这一部分文档，只和使用 event time语义的应用有关。
为了使用 event time 语义，流程序需要设置相应的 时间语义 time characteristic.

final StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime);

指定 timestamp

为了能在event time语义下正常工作，Flink需要知道数据的时间戳，意味着流中的每个数据都要有自己的时间戳。一般可以通过获取或者提取数据中某个field的时间戳完成。
时间戳的指定与watermark的生成一般是一起发生的，watermark用于告诉系统当前的event time 是多少了。
有两种方式来指定时间戳，生成watermark：
1.在source中完成
2.通过 timestamp assigner/watermark generator:在flink中，timestamp assigner同时也定义了如何发射一个watermark
注意：timestamp与watermark都是一个从 1970-01-01T00:00:00Z开始的一个毫秒值

Source Function with Timestamps and Watermarks

数据流source可以直接指定数据的timestamp以及发射watermark。当选择这么做时，就不需要timestamp assigner了。需要注意的是，如果使用了timestamp assigner，那么source中的相关逻辑会被覆盖。
为了在source中就指定timestamp，souce必须使用 SourceContext中的collectWithTimestamp(...)方法。为了生成watermark，source必须调用emitWatermark(watermark) 方法。
下面的例子展示了（不使用checkpoint）source如何指定timestamp，生成watermark

@Override
public void run(SourceContext<MyType> ctx) throws Exception {
    while (/* condition */) {
        MyType next = getNext();
        ctx.collectWithTimestamp(next, next.getEventTimestamp());

        if (next.hasWatermarkTime()) {
            ctx.emitWatermark(new Watermark(next.getWatermarkTime()));
        }
    }
}

Timestamp Assigner / Watermark Generator

Timestamp Assigner 输入一个流，输出一个带有时间戳以及watermark的流。如果输入流中本来就有时间戳以及watermark，Tmesatmp Assigner会覆盖它们。
Timesatmp Aasigner通常在调用source函数后，紧跟着调用，但是并不会这样强制要求。一个常用的模式是，可以在调用 timestamp assigner前先执行解析（map）与过滤（filter）。更通用的说法是，timestamp assigner 必须在第一个使用 event time的操作符（如第一个window操作）前定义好。作为一个特殊情况：使用kafka作为source，Flink允许使用数据源内自带的timestamp assigner与watermark generator。
注意：文档下面的部分展示了为了实现自己的timestamp提取/watermark发射所要实现的主要接口。如果想要看flink自带的默认实现，可以参阅 Pre-defined Timestamp Extractors / Watermark Emitters。

final StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime);

DataStream<MyEvent> stream = env.readFile(
        myFormat, myFilePath, FileProcessingMode.PROCESS_CONTINUOUSLY, 100,
        FilePathFilter.createDefaultFilter(), typeInfo);

DataStream<MyEvent> withTimestampsAndWatermarks = stream
        .filter( event -> event.severity() == WARNING )
        .assignTimestampsAndWatermarks(new MyTimestampsAndWatermarks());

withTimestampsAndWatermarks
        .keyBy( (event) -> event.getGroup() )
        .timeWindow(Time.seconds(10))
        .reduce( (a, b) -> a.add(b) )
        .addSink(...);

使用周期发射的watermark

AssignerWithPeriodicWatermaks 会周期性的产生timestamp与watermark（可能是基于流中的元素，也可能是基于机器的系统时间）。
生成watermark的间隔可以通过ExecutionConfig.setAutoWatermakInterval(...) 。Assigner的getCurrentWatermark()方法每次都会调用，如果返回的watermark不为null且大于上次的watermark，则返回的watermark就会成为新的watermark。
下面介绍的两个timestamp sasigner示例使用了周期性的watermark generation。需要注意的是Flink自带的 BoundedOutOfOrdernessTimestampEaxtractor 与下面的 BoundOutOfOrdernessGenerator类似。

