flink窗口会丢数据吗 flink窗口原理

文章目录

• Flink - 基于时间窗口的操作 -（Flink - 窗口原理）

• 窗口的一些概念和窗口处理流程

• 窗口
• 窗口分配器、触发器与驱逐器
• Trigger 的返回值 TriggerResult
• Evictor
• 元素进入窗口的处理流程

• Flink - 窗口原理

• SlidingEventTimeWindows
• EventTimeSessionWindows

• 第一条元素 (a,1) 到来
• 第二条元素 (a,2) 到来
• 第三条元素 (a,9) 到来

• countWindow

Flink - 基于时间窗口的操作 -（Flink - 窗口原理）

窗口的一些概念和窗口处理流程

窗口

窗口分为全局窗口（GlobalWindow）和时间窗口（TimeWindow）

窗口分配器、触发器与驱逐器

Window Assigner：用来决定某个元素被分配到哪个/哪些窗口中去
Trigger：触发器。决定了一个窗口何时能够被计算或清除，每个窗口都会拥有一个自己的 Trigger

Trigger 的返回值 TriggerResult

CONTINUE 不做任何事情
FIRE 触发 window
PURGE 清空整个 window 的元素并销毁窗口
FIRE_AND_PURGE 触发窗口，然后销毁窗口

Evictor

Evictor 可以译为"驱逐者"
在Trigger触发之后，在窗口被处理之前，Evictor（如果有Evictor的话）会用来剔除窗口中不需要的元素，相当于一个filter

元素进入窗口的处理流程

1、每条进入窗口的元素都会交由 WindowAssigner 处理，WindowAssigner 会决定元素被放到那个或哪些窗口 一个元素可以放入多个窗口
2、window 本身就是一个 ID 标识 并不存储窗口中的元素 内部可能存储一些元数据 如 TimeWindow 中有开始和结束时间，窗口中的元素实际存储在 Key/Value State 中，key 为 Window，value 为元素集合（或聚合值）
3、每个 window 都有一个 Trigger 用来决定窗口何时被触发或清除
4、Trigger被调用：

• 有元素加入当前窗口
• 之前注册的定时器到期了

5、Trigger的返回结果 TriggerResult：

• continue 不做任何操作
• fire 处理窗口数据：计算窗口并保留窗口原样，也就是说窗口中的数据仍保留不变，下次 Trigger fire 的时候再次参与计算
• purge 移除窗口和窗口中的数据：一个窗口可以被重复计算多次直到它被 purge 了 在 purge 之前，窗口会一直占用着内存
• fire + purge 触发并清除窗口

6、当 Trigger Fire 了，窗口中的元素集合就会交给 Evictor（如果指定了的话）

• Evictor: 遍历窗口中的元素列表
• 移除最先进入窗口的多少个元素
• 剩余的元素交由指定的函数进行窗口的计算

如果没有 Evictor 窗口中的所有元素会一起交给指定的函数进行计算

计算函数收到窗口的元素(可能经过了 Evictor 的过滤),计算出窗口结果并发送给下游

Flink - 窗口原理

.windowAll(org.apache.flink.streaming.api.windowing.assigners.GlobalWindows.create())
.countWindow(5,2)
.countWindow(5)
.window(ProcessingTimeSessionWindows.withGap(Time.seconds(5)))
.window(EventTimeSessionWindows.withGap(Time.seconds(5L)))
.window(TumblingProcessingTimeWindows.of(Time.seconds(5L)))
.window(TumblingEventTimeWindows.of(Time.seconds(5L)))
.window(SlidingProcessingTimeWindows.of(Time.seconds(5L),Time.seconds(2L)))
.window(SlidingEventTimeWindows.of(Time.seconds(5L), Time.seconds(2L)))

public class Win {

