Flink流式计算之时间语义与watermark

1 说明

在Flink的流式处理中，会涉及到时间的不同概念，如下图所示：

Event Time：是事件创建的时间。它通常由事件中的时间戳描述，例如采集的日志数据中，每一条日志都会记录自己的生成时间，Flink通过时间戳分配器访问事件时间戳。
Ingestion Time：是数据进入Flink的时间。
Processing Time：是每一个执行基于时间操作的算子的本地系统时间，与机器相关，默认的时间属性就是Processing Time。
例如，一条日志进入Flink的时间为2017-11-12 10:00:00.123，到达Window的系统时间为2017-11-12 10:00:01.234，日志的内容如下：

2017-11-02 18:37:15.624 INFO Fail over to rm2

对于业务来说，要统计1min内的故障日志个数，哪个时间是最有意义的？—— eventTime，因为我们要根据日志的生成时间进行统计。

2 eventTime引入

在Flink的流式处理中，绝大部分的业务都会使用eventTime，一般只在eventTime无法使用时，才会被迫使用ProcessingTime或者IngestionTime。
如果要使用EventTime，那么需要引入EventTime的时间属性，引入方式如下所示：

val env = StreamExecutionEnvironment.getExecutionEnvironment

// 从调用时刻开始给env创建的每一个stream追加时间特征

env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime)

3 Watermark

我们知道，流处理从事件产生，到流经source，再到operator，中间是有一个过程和时间的，虽然大部分情况下，流到operator的数据都是按照事件产生的时间顺序来的，但是也不排除由于网络、分布式等原因，导致乱序的产生，所谓乱序，就是指Flink接收到的事件的先后顺序不是严格按照事件的Event Time顺序排列的。

那么此时出现一个问题，一旦出现乱序，如果只根据eventTime决定window的运行，我们不能明确数据是否全部到位，但又不能无限期的等下去，此时必须要有个机制来保证一个特定的时间后，必须触发window去进行计算了，这个特别的机制，就是Watermark。
 Watermark是一种衡量Event Time进展的机制。
 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比当前未触发的窗口的停止时间要晚，那么就会触发相应窗口的执行。由于event time是由数据携带的，因此，如果运行过程中无法获取新的数据，那么没有被触发的窗口将永远都不被触发。
上图中，我们设置的允许最大延迟到达时间为2s，所以时间戳为7s的事件对应的Watermark是5s，时间戳为12s的事件的Watermark是10s，如果我们的窗口1是1s–5s，窗口2是6s~10s，那么时间戳为7s的事件到达时的Watermarker恰好触发窗口1，时间戳为12s的事件到达时的Watermark恰好触发窗口2。
Watermark 就是触发前一窗口的“关窗时间”，一旦触发关门那么以当前时刻为准在窗口范围内的所有数据都会收入窗中。
只要没有达到水位那么不管现实中的时间推进了多久都不会触发关窗。

3 Watermark引入

watermark的引入很简单，对于乱序数据，最常见的引用方式如下：

dataStream.assignTimestampsAndWatermarks( new BoundedOutOfOrdernessTimestampExtractor[SensorReading](Time.milliseconds(1000)) {
    
    
  override def extractTimestamp(element: SensorReading): Long = {
    
    
    element.timestamp * 1000
  }
} )

Event Time的使用一定要指定数据源中的时间戳。否则程序无法知道事件的事件时间是什么(数据源里的数据没有时间戳的话，就只能使用Processing Time了)。
我们看到上面的例子中创建了一个看起来有点复杂的类，这个类实现的其实就是分配时间戳的接口。Flink暴露了TimestampAssigner接口供我们实现，使我们可以自定义如何从事件数据中抽取时间戳。

val env = StreamExecutionEnvironment.getExecutionEnvironment
// 从调用时刻开始给env创建的每一个stream追加时间特性
env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime)
val readings: DataStream[SensorReading] = env
.addSource(new SensorSource)
.assignTimestampsAndWatermarks(new MyAssigner())

MyAssigner有两种类型
 AssignerWithPeriodicWatermarks
 AssignerWithPunctuatedWatermarks
以上两个接口都继承自TimestampAssigner。

3.1 Assigner with periodic watermarks

周期性的生成watermark：系统会周期性的将watermark插入到流中(水位线也是一种特殊的事件!)。默认周期是200毫秒。可以使用ExecutionConfig.setAutoWatermarkInterval()方法进行设置。

val env = StreamExecutionEnvironment.getExecutionEnvironment
env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime)
// 每隔5秒产生一个watermark
env.getConfig.setAutoWatermarkInterval(5000)

产生watermark的逻辑：每隔5秒钟，Flink会调用AssignerWithPeriodicWatermarks的getCurrentWatermark()方法。如果方法返回一个时间戳大于之前水位的时间戳，新的watermark会被插入到流中。这个检查保证了水位线是单调递增的。如果方法返回的时间戳小于等于之前水位的时间戳，则不会产生新的watermark。