/**
 * This generator generates watermarks assuming that elements arrive out of order,
 * but only to a certain degree. The latest elements for a certain timestamp t will arrive
 * at most n milliseconds after the earliest elements for timestamp t.
 */
public class BoundedOutOfOrdernessGenerator implements AssignerWithPeriodicWatermarks<MyEvent> {

    private final long maxOutOfOrderness = 3500; // 3.5 seconds

    private long currentMaxTimestamp;

    @Override
    public long extractTimestamp(MyEvent element, long previousElementTimestamp) {
        long timestamp = element.getCreationTime();
        currentMaxTimestamp = Math.max(timestamp, currentMaxTimestamp);
        return timestamp;
    }

    @Override
    public Watermark getCurrentWatermark() {
        // return the watermark as current highest timestamp minus the out-of-orderness bound
        return new Watermark(currentMaxTimestamp - maxOutOfOrderness);
    }
}

/**
 * This generator generates watermarks that are lagging behind processing time by a fixed amount.
 * It assumes that elements arrive in Flink after a bounded delay.
 */
public class TimeLagWatermarkGenerator implements AssignerWithPeriodicWatermarks<MyEvent> {

    private final long maxTimeLag = 5000; // 5 seconds

    @Override
    public long extractTimestamp(MyEvent element, long previousElementTimestamp) {
        return element.getCreationTime();
    }

    @Override
    public Watermark getCurrentWatermark() {
        // return the watermark as current time minus the maximum time lag
        return new Watermark(System.currentTimeMillis() - maxTimeLag);
    }
}

使用 Punctuated Watermark

当某个特定数据到达时再生成watermark的场景，可以使用 AssignerWithPunctuatedWatermarks 。Flink会先调用 extractTimestamp(...) 方法获取数据的timestamp，然后立即调用 checkAndGetNextWatermark(...)方法。
checkAndGetNextWatermark(...)方法会接收 extractTimestamp(...)方法指定的timestamp，然后决定是否要生成一个watermark。一旦 checkAndGetNextWatermark方法范户籍一个非空watermark并且大于旧的watermark，新返回的watermark就会发射到数据流中。

public class PunctuatedAssigner implements AssignerWithPunctuatedWatermarks<MyEvent> {

    @Override
    public long extractTimestamp(MyEvent element, long previousElementTimestamp) {
        return element.getCreationTime();
    }

    @Override
    public Watermark checkAndGetNextWatermark(MyEvent lastElement, long extractedTimestamp) {
        return lastElement.hasWatermarkMarker() ? new Watermark(extractedTimestamp) : null;
    }
}

注意：每个数据都生成对应的watermark是可以的。但是每个watermark都会造成下游操作符额外计算，因此过多的watermark会降低性能。

Timestamps per Kafka Partition

当使用kafka作为数据源时，每一个kafka partition可能会有自己的event time pattern。然而，当从kafka消费数据时，多个partiton有可能在同一线程中读取，造成不同partition的数据交错，破坏了每个partition的固有的简单的event time pattern。
针对这种情况，你可以使用Flink的 Kafka-partition-aware watermark generation。使用跟这个特征，watermark可以在kafka consumer内部每个partiton产生。多个partition的watermak的merged的逻辑和watermark在stream shuffle时的逻辑是一样的。
例如：如果数据的时间戳在kafka的每个partition中都是严格升序的，那么使用 assending timestamps watermark generator 生成每个partiton的watermrk会得到很好的结果。
下图展示了如何使用 per-Kafka-partition watermark generation 以及watermark是如何在数据流中merge然后发送到下游的。

FlinkKafkaConsumer09<MyType> kafkaSource = new FlinkKafkaConsumer09<>("myTopic", schema, props);
kafkaSource.assignTimestampsAndWatermarks(new AscendingTimestampExtractor<MyType>() {

    @Override
    public long extractAscendingTimestamp(MyType element) {
        return element.eventTimestamp();
    }
});

DataStream<MyType> stream = env.addSource(kafkaSource);