    public static void main(String[] args) throws Exception {

        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

        env.setParallelism(1);

        DataStreamSource<String> streamSource = env
                .socketTextStream("hadoop102", 9099);

        SingleOutputStreamOperator<Tuple2<String, Long>> flatMapStream = streamSource
                .flatMap(
                        new FlatMapFunction<String, Tuple2<String, Long>>() {
                            @Override
                            public void flatMap(String value, Collector<Tuple2<String, Long>> out) throws Exception {
                                String[] elems = value.split(" ");
                                out.collect(Tuple2.of(elems[0], Long.parseLong(elems[1]) * 1000));
                            }
                        }
                );

        SingleOutputStreamOperator<Tuple2<String, Long>> withWatermarkStream = flatMapStream
                .assignTimestampsAndWatermarks(
                        WatermarkStrategy
                                .<Tuple2<String, Long>>forBoundedOutOfOrderness(Duration.ofSeconds(0L))
                                .withTimestampAssigner(
                                        new SerializableTimestampAssigner<Tuple2<String, Long>>() {
                                            @Override
                                            public long extractTimestamp(Tuple2<String, Long> element, long recordTimestamp) {
                                                return element.f1;
                                            }
                                        }
                                )
                );

        KeyedStream<Tuple2<String, Long>, String> keyedStream = withWatermarkStream
                .keyBy(
                        new KeySelector<Tuple2<String, Long>, String>() {
                            @Override
                            public String getKey(Tuple2<String, Long> value) throws Exception {
                                return value.f0;
                            }
                        }
                );

//        withWatermarkStream
//                .windowAll(org.apache.flink.streaming.api.windowing.assigners.GlobalWindows.create());

        WindowedStream<Tuple2<String, Long>, String, TimeWindow> winStream = keyedStream
                .countWindow(5, 2)
//                .countWindow(5)
//                .window(ProcessingTimeSessionWindows.withGap(Time.seconds(5)))
//                .window(EventTimeSessionWindows.withGap(Time.seconds(5L)))
//                .window(TumblingProcessingTimeWindows.of(Time.seconds(5L)))
//                .window(TumblingEventTimeWindows.of(Time.seconds(5L)))
//                .window(SlidingProcessingTimeWindows.of(Time.seconds(5L),Time.seconds(2L)))
//                .window(SlidingEventTimeWindows.of(Time.seconds(5L), Time.seconds(2L)));

        SingleOutputStreamOperator<String> countWinStream = winStream
                .process(
                        new ProcessWindowFunction<Tuple2<String, Long>, String, String, TimeWindow>() {
                            @Override
                            public void process(String key, Context context, Iterable<Tuple2<String, Long>> elements, Collector<String> out) throws Exception {

                                Timestamp winStart = new Timestamp(context.window().getStart());
                                Timestamp winEnd = new Timestamp(context.window().getEnd());

                                long count = elements.spliterator().getExactSizeIfKnown();

                                out.collect("key = " + key + ", win [ " + winStart + " - " + winEnd + " ), 窗口有 " + count + " 条元素");

                            }
                        }
                );

        countWinStream
                .print();


        env.execute();


    }

}

SlidingEventTimeWindows

nc -lk 9099
a 1
a 2
a 3

程序启动初始化窗口分配器

根据窗口分配器创建 WindowedStream

位窗口分配器创建默认的触发器

窗口中第一条元素到来交由 org.apache.flink.streaming.runtime.operators.windowing.WindowOperator#processElement 方法处理分配窗口

进入 org.apache.flink.streaming.api.windowing.assigners.SlidingEventTimeWindows#assignWindows 方法为元素分配窗口

最终元素会被分配到 [-2000,3000) 与 [0,5000) 的窗口

元素分配到指定窗口后返回元素所属的窗口，回到 org.apache.flink.streaming.runtime.operators.windowing.WindowOperator#processElement 方法

判断窗口分配器是否是 session 类型的窗口，如果是遍历所有窗口，判断是否需要 merge 窗口，我们此处是滚动事件窗口，因此跳过进入 else 分支

进入 else 分支

1、元素事件时间小于窗口的数据丢弃

2、为窗口创建一个 State (所有窗口共享，在 WindowOperator 初始化时创建)，并将元素数存入，每个窗口的元素通过当前窗口的 Namespace 区分

3、获取窗口的 TriggerResult，每一条元素都有进入org.apache.flink.streaming.api.windowing.triggers.EventTimeTrigger#onElement方法获取 TriggerResult

4、判断窗口是否触发，如果是，触发窗口计算

5、判断是否清空窗口

6、注册触发窗口的定时器

7、判断元素是否要输出到侧输出流（所有类型的窗口分配器都会执行该步骤）

输入 a 3 触发窗口 watermark = 3 - 1 ms = 29999 ms，定时器触发 ，timer 原理时将详细描述触发过程

获取 TriggerResult

org.apache.flink.streaming.api.windowing.triggers.EventTimeTrigger#onElement

EventTimeSessionWindows

第一条元素 (a,1) 到来

初始化 EventTimeSessionWindows org.apache.flink.streaming.api.windowing.assigners.EventTimeSessionWindows

创建 WindowedStream org.apache.flink.streaming.api.datastream.WindowedStream

默认触发器 org.apache.flink.streaming.api.windowing.assigners.EventTimeSessionWindows#getDefaultTrigger

输入第一条元素 (a,1)

为元素分配窗口 org.apache.flink.streaming.runtime.operators.windowing.WindowOperator#processElement

org.apache.flink.streaming.api.windowing.assigners.EventTimeSessionWindows#assignWindows

