Question

这是针对以下问题的跟踪问题：Trigger when State expires

我将每个传入元素的状态存储在流中，并在计时器关闭后删除状态。这样一来，在元素超时之前，我可以防止重复项被处理，之后我可以再次处理同一元素。我

我已经编写了以下代码来测试计时器，但似乎在所有3个元素都经过第一个ProcessFunction之后才触发计时器。

public static void main(String[] args) throws Exception {
    StreamExecutionEnvironment streamEnv = StreamExecutionEnvironment.getExecutionEnvironment();
    streamEnv.setStreamTimeCharacteristic(TimeCharacteristic.IngestionTime);
    streamEnv.setParallelism(12);

    List<Tuple2<String, String>> inputList = new ArrayList<>();
    inputList.add(new Tuple2<>("Test", "test"));
    inputList.add(new Tuple2<>("Test", "test"));
    inputList.add(new Tuple2<>("Test", "test"));

    streamEnv.fromCollection(inputList).keyBy(0)
            .process(new ProcessFunction<Tuple2<String, String>, Tuple2<String, String>>() {
                ValueState<Integer> occur;

                @Override
                public void open(Configuration parameters) throws Exception {
                    occur = getRuntimeContext().getState(new ValueStateDescriptor<Integer>("occurs", Integer.class, 0));
                }

                @Override
                public void processElement(Tuple2<String, String> value, Context ctx, Collector<Tuple2<String, String>> out) throws Exception {
                    if (occur.value() < 2) {
                        occur.update(occur.value() + 1);
                        out.collect(value);
                        LOGGER.info("[TEST] Outputting Tuple {}", value);
                    }
                    else {
                        Thread.sleep(10000);
                        LOGGER.info("[TEST] Outputting Tuple {}", value);
                        out.collect(value);
                    }
                }
            })
            .keyBy(0)
            .process(new ProcessFunction<Tuple2<String, String>, Tuple2<String, String>>() {
                ValueState<Tuple2<String, String>> storedTuple;

                @Override
                public void open(Configuration parameters) throws Exception {
                    storedTuple = getRuntimeContext().getState(new ValueStateDescriptor<>("storedTuple",
                            TypeInformation.of(new TypeHint<Tuple2<String, String>>() {})));
                }

                @Override
                public void processElement(Tuple2<String, String> value, Context ctx, Collector<Tuple2<String, String>> out) throws Exception {
                    Tuple2<String, String> stored = storedTuple.value();
                    if (stored == null) {
                        LOGGER.info("[TEST] Storing Tuple {}", value);
                        storedTuple.update(value);
                        out.collect(value);
                        ctx.timerService().registerEventTimeTimer(ctx.timestamp() + 6000);
                    }
                }
            }

            @Override
                public void onTimer(long timestamp, OnTimerContext ctx, Collector<Tuple2<String, String>> out) throws Exception {
                    LOGGER.info("[TEST] Removing Tuple {}", storedTuple.value());
                    storedTuple.clear();
                }    
            )
            .addSink(new CollectSink());

    streamEnv.execute("Testing");
    for (Tuple2<String, String> tup: CollectSink.values) {
        System.out.println(tup);
    }

}

private static class CollectSink implements SinkFunction<Tuple2<String, String>> {

    static final List<Tuple2<String, String>> values = new ArrayList<>();

    @Override
    public synchronized void invoke(Tuple2<String, String> value) throws Exception {
        values.add(value);
    }
}

我有一个包含3个重复元素的输入列表。在第一个ProcessFunction中，我原样发送了前两个元素，但是将第三个元素延迟了10秒。

在第二个ProcessFunction中，它根据是否为状态存储元素来过滤元素。正如预期的那样，第一个元素将被存储并向前发送，而第二个元素则不存在，因为状态已经存在。对于第一个元素，除了发送它之外，我还设置了一个计时器6秒钟，以便在触发计时器后清除状态。

现在，第三个元素将在10秒后发送，这意味着6秒触发器应该已经清除了状态。但是，在触发计时器之前也正在处理第三个元素。我还可以看到输出仅包含1个元组副本，即使我期望2个副本也是如此。

我添加了一些日志记录，以更好地了解执行时间。

[2019-02-19 14:11:48,891] [Process (1/12)] INFO  FlinkTest - [TEST] Outputting Tuple (Test,test)
[2019-02-19 14:11:48,891] [Process (1/12)] INFO  FlinkTest - [TEST] Outputting Tuple (Test,test)
[2019-02-19 14:11:48,943] [Process -> Sink: Unnamed (1/12)] INFO  FlinkTest - [TEST] Storing Tuple (Test,test)
[2019-02-19 14:11:58,891] [Process (1/12)] INFO  FlinkTest - [TEST] Outputting Tuple (Test,test)
[2019-02-19 14:11:58,896] [Process -> Sink: Unnamed (1/12)] INFO  FlinkTest - [TEST] Removing Tuple (Test,test)

您可以看到前两个元组按预期方式一起发出，然后是10秒钟的延迟，之后才发出第三个元组。现在Removing Tuple会在10秒后发生，即使它是在第一个元组进入6秒后触发发生的。

Answer 1

直到处理了大于计时器中指定时间的水印后，事件时间计时器才会启动。这样的水印要等到第三个事件被处理后才能出现。此外，随着摄取时间的增加，使用定期水印生成器生成水印，并且默认情况下每200毫秒将水印插入流中。

Answer 2

注意：在Flink 1.4.0之前，从处理时间计时器调用时，ProcessFunction.onTimer（）方法将当前处理时间设置为事件时间时间戳。此行为非常微妙，用户可能不会注意到。嗯，这很有害，因为处理时间的时间戳是不确定的，并且与水印不符。此外，用户实现的逻辑依赖于此错误的时间戳，很可能是意外错误。因此，我们决定对其进行修复。升级到1.4.0后，使用此错误事件时间时间戳的Flink作业将失败，用户应根据正确的逻辑调整其作业。

https://ci.apache.org/projects/flink/flink-docs-stable/dev/stream/operators/process_function.html

Flink计时器未按时执行

2 个答案: