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

处理迟到数据

处理迟到数据

事件时间窗口关闭后,数据仍可能因网络抖动、分区积压或重试而到达。本课用允许迟到时间保留可修正的窗口状态,再用侧输出流接住已经超过保留期限的事件,避免迟到数据被无声丢弃。

学习目标

  • 区分准时、允许范围内迟到和彻底过期的数据
  • 配置 allowedLateness 与 sideOutputLateData
  • 正确处理同一窗口的多次结果和状态保留成本

迟到数据的判定边界

Watermark 表示系统认为事件时间已经推进到的位置。对于结束时间为 windowEnd 的事件时间窗口,Watermark 到达窗口最大时间戳时会产生主触发;若配置允许迟到时间,窗口状态会继续保留到清理时间。

在保留期内到达的迟到事件仍进入原窗口,并可能让 EventTimeTrigger 再次触发。超过清理时间后到达的事件无法再修改窗口结果:配置了侧输出标签时进入侧输出流,否则会被丢弃。默认允许迟到时间为零。

允许迟到与侧输出流时间线

配置主输出与侧输出

allowedLateness 的含义不是让 Watermark 倒退,而是延后窗口状态的清理。值越大,修正机会越多,窗口状态保留越久。侧输出标签应使用匿名子类保留泛型信息,然后在窗口运算产生的 SingleOutputStreamOperator 上调用 getSideOutput。

允许范围内的迟到事件仍在主流产生更新结果,侧输出只接收已经无法进入窗口的事件。因此,下游若写入数据库或消息系统,应使用“业务键加窗口边界”作为幂等键,以更新或撤回旧结果,而不是把每次触发都当成新的独立统计。

可运行示例与结果验证

下面的教学 Source 手动发出事件时间和 Watermark,以稳定复现三种情况:首次触发、允许范围内的迟到更新、超过期限后的侧输出。生产作业应优先在 KafkaSource 等新 Source 上配置 WatermarkStrategy,不要依赖手工 Watermark。

java
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.source.SourceFunction;
import org.apache.flink.streaming.api.functions.windowing.ProcessWindowFunction;
import org.apache.flink.streaming.api.watermark.Watermark;
import org.apache.flink.streaming.api.windowing.assigners.TumblingEventTimeWindows;
import org.apache.flink.streaming.api.windowing.windows.TimeWindow;
import org.apache.flink.util.Collector;
import org.apache.flink.util.OutputTag;

import java.time.Duration;

public class LateDataDemo {

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

        OutputTag<Event> lateTag =
                new OutputTag<Event>("late-events") {};

        SingleOutputStreamOperator<String> mainResult =
                env.addSource(new DemoSource())
                        .keyBy(event -> event.user)
                        .window(TumblingEventTimeWindows.of(
                                Duration.ofSeconds(5)))
                        .allowedLateness(Duration.ofSeconds(2))
                        .sideOutputLateData(lateTag)
                        .process(new ProcessWindowFunction<
                                Event, String, String, TimeWindow>() {
                            @Override
                            public void process(
                                    String user,
                                    Context context,
                                    Iterable<Event> events,
                                    Collector<String> out) {
                                int total = 0;
                                for (Event ignored : events) {
                                    total++;
                                }
                                out.collect(
                                        "window=[" + context.window().getStart()
                                                + "," + context.window().getEnd()
                                                + "), user=" + user
                                                + ", total=" + total);
                            }
                        });

        DataStream<Event> tooLateEvents =
                mainResult.getSideOutput(lateTag);

        mainResult.print("main");
        tooLateEvents.print("late");
        env.execute("late-data-demo");
    }

    @SuppressWarnings("deprecation")
    private static final class DemoSource
            implements SourceFunction<Event> {

        private volatile boolean running = true;

        @Override
        public void run(SourceContext<Event> context) {
            synchronized (context.getCheckpointLock()) {
                if (!running) {
                    return;
                }

                context.collectWithTimestamp(
                        new Event("alice", "first", 1_000L), 1_000L);

                // 触发窗口 [0, 5000) 的第一次计算。
                context.emitWatermark(new Watermark(4_999L));

                // 在 2 秒允许迟到范围内,进入原窗口并再次触发。
                context.collectWithTimestamp(
                        new Event("alice", "late-update", 3_000L), 3_000L);

                // 超过窗口清理时间 6999,窗口状态被删除。
                context.emitWatermark(new Watermark(7_000L));

                // 该事件无法再进入主窗口,将进入侧输出流。
                context.collectWithTimestamp(
                        new Event("alice", "too-late", 2_000L), 2_000L);
            }
        }

        @Override
        public void cancel() {
            running = false;
        }
    }

    public static final class Event {
        public String user;
        public String name;
        public long eventTime;

        public Event() {
        }

        public Event(String user, String name, long eventTime) {
            this.user = user;
            this.name = name;
            this.eventTime = eventTime;
        }

        @Override
        public String toString() {
            return "Event{user='" + user
                    + "', name='" + name
                    + "', eventTime=" + eventTime + "}";
        }
    }
}

预期输出

text
main> window=[0,5000), user=alice, total=1
main> window=[0,5000), user=alice, total=2
late> Event{user='alice', name='too-late', eventTime=2000}

不同运行器可能改变打印前缀或两条输出流的显示顺序,但主流应包含同一窗口的两次结果,侧输出应只包含 too-late。这两次主流结果不是两个独立窗口,而是同一统计的旧值与更新值。

允许迟到时间不应凭经验任意放大。应根据业务可接受的修正时限和实际延迟分布设定,并监控迟到比例、侧输出数量、窗口状态大小与检查点耗时。侧输出中的数据还需要明确补偿策略,例如离线重算、告警、落盘审计或进入专门的修正链路。

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

目录与阅读设置

阅读设置

17

记录一个想法

处理迟到数据

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

登录哪都通