Flink中的时间语义

在Flink的流式处理中，会涉及到时间的不同概念。

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

EventTime的引入

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

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，那么这个窗口被触发执行。

当Flink接收到数据时，会按照一定的规则去生成Watermark，这条Watermark就等于当前所有到达数据中的maxEventTime - 延迟时长，也就是说，Watermark是基于数据携带的时间戳形成的，一旦Watermark比当前未触发的窗口的停止时间要晚，那么就会触发相应窗口的执行。由于Event Time是由数据携带的，因此，如果运行过程中无法获取新的数据，那么没有被触发的窗口将永远都不会被触发。
Watermark就是触发前一窗口的“关窗时间”，一旦触发关门那么以当前时刻为准在窗口范围内的所有数据都会收入窗中。
只要没有达到水位那么不管现实中的时间推进了多久都不会触发关窗。

Watermark的引入

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

dataStream.assignTimestampsAndWatermarks(new BoundedOutOfOrdernessTimestampExtractor<SensorReading>(Time.seconds(2)) {
                    @Override
                    public long extractTimestamp(SensorReading element) {
                        return element.getTimestamp() * 1000L;
                    }
                });

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

StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

// 设置时间语义
env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime);

DataStream<SensorReading> dataStream = env.addSource(new SensorSource()).assignTimestampAndWatermarks(new MyAssigner());

MyAssigner由两种类型

AssignerWithPeriodicWatermarks
AssignerWithPunctuatedWatermarks

以上两个接口都集成自 TimestampAssigner

Assigner with periodic watermarks

周期性的生成watermark：系统会周期性的将watermark插入到流中（水位线也是一种特殊的事件）。默认周期是200毫秒。可以用ExecutionConfig.setAutoWatermarkInterval()方法进行设置。
例：每隔5秒产生一个wateramarkenv.getConfig.setAutoWatermarkInterval(5000);
产生watermark的逻辑：每隔5s钟，Flink会调用AssignerWithPeriodicWatermarks的getCurrentWatermark()方法。如果方法返回一个时间戳大于之前水位线的戳，新的watermark会被插入到流中。这个检查保证了水位线是单调递增的。如果方法返回的时间戳小于等于之前水位的时间戳，则不会产生新的watermark。

demo

自定义一个周期性的时间戳

public static class MyPeriodicAssigner implements AssignerWithPeriodicWatermarks<SensorReading> {
    private Long bound = 60 * 1000L; // 延迟一分钟
    private Long maxTs = Long.MIN_VALUE; // 当前最大时间戳

    @Nullable
    @Override
    public Watermark getCurrentWatermark() {
        return new Watermark(maxTs - bound);
    }

    @Override
    public long extractTimestamp(SensorReading element, long preiousElementTimestamp) {
        maxTs = Math.max(maxTs, element.getTimestamp());
        return element.getTimestamp();
    }
}

一般简单的特殊情况是，如果我们事先得知数据流的时间戳是单调递增的，也就是说没有乱序，那我们可以使用`AscendingTimestampExtractor`，这个类会直接使用数据的时间戳生成watermark。

DataStream<SensorReading> dataStream = ...

dataStream.assignTimestampsAndWatermarks(
    new AscendingTimestampExtractor<SensorReading>() {
        @Override
        public long extractAscendingTimestamp(SensorReading element) {
            return element.getTimestamp() * 1000;
        }
    }
)

而对于乱序数据流，如果我们能大致估算处数据流中的事件的最大延迟时间，就可以使用如下代码：

DataStream<SensorReading> dataStream = ...

dataStream.assignTimestampsAndWatermarks(
    new BoundedOutOfOrdernessTimestampExtractor<SensorReading>(Time.seconds(1)) {
        @Override
        public long extractTimestamp(SensorReading element) {
            return element.getTimestamp() * 1000;
        }
    }
)

Assigner with punctuated watermarks

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

public static class MyPunctuatedAssigner implements AssignerWithPunctuatedWatermarks<SensorReading> {
    private Long bound = 60 * 1000L; // 延迟一分钟

    @Nullable
    @Override
    public Watermark checkAndGetNextWatermark(SensorReading lastElement, long extractedTimestamp) {
        if(lastElement.getId().equals("sensor_1"))
            return new Watermark(extractedTimestamp - bound);
        else 
            return null;
    }

    @Override
    public long extractTimestamp(SensorReading element, long previousElementTimestamp) {
        return element.getTimestamp();
    }
}

EnventTime和Watermark

package com.zh.apitest.window;

import com.zh.apitest.beans.SensorReading;
import org.apache.flink.streaming.api.TimeCharacteristic;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.timestamps.BoundedOutOfOrdernessTimestampExtractor;
import org.apache.flink.streaming.api.windowing.time.Time;
import org.apache.flink.util.OutputTag;

/**
 * author: zhanghui
 * project: big-data-learning
 * package: com.zh.apitest.window
 * filename: WindowTest3_EventTimeWindow
 * date: 2021/12/6 8:40 下午
 * description: 事件时间（EventTime）和WaterMark
 */
public class WindowTest3_EventTimeWindow {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);
        // 设置全局时间语义
        env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime);

        // socket文本流
        DataStreamSource<String> inputStream = env.socketTextStream("localhost", 7777);

        // 转换成SensorReading类型
        DataStream<SensorReading> dataStream = inputStream.map(line -> {
            String[] fields = line.split(",");
            return new SensorReading(fields[0], new Long(fields[1]), new Double(fields[2]));
        })
                // 升序数据设置事件时间和watermark
