Flink(1.13) 的window机制(一)

窗口概述

在流处理应用中，数据是连续不断的，因此我们不可能等到所有数据都到了才开始处理。当然我们可以每来一个消息就处理一次，但是有时我们需要做一些聚合类的处理，例如：在过去的1分钟内有多少用户点击了我们的网页。在这种情况下，我们必须定义一个窗口，用来收集最近一分钟内的数据，并对这个窗口内的数据进行计算。

流式计算是一种被设计用于处理无限数据集的数据处理引擎，而无限数据集是指一种不断增长的本质上无限的数据集，而Window窗口是一种切割无限数据为有限块进行处理的手段。

在Flink中, 窗口(window)是处理无界流的核心. 窗口把流切割成有限大小的多个"存储桶"(bucket), 我们在这些桶上进行计算.

image.png

窗口的分类

窗口分类

窗口分为2类:

1. 基于时间的窗口(时间驱动)
2. 基于元素个数的(数据驱动)

WindowAssigner

WindowAssigner 是一个抽象类，是所有窗口策略父类。

public abstract class WindowAssigner implements Serializable {}

WindowAssigner下所有的子类

SlidingProcessingTimeWindows (org.apache.flink.streaming.api.windowing.assigners)
按照处理时间进行窗口滑动
of 的重载方法

• of(Time size, Time slide)
  size:窗口长度
  slide：滑动步长
• of(Time size, Time slide, Time offset)
  offset：时区

BaseAlignedWindowAssigner (org.apache.flink.streaming.api.windowing.assigners)

TumblingEventTimeWindows (org.apache.flink.streaming.api.windowing.assigners)

    TumblingTimeWindows (org.apache.flink.streaming.api.windowing.assigners)

MergingWindowAssigner (org.apache.flink.streaming.api.windowing.assigners)

    DynamicProcessingTimeSessionWindows(org.apache.flink.streaming.api.windowing.assigners)

    ProcessingTimeSessionWindows(org.apache.flink.streaming.api.windowing.assigners)
    按照处理时间划分session，该方式为静态gap。
    withGap ：窗口间隔时长，gap时间内的会划为一个窗口，这是一个合并的操作，这也说明为啥是MergingWindowAssigner 子类的原因。

    DynamicEventTimeSessionWindows(org.apache.flink.streaming.api.windowing.assigners)

    EventTimeSessionWindows(org.apache.flink.streaming.api.windowing.assigners)

TumblingProcessingTimeWindows (org.apache.flink.streaming.api.windowing.assigners)
按照处理时间进行窗口滚动
of 的重载方法

• of(Time size)
  size：窗口长度
• of(Time size, Time offset)
  offset：配置时区
• of(Time size, Time offset, WindowStagger windowStagger)
  windowStagger：窗口交错

SlidingEventTimeWindows(org.apache.flink.streaming.api.windowing.assigners)

    SlidingTimeWindows (org.apache.flink.streaming.api.windowing.assigners)

GlobalWindows (org.apache.flink.streaming.api.windowing.assigners)

Time

    public static Time of(long size, TimeUnit unit) {
        return new Time(size, unit);
    }

    /** Creates a new {@link Time} that represents the given number of milliseconds. */
    public static Time milliseconds(long milliseconds) {
        return of(milliseconds, TimeUnit.MILLISECONDS);
    }

    /** Creates a new {@link Time} that represents the given number of seconds. */
    public static Time seconds(long seconds) {
        return of(seconds, TimeUnit.SECONDS);
    }

    /** Creates a new {@link Time} that represents the given number of minutes. */
    public static Time minutes(long minutes) {
        return of(minutes, TimeUnit.MINUTES);
    }

    /** Creates a new {@link Time} that represents the given number of hours. */
    public static Time hours(long hours) {
        return of(hours, TimeUnit.HOURS);
    }

    /** Creates a new {@link Time} that represents the given number of days. */
    public static Time days(long days) {
        return of(days, TimeUnit.DAYS);
    }

WindowStagger

public enum WindowStagger {
    /** Default mode, all panes fire at the same time across all partitions. */
    ALIGNED {
        @Override
        public long getStaggerOffset(final long currentProcessingTime, final long size) {
            return 0L;
        }
    },

    /**
     * Stagger offset is sampled from uniform distribution U(0, WindowSize) when first event
     * ingested in the partitioned operator.
     */
    RANDOM {
        @Override
        public long getStaggerOffset(final long currentProcessingTime, final long size) {
            return (long) (ThreadLocalRandom.current().nextDouble() * size);
        }
    },

    /**
     * When the first event is received in the window operator, take the difference between the
     * start of the window and current procesing time as the offset. This way, windows are staggered
     * based on when each parallel operator receives the first event.
     */
    NATURAL {
        @Override
        public long getStaggerOffset(final long currentProcessingTime, final long size) {
            final long currentProcessingWindowStart =
                    TimeWindow.getWindowStartWithOffset(currentProcessingTime, 0, size);
            return Math.max(0, currentProcessingTime - currentProcessingWindowStart);
        }
    };

    public abstract long getStaggerOffset(final long currentProcessingTime, final long size);
}

基于时间的窗口

时间窗口包含一个开始时间戳(包括)和结束时间戳(不包括), 这两个时间戳一起限制了窗口的尺寸.
在代码中, Flink使用TimeWindow这个类来表示基于时间的窗口. 这个类提供了key查询开始时间戳和结束时间戳的方法, 还提供了针对给定的窗口获取它允许的最大时间戳的方法(maxTimestamp())。