扫描二维码关注公众号，回复： 15906445 查看本文章

3.2 Assigner with punctuated watermarks

间断式地生成watermark。和周期性生成的方式不同，这种方式不是固定时间的，而是可以根据需要对每条数据进行筛选和处理。直接上代码来举个例子，我们只给sensor_1的传感器的数据流插入watermark：

class PunctuatedAssigner extends AssignerWithPunctuatedWatermarks[SensorReading] {
    
    
val bound: Long = 60 * 1000
override def checkAndGetNextWatermark(r: SensorReading, extractedTS: Long): Watermark = {
    
    
if (r.id == "sensor_1") {
    
    
new Watermark(extractedTS - bound)
} else {
    
    
null
}
}
override def extractTimestamp(r: SensorReading, previousTS: Long): Long = {
    
    
r.timestamp
}
}

4 EventTime在windows中的使用

4.1 滚动窗口（TumblingEventTimeWindows）

import org.apache.flink.api.java.tuple.Tuple
import org.apache.flink.streaming.api.TimeCharacteristic
import org.apache.flink.streaming.api.functions.timestamps.BoundedOutOfOrdernessTimestampExtractor
import org.apache.flink.streaming.api.scala._
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

object EventTimeDemo02 {
    
    

  def main(args: Array[String]): Unit = {
    
    

    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    //设置读取时间为event time    env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime)
    //为了便于观察，设置并行度为1
    env.setParallelism(1)
    //设置自动获取水印的时间
    env.getConfig.setAutoWatermarkInterval(200)

    val dataStream: DataStream[String] = env.socketTextStream("192.168.199.101", 7777)
    //处理数据
    val mapStream = dataStream.map(
      data => {
    
    
        val strings = data.split(",")
        (strings(0), strings(1).toLong, strings(2).toDouble)
      }
    )

    /*设置watermark
    * 这里的new BoundedOutOfOrdernessTimestampExtractor()设置延迟时间
    * watermark = eventtime(事件时间) - boundtime(延迟时间)
    * */
    val waterMarkStream: DataStream[(String, Long, Double)] = mapStream.
      assignTimestampsAndWatermarks(new BoundedOutOfOrdernessTimestampExtractor[(String, Long, Double)](Time.seconds(2)) {
    
    
      override def extractTimestamp(element: (String, Long, Double)): Long = {
    
    
        element._2
      }
    })

    //使用keyby进行分组
    val keyedStream: KeyedStream[(String, Long, Double), Tuple] = waterMarkStream.keyBy(0)

    //设置滚动窗口
    val timeWindowStream: WindowedStream[(String, Long, Double), Tuple, TimeWindow] = keyedStream
      .window(TumblingEventTimeWindows.of(Time.seconds(5)))
    //获取每个分组中的最大值
    val result: DataStream[(String, Long, Double)] = timeWindowStream.reduce((r1, r2) => ((r1._1, r1._2.max(r2._2), r1._3.max(r2._3))))
    result.print("result")
    env.execute()
  }
}

这里设置的延迟时间为2秒，滚动窗口时间为5秒，也就是说水位线>=滚动时间=5秒时才会关闭第一个(0-5秒)滚动窗口，并触发计算。
如图：当输入的事件时间小于7秒时并不会触发计算

当输入数据的事件时间>=7秒(窗口时间5秒+延长时间2秒)时就会触发第一个窗口计算