//                .assignTimestampsAndWatermarks(new AscendingTimestampExtractor<SensorReading>() {
//                    @Override
//                    public long extractAscendingTimestamp(SensorReading element) {
//                        return element.getTimestamp() * 1000L;
//                    }
//                })
                // 乱序设置时间戳和watermark
                .assignTimestampsAndWatermarks(new BoundedOutOfOrdernessTimestampExtractor<SensorReading>(Time.seconds(2)) {
                    @Override
                    public long extractTimestamp(SensorReading element) {
                        return element.getTimestamp() * 1000L;
                    }
                });

        OutputTag<SensorReading> outputTag = new OutputTag<SensorReading>("late") {
        };

        // 基于事件时间的开窗聚合，统计15s内温度的最小值
        SingleOutputStreamOperator<SensorReading> minTempStream = dataStream.keyBy("id")
                .timeWindow(Time.seconds(15))
                .allowedLateness(Time.minutes(1))
                .sideOutputLateData(outputTag)
                .minBy("temperature");

        minTempStream.print("minTemperature");
        minTempStream.getSideOutput(outputTag).print("late");

        env.execute();
    }
}

EventTime在window中的使用（Scala）

滚动窗口（TumblingEventTimeWindows）

def main(args: Array[String]): Unit = {
    // 环境
  val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExectuionEnvironment

  env.setStreamTimeCharacteristic(TimeCharacteristic.EnventTime)
  env.setParallelism(1)

  val dstream: DataStream[String] = env.socketTextStream("localhost", 7777)

  val textWithTsDstream: DataStream[(String, Long, Int)] = dstream.map{ text => 
      val arr: Array[String] = text.split(" ")
    (arr(0), arr(1).toLong, 1)
  }

  val textWithEventTimeDstream: DataStream[(String, Long, Int)] = textWithTsDstream.assignTimestampsAndWatermarks(new BoundedOutOfOrdernessTimestampExtractor[(String, Long, Int)](Time.milliseconds(1000)) {
      override def extractTimestamp(element: (String, Long, Int)) : Long = {
        return element._2
    }
  })

  val textKeyStream: KeyedStream[(String, Long, Int), Tuple] = textWithEventTimeDstream.keyBy(0)

  textKeyStream.print("textkey:")

  val windowStream: WindowedStream[(String, Long, Int), Tuple, TimeWindow] = textKeyStream.window(TumblingEventTimeWindows.of(Time.seconds(2)))

  val groupDstream: DataStream[mutable.HashSet[Long]] = windowStream.fold(new mutable.HashSet[Long]()) {
      case (set, (key, ts, count)) => set += ts
  }

  groupDstream.print("window::::").setParallelism(1)

  env.execute()

}

结果是按照Event Time的时间窗口计算得出的，而无关系统的时间（包括输入的快慢）。

滑动窗口（SlidingEventTimeWindows）

def main(args: Array[String]): Unit = {
    // 环境
  val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExectuionEnvironment

  env.setStreamTimeCharacteristic(TimeCharacteristic.EnventTime)
  env.setParallelism(1)

  val dstream: DataStream[String] = env.socketTextStream("localhost", 7777)

  val textWithTsDstream: DataStream[(String, Long, Int)] = dstream.map{ text => 
      val arr: Array[String] = text.split(" ")
    (arr(0), arr(1).toLong, 1)
  }

  val textWithEventTimeDstream: DataStream[(String, Long, Int)] = textWithTsDstream.assignTimestampsAndWatermarks(new BoundedOutOfOrdernessTimestampExtractor[(String, Long, Int)](Time.milliseconds(1000)) {
      override def extractTimestamp(element: (String, Long, Int)) : Long = {
        return element._2
    }
  })

  val textKeyStream: KeyedStream[(String, Long, Int), Tuple] = textWithEventTimeDstream.keyBy(0)

  textKeyStream.print("textkey:")

  val windowStream: WindowedStream[(String, Long, Int), Tuple, TimeWindow] = textKeyStream.window(SlidingEventTimeWindows.of(Time.seconds(2), Time.milliseconds(500)))

  val groupDstream: DataStream[mutable.HashSet[Long]] = windowStream.fold(new mutable.HashSet[Long]()) {
      case (set, (key, ts, count)) => set += ts
  }

  groupDstream.print("window::::").setParallelism(1)

  env.execute()

}

会话窗口（EventTimeSessionWindows）

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

def main(args: Array[String]): Unit = {
    // 环境
  val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExectuionEnvironment

  env.setStreamTimeCharacteristic(TimeCharacteristic.EnventTime)
  env.setParallelism(1)

  val dstream: DataStream[String] = env.socketTextStream("localhost", 7777)

  val textWithTsDstream: DataStream[(String, Long, Int)] = dstream.map{ text => 
      val arr: Array[String] = text.split(" ")
    (arr(0), arr(1).toLong, 1)
  }

  val textWithEventTimeDstream: DataStream[(String, Long, Int)] = textWithTsDstream.assignTimestampsAndWatermarks(new BoundedOutOfOrdernessTimestampExtractor[(String, Long, Int)](Time.milliseconds(1000)) {
      override def extractTimestamp(element: (String, Long, Int)) : Long = {
        return element._2
    }
  })

  val textKeyStream: KeyedStream[(String, Long, Int), Tuple] = textWithEventTimeDstream.keyBy(0)

  textKeyStream.print("textkey:")

  val windowStream: WindowedStream[(String, Long, Int), Tuple, TimeWindow] = textKeyStream.window(EnventTimeSessionWindows.withGap(Time.milliseconds(500)))

  val groupDstream: DataStream[mutable.HashSet[Long]] = windowStream.fold(new mutable.HashSet[Long]()) {
      case (set, (key, ts, count)) => set += ts
  }

  groupDstream.print("window::::").setParallelism(1)

  env.execute()

}

大数据

F-时间语义与Wartermark