时间窗口可以理解成一个桶，装有各种各样的元素，
相同的元素会存放到同一个窗口（如下图），统计窗口0_{5的数据，其实每个元素都有0}5的窗口。
注意：(a,4)，表示有 4个a，而不是a的个数为4。

时间窗口又分4种:

1.滚动窗口(Tumbling Windows)

滚动窗口有固定的大小, 窗口与窗口之间不会重叠也没有缝隙.比如,如果指定一个长度为5分钟的滚动窗口, 当前窗口开始计算, 每5分钟启动一个新的窗口。
滚动窗口能将数据流切分成不重叠的窗口，每一个事件只能属于一个窗口。

滚动窗口

• 没有间隙
• 没有重叠
• 窗口长度

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

        Configuration config=new Configuration();
        config.setInteger("rest.port",8081); // 配置固定端口

        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment(config);


        DataStreamSource source = env.socketTextStream("mydocker", 9999);

        // 扁平化
        SingleOutputStreamOperator> flatMap = source.flatMap((FlatMapFunction>) (value, out) -> {
            Arrays.stream(value.split(" ")).forEach(s -> out.collect(Tuple2.of(s, 1L)));
        }).returns(Types.TUPLE(Types.STRING, Types.LONG));

        // 聚合
        KeyedStream, String> keyBy = flatMap.keyBy(s -> s.f0);

        // 设置窗口为5秒
        WindowedStream, String, TimeWindow> window = keyBy.window(TumblingProcessingTimeWindows.of(Time.seconds(5l)));

        // 聚合
        window.sum(1).print();

        env.execute();

    }

输入

java python java scala

输出：并不会立即输出，需要等待窗口关闭之后才能进行输出

5> (python,2)
1> (scala,1)
3> (java,3)

2.滑动窗口(Sliding Windows)

与滚动窗口一样, 滑动窗口也是有固定的长度. 另外一个参数我们叫滑动步长, 用来控制滑动窗口启动的频率.

所以, 如果滑动步长小于窗口长度, 滑动窗口会重叠. 这种情况下, 一个元素可能会被分配到多个窗口中

例如, 滑动窗口长度10分钟, 滑动步长5分钟, 则, 每5分钟会得到一个包含最近10分钟的数据.

滑动窗口

• 固定长度
• 滑动步长
• 滑动步长<窗口长度，会造成数据重复
• 滑动步长>窗口长度，会造成数据丢失

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

        Configuration config=new Configuration();
        config.setInteger("rest.port",8081); // 配置固定端口

        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment(config);


        DataStreamSource source = env.socketTextStream("mydocker", 9999);

        // 扁平化
        SingleOutputStreamOperator> flatMap = source.flatMap((FlatMapFunction>) (value, out) -> {
            Arrays.stream(value.split(" ")).forEach(s -> out.collect(Tuple2.of(s, 1L)));
        }).returns(Types.TUPLE(Types.STRING, Types.LONG));

        // 聚合
        KeyedStream, String> keyBy = flatMap.keyBy(s -> s.f0);

        //窗口长度为5，没3秒统计一次。
        SlidingProcessingTimeWindows windows = SlidingProcessingTimeWindows.of(Time.seconds(5),Time.seconds(3));

        WindowedStream, String, TimeWindow> window = keyBy.window(windows);

        // 聚合
        window.sum(1).print();

        env.execute();

    }

输出

12> (,1)
5> (python,9)
3> (java,9)
5> (python,2)
3> (java,2)

3.会话窗口(Session Windows)

会话窗口分配器会根据活动的元素进行分组. 会话窗口不会有重叠, 与滚动窗口和滑动窗口相比, 会话窗口也没有固定的开启和关闭时间.

如果会话窗口有一段时间没有收到数据, 会话窗口会自动关闭, 这段没有收到数据的时间就是会话窗口的gap(间隔)

我们可以配置静态的gap, 也可以通过一个gap extractor 函数来定义gap的长度. 当时间超过了这个gap, 当前的会话窗口就会关闭, 后序的元素会被分配到一个新的会话窗口

会话窗口

• 按照key进行分组(划分一个新的窗口)
• 不会造成数据重叠
• 没有固定开启和关闭时间
• 若一段时间内没有数据，窗口自动关闭
• 可以设置静态gap和动态gap

静态 gap

ProcessingTimeSessionWindows windows = ProcessingTimeSessionWindows.withGap(Time.seconds(3));

    @Test
    public void test1() throws Exception {
        Configuration config=new Configuration();
        config.setInteger("rest.port",8081); // 配置固定端口

        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment(config);


        DataStreamSource source = env.socketTextStream("mydocker", 9999);

        // 扁平化
        SingleOutputStreamOperator> flatMap = source.flatMap((FlatMapFunction>) (value, out) -> {
            Arrays.stream(value.split(" ")).forEach(s -> out.collect(Tuple2.of(s, 1L)));
        }).returns(Types.TUPLE(Types.STRING, Types.LONG));

        // 聚合
        KeyedStream, String> keyBy = flatMap.keyBy(s -> s.f0);

        // 设置session时间为3秒
        ProcessingTimeSessionWindows windows = ProcessingTimeSessionWindows.withGap(Time.seconds(3));

        WindowedStream, String, TimeWindow> window = keyBy.window(windows);


        // 聚合
        window.sum(1).print();


        env.execute();
    }

动态 gap

DynamicProcessingTimeSessionWindows