此时可以看到,sensor_1最大值为第1秒输入的43.92。此时注意观察sensor_5的最大值为什么不是第5秒输入的62.53呢？因为sensor_5是第5秒的数据，会把记录到第二个滚动窗口，也就是[5,10）。此时要触发第二个窗口关闭，需要事件时间>=12秒。我们传入一些测试数据
注意：如果这时候如果再发送一些事件时间5秒内的数据，将不会被接收，因为第一个窗口已经关闭，不会再接收数据。此时可以使用allowedLateness()方法延迟数据接收，或使用sideOutputLateData将数据传入测流中，后续再合入主流进行处理。

此时又输入了三条数据，当水位线达到12秒时触发了计算。此时可以看到，在窗口2中，sensor_5对应的最大值就为62.53了。

4.2 滑动窗口（SlidingEventTimeWindows）

import org.apache.flink.api.java.tuple.Tuple
import org.apache.flink.streaming.api.TimeCharacteristic
import org.apache.flink.streaming.api.functions.timestamps.BoundedOutOfOrdernessTimestampExtractor
import org.apache.flink.streaming.api.scala._
import org.apache.flink.streaming.api.windowing.assigners.SlidingEventTimeWindows
import org.apache.flink.streaming.api.windowing.time.Time
import org.apache.flink.streaming.api.windowing.windows.TimeWindow

//测试watermark与滑动窗口
object EventTimeDemo03 {
    
    

  def main(args: Array[String]): Unit = {
    
    

    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment

    //设置读取时间为event time
    env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime)
    //为了便于观察，设置并行度为1
    env.setParallelism(1)
    //设置自动获取水印的时间
    env.getConfig.setAutoWatermarkInterval(200)

    val dataStream: DataStream[String] = env.socketTextStream("192.168.199.101", 7777)
    val mapStream: DataStream[(String, Long, Long)] = dataStream.map(
      data => {
    
    
        val strings = data.split(",")
        (strings(0), strings(1).toLong, 1)
      }
    )

    /**
     * 设置watermark水位线
     */
    val waterStream: DataStream[(String, Long, Long)] = mapStream.
      assignTimestampsAndWatermarks(new BoundedOutOfOrdernessTimestampExtractor[(String, Long, Long)](Time.seconds(2)) {
    
    
        override def extractTimestamp(element: (String, Long, Long)): Long = {
    
    
          element._2
        }
      })

    val keyedStream: KeyedStream[(String, Long, Long), Tuple] = waterStream.keyBy(0)

    //设置滑动窗口，窗口大小10秒，滑动时间5秒
    val slideWindowStream: WindowedStream[(String, Long, Long), Tuple, TimeWindow] = keyedStream.
      window(SlidingEventTimeWindows.of(Time.seconds(10), Time.seconds(5)))

    val resultStream: DataStream[(String, Long, Long)] = slideWindowStream.reduce((r1, r2) => (r1._1, r1._2.max(r2._2), r1._3 + r2._3))

    resultStream.print("watermark slide")
    env.execute()
  }

}

滑动窗口大小为10秒，滑动时间为5秒，延迟时间为2秒。也就是说当事件时间>=滑动时间5秒+延迟时间2秒,才会触发窗口计算。如下图，当不满足条件时，窗口不会触发计算。

当事件时间>=滑动窗口时间5秒+延迟时间2秒时，触发计算

下次触发窗口计算的时间为>=12秒，在此期间传入数据

由于整个窗口大小为10秒，因此在往下滑动5秒时，会包含上个阶段5秒窗口中的数据，所以在12秒触发窗口计算后，窗口中的数据为8条(包含前一个窗口中的4条)

4.3 会话窗口(EvnentTimeSessionWindows)

相邻两次数据的EventTime的时间差超过指定的时间间隔就会触发执行。如果加入Watermark， 会在符合窗口触发的情况下进行延迟。到达延迟水位再进行窗口触发。

import org.apache.flink.api.java.tuple.Tuple
import org.apache.flink.streaming.api.TimeCharacteristic
import org.apache.flink.streaming.api.functions.timestamps.BoundedOutOfOrdernessTimestampExtractor
import org.apache.flink.streaming.api.scala._
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

/**
 * 测试watermark和回话窗口
 */
object EventTimeDemo04 {
    
    

  def main(args: Array[String]): Unit = {
    
    

    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    //设置读取时间为event time
    env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime)
    //为了便于观察，设置并行度为1
    env.setParallelism(1)
    //设置自动获取水印的时间
    env.getConfig.setAutoWatermarkInterval(200)

    val dataStream: DataStream[String] = env.socketTextStream("192.168.199.101", 7777)
    val mapStream: DataStream[(String, Long, Double)] = dataStream.map(
      data => {
    
    
        val strings = data.split(",")
        (strings(0), strings(1).toLong, strings(2).toDouble)
      }
    )

    val waterStream: DataStream[(String, Long, Double)] = mapStream.
      assignTimestampsAndWatermarks(new BoundedOutOfOrdernessTimestampExtractor[(String, Long, Double)](Time.seconds(1)) {
    
    
        override def extractTimestamp(element: (String, Long, Double)): Long = {
    
    
          element._2
        }
      })

    val windowsStream: WindowedStream[(String, Long, Double), Tuple, TimeWindow] = waterStream.
      keyBy(0).window(EventTimeSessionWindows.withGap(Time.seconds(1)))

    val result = windowsStream.reduce((r1, r2) => (r1._1, r1._2.max(r2._2), r1._3 + r2._3))

    result.print("water session")
    env.execute()
  }

}

当输入数据的事件时间，相邻时间间隔没有超过设置的会话时间间隔1秒+延迟时间1秒时，不会触发窗口的计算。

当传入的相邻数据事件时间>=会话窗口时间1秒+延迟时间1秒=2秒时，就会触发窗口计算

此时的计算结果105.4是事件时间4200之前所有数据的数值和。注意：此是事件时间为4200的数据，会进入下一个会话窗口而不是当前的会话窗口

从上图可以看到相邻间隔事件在1秒内的会在同一个session窗口中，而相邻数据的事件时间间隔超过1秒的，会进入下一个session窗口中,直到相邻的事件时间>=会话窗口时间1秒+延迟时间1秒=2秒时，会触发相应的session窗口进行计算。