大数据与流处理 / 系统课时

定时器服务

定时器服务

本课通过一个订单超时示例同时注册事件时间和处理时间定时器。你将掌握两类时钟的触发条件、定时器替换与删除方式,以及恢复、去重和 Watermark 停滞等生产边界。

学习目标

  • 区分事件时间定时器与处理时间定时器的推进依据
  • 正确注册、删除并识别两类定时器回调
  • 使用状态保存定时器时间戳,实现可重置的超时逻辑

两类定时器如何推进

处理时间来自执行算子所在机器的系统时钟,适合重试、周期刷新和低延迟任务,但结果会受机器负载、背压和故障恢复影响。事件时间来自数据携带的业务时间,只有 Watermark 达到或超过目标时间戳时才触发,更适合订单超时、乱序事件等待和历史数据重放。

事件时间与处理时间定时器对比时间轴

对比项 处理时间定时器 事件时间定时器
注册方法 registerProcessingTimeTimer registerEventTimeTimer
删除方法 deleteProcessingTimeTimer deleteEventTimeTimer
推进依据 TaskManager 系统时钟 当前算子的 Watermark
典型用途 延迟重试、缓存刷新、心跳检查 业务超时、乱序等待、可重放计算
确定性 较低 Watermark 策略稳定时较高

注册、替换与回调规则

同一个键、同一种时间域、同一个时间戳最多保留一个定时器,重复注册只会回调一次。业务上需要“最后一次事件后再等待 N 秒”时,应把最新定时器时间戳保存在 ValueState 中,新事件到达后先删除旧定时器,再注册新的截止时间。

onTimer 与 processElement 不会并发修改同一个算子状态,因此普通键控状态不需要额外加锁。故障恢复时,定时器会和状态一起恢复;已经过期的处理时间定时器可能在恢复后立即触发,回调逻辑必须具备幂等性。

主示例:订单超时与延迟检查

程序从本机 <PORT> 端口读取 订单号,事件时间戳。每条订单事件注册一个 3 秒后的处理时间检查,以及一个事件时间后 5 秒的业务超时;再次收到同一订单时,两类定时器都会被重置。

java
import org.apache.flink.api.common.eventtime.WatermarkStrategy;
import org.apache.flink.api.common.functions.OpenContext;
import org.apache.flink.api.common.state.ValueState;
import org.apache.flink.api.common.state.ValueStateDescriptor;
import org.apache.flink.api.common.typeinfo.Types;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.streaming.api.TimeDomain;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.KeyedProcessFunction;
import org.apache.flink.util.Collector;

public class TimerServiceJob {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env =
                StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);

        DataStream<Tuple2<String, Long>> events = env
                .socketTextStream("localhost", 9999)
                .map(line -> {
                    String[] parts = line.trim().split(",");
                    return Tuple2.of(parts[0], Long.parseLong(parts[1]));
                })
                .returns(Types.TUPLE(Types.STRING, Types.LONG))
                .assignTimestampsAndWatermarks(
                        WatermarkStrategy
                                .<Tuple2<String, Long>>forMonotonousTimestamps()
                                .withTimestampAssigner((event, previous) -> event.f1));

        events.keyBy(event -> event.f0)
                .process(new OrderTimerFunction())
                .print();

        env.execute("timer-service-demo");
    }

    private static class OrderTimerFunction
            extends KeyedProcessFunction<String, Tuple2<String, Long>, String> {
        private ValueState<Long> eventTimerState;
        private ValueState<Long> processingTimerState;

        @Override
        public void open(OpenContext openContext) throws Exception {
            eventTimerState = getRuntimeContext().getState(
                    new ValueStateDescriptor<>("event-timer", Long.class));
            processingTimerState = getRuntimeContext().getState(
                    new ValueStateDescriptor<>("processing-timer", Long.class));
        }

        @Override
        public void processElement(
                Tuple2<String, Long> value,
                Context ctx,
                Collector<String> out) throws Exception {
            Long oldEventTimer = eventTimerState.value();
            if (oldEventTimer != null) {
                ctx.timerService().deleteEventTimeTimer(oldEventTimer);
            }
            Long oldProcessingTimer = processingTimerState.value();
            if (oldProcessingTimer != null) {
                ctx.timerService().deleteProcessingTimeTimer(oldProcessingTimer);
            }

            long eventTimer = value.f1 + 5000L;
            long processingTimer =
                    ctx.timerService().currentProcessingTime() + 3000L;

            ctx.timerService().registerEventTimeTimer(eventTimer);
            ctx.timerService().registerProcessingTimeTimer(processingTimer);
            eventTimerState.update(eventTimer);
            processingTimerState.update(processingTimer);

            out.collect("received order=" + value.f0
                    + " eventTimer=" + eventTimer);
        }

        @Override
        public void onTimer(
                long timestamp,
                OnTimerContext ctx,
                Collector<String> out) throws Exception {
            if (ctx.timeDomain() == TimeDomain.PROCESSING_TIME
                    && Long.valueOf(timestamp).equals(processingTimerState.value())) {
                out.collect("processing-delay order=" + ctx.getCurrentKey());
                processingTimerState.clear();
            }

            if (ctx.timeDomain() == TimeDomain.EVENT_TIME
                    && Long.valueOf(timestamp).equals(eventTimerState.value())) {
                out.collect("event-timeout order=" + ctx.getCurrentKey()
                        + " timer=" + timestamp);
                eventTimerState.clear();
            }
        }
    }
}

先启动输入端口,再运行 Java 作业。示例使用固定端口 9999;实际环境可替换为其他 <PORT>,但启动命令与代码必须保持一致。

bash
nc -lk 9999

依次输入第一行,等待至少 3 秒,再输入第二行:

text
order-1,1000
order-2,7000

预期输出如下。处理时间检查会在第一条输入约 3 秒后出现;第二条事件把 Watermark 推进到足以触发 order-1 的事件时间定时器。控制台前缀与行间穿插顺序可能不同。

text
received order=order-1 eventTimer=6000
processing-delay order=order-1
received order=order-2 eventTimer=12000
event-timeout order=order-1 timer=6000

生产使用边界

事件时间定时器迟迟不触发时,先检查上游是否分配时间戳、Watermark 是否推进,以及多并行分区中是否存在空闲分区。处理时间定时器大量集中触发时,应避免在回调中执行阻塞 I/O,可把外部调用改为异步 I/O,并让输出或状态更新具备幂等性。

定时器属于检查点状态的一部分。每条事件注册多个毫秒级定时器会增大快照体积,可按秒或分钟对目标时间取整,让同一键的多个逻辑任务合并到较少的物理定时器中,再在状态里判断真正到期的任务。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

定时器服务

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通