回到 org.apache.flink.streaming.runtime.operators.windowing.WindowOperator#processElement 方法

创建 MergingWindowSet

org.apache.flink.streaming.runtime.operators.windowing.MergingWindowSet#MergingWindowSet

将当前元素的窗口和之前的窗口进行 merge

合并窗口 org.apache.flink.streaming.runtime.operators.windowing.MergingWindowSet#addWindow

TimeWindow 合并窗口操作 org.apache.flink.streaming.api.windowing.windows.TimeWindow#mergeWindows，mergeWindows 方法是专门为 session 合并窗口而定义的方法，同时配备有 mergeTrigger、mergeTimer 等方法

1、将所有窗口存入一个集合

2、对集合中的窗口按窗口开始时间排序

3、创建一个集合用于保存所有 merge 后的窗口，创建一个 元组保存正在 merge 的窗口

4、遍历所有窗口判断是否合并

合并完后回到 org.apache.flink.streaming.runtime.operators.windowing.MergingWindowSet#addWindow 方法

返回 org.apache.flink.streaming.runtime.operators.windowing.WindowOperator#processElement 方法

第二条元素 (a,2) 到来

为 (a,2) 元素分配窗口org.apache.flink.streaming.runtime.operators.windowing.WindowOperator#processElement

获取 MergingWindowSet org.apache.flink.streaming.runtime.operators.windowing.MergingWindowSet#MergingWindowSet

通过 MergingWindowSet 合并窗口

org.apache.flink.streaming.runtime.operators.windowing.MergingWindowSet#addWindow

1、创建一个空集合，并将 MergingWindowSet 状态中的旧窗口信息和当前元素的新窗口信息添加到集合中

2、通过TimeWindow mergeWindows 方法合并窗口

3、org.apache.flink.streaming.api.windowing.windows.TimeWindow#mergeWindowsmerge 窗口

将所有窗口存入一个 List 集合

按窗口起始时间升序排序

创建一个空的集合和二元组用于存储合并后的结果和正在 merge 的窗口

合并窗口操作

遍历第一个窗口 [1000,6000)

初始化二元组，f0：（当前排序中）起始时间最小的窗口，f1：被合并的窗口集合

遍历第二个窗口 [2000,7000)

由于第一步已经创建好了 currentMerge 因此走第二个分支，判断是否需要合并窗口

判断两个窗口是否相交

通过 cover 方法合并，合并方式就是创建一个新的窗口，新窗口的开始时间为两个窗口最小的时间，结束时间同理，然后返回新的窗口

将窗口放入被合并的窗口集合中

更新合并窗口的集合中

回调 org.apache.flink.streaming.runtime.operators.windowing.MergingWindowSet#addWindow 方法中的 MergingWindowAssigner.MergeCallback 具体实现，将合并后的数据保存到 map 中

返回 org.apache.flink.streaming.runtime.operators.windowing.MergingWindowSet#addWindow 方法

执行其他 merge 操作，主要 merge 定时器和状态

返回 org.apache.flink.streaming.runtime.operators.windowing.WindowOperator#processElement 方法中执行具体的 MergeFunction 实现

合并触发器 org.apache.flink.streaming.api.windowing.triggers.EventTimeTrigger#onMerge

清空被合并窗口的触发器上下文信息和定时器

merge namespace 和 state

最后再次返回 org.apache.flink.streaming.runtime.operators.windowing.WindowOperator#processElement 方法

处理迟到元素

获取 mapping 中被合并的窗口，这一步需要结合 org.apache.flink.streaming.runtime.operators.windowing.MergingWindowSet#addWindow方法中

将当前元素添加到 state 中

获取触发器

更新状态 org.apache.flink.streaming.runtime.operators.windowing.MergingWindowSet#persist

侧输出流处理

第三条元素 (a,9) 到来

分配窗口 [9000,14000)

初始 MergingWindowSet

合并窗口 org.apache.flink.streaming.runtime.operators.windowing.MergingWindowSet#addWindow

执行合并操作 org.apache.flink.streaming.api.windowing.windows.TimeWindow#mergeWindows

定时器触发窗口

countWindow

public class Win {

