Flink-watermark

最新推荐文章于 2024-01-27 20:44:11 发布

安然烟火

最新推荐文章于 2024-01-27 20:44:11 发布

阅读量200

点赞数 1

分类专栏： flink 文章标签： flink

本文链接：https://blog.csdn.net/qq_30868737/article/details/113352727

版权

flink 专栏收录该内容

9 篇文章 1 订阅

订阅专栏

1 基本概念

Flink中可以让window延迟触发的一种机制
我们知道，流处理从事件产⽣，到流经source，再到operator，中间是有⼀个过程和时间的，虽然⼤部分情况下，流到operato的数据都是按照事件产⽣的时间顺序来的，但是也不排除由于⽹络、背压等原因，导致乱序的产⽣，所谓乱序，就是指Flink接收到的事件的先后顺序不是严格按照事件的Event Time顺序排列的。
在这里插入图片描述
那么此时出现⼀个问题，⼀旦出现乱序，如果只根据eventTime决定window的运⾏，我们不能明确数据是否全部到位，但⼜不能⽆限期的等下去，此时必须要有个机制来保证⼀个特定的时间后，必须触发window去进⾏计算了，这个特别的机制，就是Watermark。Watermark是⼀种衡量Event Time进展的机制，它是数据本身的⼀个隐藏属性，数据本身携带着对应Watermark。

Watermark是⽤于处理乱序事件的，⽽正确的处理乱序事件，通常⽤Watermark机制结合window来实现。数据流中的Watermark⽤于表示timestamp⼩于Watermark的数据，都已经到达了，因此，window的执⾏也是由Watermark触发的。

Watermark可以理解成⼀个延迟触发机制，我们可以设置Watermark的延时时⻓t，每次系统会校验已经到达的数据中最⼤的maxEventTime，然后认定eventTime⼩于maxEventTime- t的所有数据都已经到达，如果有窗⼝的停⽌时间等于maxEventTime – t，那么这个窗⼝被触发执⾏。

有序流的Watermarker如下图所示：（Watermark设置为0）

乱序流的Watermarker如下图所示：（Watermark设置为2）
在这里插入图片描述
当Flink接收到每一条数据时，都会产⽣一条Watermark，这条Watermark就等于当前所有到达数据中的maxEventTime - 延迟时⻓长，也就是说，Watermark是由数据携带的，一旦数据携带的Watermark比当前未触发的窗口的停止时间要晚，那么就会触发相应窗口的执行。由于Watermark是由数据携带的，因此，如果运行过程中⽆法获取新的数据，那么没有被触发的窗口将永远都不不被触发。

上图中，我们设置的允许最大延迟到达时间为2s，所以时间戳为7s的事件对应的Watermark是5s，时间戳为12s的事件的Watermark是10s，如果我们的窗口1是1s_{5s，窗口2是6s}10s，那么时间戳为7s的事件到达时的Watermarker恰好触发窗口1，时间戳为12s的事件到达时的Watermark恰好触发窗口2。

2 引入watermark

val env = StreamExecutionEnvironment.getExecutionEnvironment
// 从调⽤时刻开始给env创建的每⼀个stream追加时间特征
env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime)
val stream = env.readTextFile("eventTest.txt").assignTimestampsAndWatermarks(
 new BoundedOutOfOrdernessTimestampExtractor[String](Time.milliseconds(200)) {
 override def extractTimestamp(t: String): Long = {
 // EventTime是⽇志⽣成时间，我们从⽇志中解析EventTime
 t.split(" ")(0).toLong
 }
})

3 EventTimeWindow API

当使⽤EventTimeWindow时，所有的Window在EventTime的时间轴上进⾏划分，也就是说，在Window启动后，会根据初始的EventTime时间每隔⼀段时间划分⼀个窗⼝，如果Window⼤⼩是3秒，那么1分钟内会把Window划分为如下的形式：

[00:00:00,00:00:03)
[00:00:03,00:00:06)
…
[00:00:57,00:01:00)

如果Window⼤⼩是10秒，则Window会被分为如下的形式：

[00:00:00,00:00:10)
[00:00:10,00:00:20)
…
[00:00:50,00:01:00)

注意，窗⼝是左闭右开的，形式为：[window_start_time,window_end_time)。

Window的设定⽆关数据本身，⽽是系统定义好了的，也就是说，Window会⼀直按照指定的时间间隔进⾏划分，不论这个Window中有没有数据，EventTime在这个Window期间的数据会进⼊这个Window。

Window会不断产⽣，属于这个Window范围的数据会被不断加⼊到Window中，所有未被触发的Window都会等待触发，只要Window还没触发，属于这个Window范围的数据就会⼀直被加⼊到Window中，直到Window被触发才会停⽌数据的追加，⽽当Window触发之后才接受到的属于被触发Window的数据会被丢弃。

Window会在以下的条件满⾜时被触发执⾏：
watermark时间 >= window_end_time；
在[window_start_time,window_end_time)中有数据存在。

我们通过下图来说明Watermark、EventTime和Window的关系。

3.1 滚动窗口(TumblingEventTimeWindows)

package com.wedoctor.flink;

import org.apache.flink.api.common.functions.MapFunction;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.configuration.Configuration;
import org.apache.flink.streaming.api.TimeCharacteristic;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.datastream.KeyedStream;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.datastream.WindowedStream;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.timestamps.BoundedOutOfOrdernessTimestampExtractor;
import org.apache.flink.streaming.api.windowing.assigners.TumblingEventTimeWindows;
import org.apache.flink.streaming.api.windowing.time.Time;
import org.apache.flink.streaming.api.windowing.windows.TimeWindow;

public class WaterMarkDemo1 {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.createLocalEnvironmentWithWebUI(new Configuration());
        //设置EventTime作为时间标准
        env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime);
        //1000,spark,1
        DataStreamSource<String> lines = env.socketTextStream("localhost", 8888);
        //直接对Source提取EventTime
        SingleOutputStreamOperator<String> watermarksDataStream = lines.assignTimestampsAndWatermarks(new BoundedOutOfOrdernessTimestampExtractor<String>(Time.seconds(2)) {
            @Override
            public long extractTimestamp(String element) {
                //当前分区中数据中最大的EventTime - 延迟时间 = 该分区的WaterMark
                return Long.parseLong(element.split(",")[0]);
            }
        });
        SingleOutputStreamOperator<Tuple2<String, Integer>> wordAndCount = watermarksDataStream.map(new MapFunction<String, Tuple2<String, Integer>>() {
            @Override
            public Tuple2<String, Integer> map(String value) throws Exception {
                String[] fileds = value.split(",");
                String word = fileds[1];
                int count = Integer.parseInt(fileds[2]);
                return Tuple2.of(word, count);
            }
        });
        //先分组
        KeyedStream<Tuple2<String, Integer>, String> keyed = wordAndCount.keyBy(t -> t.f0);
        //划分窗口
        //keyed.timeWindow(Time.seconds(5));
        WindowedStream<Tuple2<String, Integer>, String, TimeWindow> window = keyed.window(TumblingEventTimeWindows.of(Time.seconds(5)));
        SingleOutputStreamOperator<Tuple2<String, Integer>> summed = window.sum(1);
        summed.print();
        env.execute();
    }
}

结果是按照Event Time的时间窗⼝计算得出的，⽽⽆关系统的时间（包括输⼊的快慢）。

3.2 滑动窗⼝（SlidingEventTimeWindows）

// 获取执⾏环境
val env = StreamExecutionEnvironment.getExecutionEnvironment
env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime)
// 创建SocketSource
val stream = env.socketTextStream("localhost", 11111)
// 对stream进⾏处理并按key聚合
val streamKeyBy = stream.assignTimestampsAndWatermarks(
 new BoundedOutOfOrdernessTimestampExtractor[String](Time.milliseconds(0)) {
 override def extractTimestamp(element: String): Long = {
 val sysTime = element.split(" ")(0).toLong
 println(sysTime)
 sysTime
 }}).map(item => (item.split(" ")(1), 1)).keyBy(0)
// 引⼊滚动窗⼝
val streamWindow = streamKeyBy.window(SlidingEventTimeWindows.of(Time.seconds(10),
Time.seconds(5)))
// 执⾏聚合操作
val streamReduce = streamWindow.reduce(
 (a,b) => (a._1, a._2 + b._2)
)
// 将聚合数据写⼊⽂件
streamReduce.print
// 执⾏程序
env.execute("TumblingWindow")

3.3 会话窗⼝（EventTimeSessionWindows）

相邻两次数据的EventTime的时间差超过指定的时间间隔就会触发执⾏。如果加⼊Watermark，那么当触发执⾏时，所有满⾜时间间隔⽽还没有触发的Window会同时触发执⾏。

package com.wedoctor.flink;

import org.apache.flink.api.common.functions.MapFunction;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.configuration.Configuration;
import org.apache.flink.streaming.api.TimeCharacteristic;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.datastream.KeyedStream;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.datastream.WindowedStream;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.timestamps.BoundedOutOfOrdernessTimestampExtractor;
import org.apache.flink.streaming.api.windowing.assigners.EventTimeSessionWindows;
import org.apache.flink.streaming.api.windowing.time.Time;
import org.apache.flink.streaming.api.windowing.windows.TimeWindow;

public class WaterMarkDemo3 {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.createLocalEnvironmentWithWebUI(new Configuration());
        //设置EventTime作为时间标准
        env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime);
        //1000,spark,1
        DataStreamSource<String> lines = env.socketTextStream("localhost", 8888);
        //直接对Source提取EventTime
        SingleOutputStreamOperator<String> watermarksDataStream = lines.assignTimestampsAndWatermarks(new BoundedOutOfOrdernessTimestampExtractor<String>(Time.seconds(2)) {
            @Override
            public long extractTimestamp(String element) {
                //当前分区中数据中最大的EventTime - 延迟时间 = 该分区的WaterMark
                return Long.parseLong(element.split(",")[0]);
            }
        });
        SingleOutputStreamOperator<Tuple2<String, Integer>> wordAndCount = watermarksDataStream.map(new MapFunction<String, Tuple2<String, Integer>>() {
            @Override
            public Tuple2<String, Integer> map(String value) throws Exception {
                String[] fileds = value.split(",");
                String word = fileds[1];
                int count = Integer.parseInt(fileds[2]);
                return Tuple2.of(word, count);
            }
        });
        //先分组
        KeyedStream<Tuple2<String, Integer>, String> keyed = wordAndCount.keyBy(t -> t.f0);
        //分组后划分EventTime的SessionWindow
        WindowedStream<Tuple2<String, Integer>, String, TimeWindow> windowed = keyed.window(EventTimeSessionWindows.withGap(Time.seconds(5)));
        SingleOutputStreamOperator<Tuple2<String, Integer>> summed = windowed.sum(1);
        summed.print();
        env.execute();
    }
}

安然烟火

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Flink-watermark

1 基本概念Flink中可以让window延迟触发的一种机制我们知道，流处理从事件产⽣，到流经source，再到operator，中间是有⼀个过程和时间的，虽然⼤部分情况下，流到operato的数据都是按照事件产⽣的时间顺序来的，但是也不排除由于⽹络、背压等原因，导致乱序的产⽣，所谓乱序，就是指Flink接收到的事件的先后顺序不是严格按照事件的Event Time顺序排列的。那么此时出现⼀个问题，⼀旦出现乱序，如果只根据eventTime决定window的运⾏，我们不能明确数据是否全部到位，但⼜不能
复制链接

扫一扫