    public static void main(String[] args) throws Exception {

        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

        env.setParallelism(1);

        DataStreamSource<String> streamSource = env
                .socketTextStream("hadoop102", 9099);

        SingleOutputStreamOperator<Tuple2<String, Long>> flatMapStream = streamSource
                .flatMap(
                        new FlatMapFunction<String, Tuple2<String, Long>>() {
                            @Override
                            public void flatMap(String value, Collector<Tuple2<String, Long>> out) throws Exception {
                                String[] elems = value.split(" ");
                                out.collect(Tuple2.of(elems[0], Long.parseLong(elems[1]) * 1000));
                            }
                        }
                );

        SingleOutputStreamOperator<Tuple2<String, Long>> withWatermarkStream = flatMapStream
                .assignTimestampsAndWatermarks(
                        WatermarkStrategy
                                .<Tuple2<String, Long>>forBoundedOutOfOrderness(Duration.ofSeconds(0L))
                                .withTimestampAssigner(
                                        new SerializableTimestampAssigner<Tuple2<String, Long>>() {
                                            @Override
                                            public long extractTimestamp(Tuple2<String, Long> element, long recordTimestamp) {
                                                return element.f1;
                                            }
                                        }
                                )
                );

        KeyedStream<Tuple2<String, Long>, String> keyedStream = withWatermarkStream
                .keyBy(
                        new KeySelector<Tuple2<String, Long>, String>() {
                            @Override
                            public String getKey(Tuple2<String, Long> value) throws Exception {
                                return value.f0;
                            }
                        }
                );

//        withWatermarkStream
//                .windowAll(org.apache.flink.streaming.api.windowing.assigners.GlobalWindows.create());
//
//        WindowedStream<Tuple2<String, Long>, String, TimeWindow> winStream = keyedStream
                .countWindow(5, 2)
                .countWindow(5)
                .window(ProcessingTimeSessionWindows.withGap(Time.seconds(5)))
//                .window(EventTimeSessionWindows.withGap(Time.seconds(5L)));
                .window(TumblingProcessingTimeWindows.of(Time.seconds(5L)))
                .window(TumblingEventTimeWindows.of(Time.seconds(5L)))
                .window(SlidingProcessingTimeWindows.of(Time.seconds(5L),Time.seconds(2L)))
                .window(SlidingEventTimeWindows.of(Time.seconds(5L), Time.seconds(2L)));
//
//        SingleOutputStreamOperator<String> countWinStream = winStream
//                .process(
//                        new ProcessWindowFunction<Tuple2<String, Long>, String, String, TimeWindow>() {
//                            @Override
//                            public void process(String key, Context context, Iterable<Tuple2<String, Long>> elements, Collector<String> out) throws Exception {
//
//                                Timestamp winStart = new Timestamp(context.window().getStart());
//                                Timestamp winEnd = new Timestamp(context.window().getEnd());
//
//                                long count = elements.spliterator().getExactSizeIfKnown();
//
//                                out.collect("key = " + key + ", win [ " + winStart + " - " + winEnd + " ), 窗口有 " + count + " 条元素，当前的 watermark = " + context.currentWatermark());
//
//                            }
//                        }
//                );
//
//        countWinStream
//                .print();


        WindowedStream<Tuple2<String, Long>, String, GlobalWindow> winStream = keyedStream
                .countWindow(5, 2);

        winStream
                .process(
                        new ProcessWindowFunction<Tuple2<String, Long>, String, String, GlobalWindow>() {
                            @Override
                            public void process(String key, Context context, Iterable<Tuple2<String, Long>> elements, Collector<String> out) throws Exception {
                                out.collect("key = " + key + ", 窗口有 " + elements.spliterator().getExactSizeIfKnown() + " 条元素 ");
                            }
                        }
                )
                .print();


        env.execute();


    }

}

初始化 WindowedStream

初始化全局窗口分配器

初始化 WindowedStream org.apache.flink.streaming.api.datastream.WindowedStream#WindowedStream

初始化 CountEvictor

给窗口添加 evictor org.apache.flink.streaming.api.datastream.WindowedStream#evictor

初始化 CountTrigger

为窗口添加 trigger org.apache.flink.streaming.api.datastream.WindowedStream#trigger

第一条元素来了，分配窗口 org.apache.flink.streaming.runtime.operators.windowing.EvictingWindowOperator#processElement

获取触发器 org.apache.flink.streaming.api.windowing.triggers.CountTrigger#onElement

第二条元素到来

驱逐窗口中的元素 org.apache.flink.streaming.runtime.operators.windowing.EvictingWindowOperator#emitWindowContents

org.apache.flink.streaming.api.windowing.evictors.CountEvictor#evictBefore

org.apache.flink.streaming.api.windowing.evictors.CountEvictor#evict

执行 process 方法

第六条元素到来

驱逐窗口中的元素 org.apache.flink.streaming.runtime.operators.windowing.EvictingWindowOperator#emitWindowContents

org.apache.flink.streaming.runtime.operators.windowing.EvictingWindowOperator.EvictorContext#evictBefore

org.apache.flink.streaming.api.windowing.evictors.CountEvictor#evictBefore

org.apache.flink.streaming.api.windowing.evictors.CountEvictor#evict