devbox
小蓝xlanll
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Flink会话窗口和定时器原理详解

作者：小蓝xlanll | 2024-05-06 02:01:26

赞

踩

flink定时任务

点击上方蓝色字体，选择“设为星标”

回复”资源“获取更多资源

前言

在我们使用Flink DataStream API编写业务代码时，aggregate()算子、AggregateFunction、KeyedProcessFunction是非常常用的。下面我们把这两个知识点详细的讲解一下。

AggregateFunction

在我们使用Flink DataStream API编写业务代码时，aggregate()算子和AggregateFunction无疑是非常常用的。编写一个AggregateFunction需要实现4个方法：

  1. public interface AggregateFunction<IN, ACC, OUT> extends Function, Serializable {
  2.     ACC createAccumulator();
  3.     ACC add(IN value, ACC accumulator);
  4.     OUT getResult(ACC accumulator);
  5.     ACC merge(ACC a, ACC b);
  6. }

前三个方法都很容易理解，但第四个merge()方法就有些令人费解了：到底什么时候需要合并两个累加器的数据呢？最近也有童鞋问到了这个问题。实际上，这个方法是专门为会话窗口（session window）服务的。下面来解析一下会话窗口。

Session Window & MergingWindowAssigner

stream.keyBy("userId").window(EventTimeSessionWindows.withGap(Time.seconds(gap))) 在普通的翻滚窗口和滑动窗口中，窗口的范围是按时间区间固定的，虽然范围有可能重合，但是处理起来是各自独立的，并不会相互影响。但是会话窗口则不同，其范围是根据事件之间的时间差是否超过gap来确定的（超过gap就形成一个新窗口），也就是说并非固定。所以，我们需要在每个事件进入会话窗口算子时就为它分配一个初始窗口，起点是它本身所携带的时间戳（这里按event time处理），终点则是时间戳加上gap的偏移量。这样的话，如果两个事件所在的初始窗口没有相交，说明它们属于不同的会话；如果相交，则说明它们属于同一个会话，并且要把这两个初始窗口合并在一起，作为新的会话窗口。多个事件则依次类推，最终形成上面图示的情况。

为了支持会话窗口的合并，它们的WindowAssigner也有所不同，称为MergingWindowAssigner，如下类图所示。

MergingWindowAssigner是一个抽象类，代码很简单，定义了用于合并窗口的mergeWindows()方法以及合并窗口时的回调MergeCallback。

  1. public abstract class MergingWindowAssigner<T, W extends Window> extends WindowAssigner<T, W> {
  2.     private static final long serialVersionUID = 1L;
  3.  
  4.     public abstract void mergeWindows(Collection<W> windows, MergeCallback<W> callback);
  5.  
  6.     public interface MergeCallback<W> {
  7.         void merge(Collection<W> toBeMerged, W mergeResult);
  8.     }
  9. }

所有MergingWindowAssigner实现类的mergeWindows()方法都是相同的，即直接调用TimeWindow.mergeWindows()方法，其源码如下。

  1. public static void mergeWindows(Collection<TimeWindow> windows, MergingWindowAssigner.MergeCallback<TimeWindow> c)
  2.     // sort the windows by the start time and then merge overlapping windows
  3.     List<TimeWindow> sortedWindows = new ArrayList<>(windows);
  4.     Collections.sort(sortedWindows, new Comparator<TimeWindow>() {
  5.         @Override
  6.         public int compare(TimeWindow o1, TimeWindow o2) {
  7.             return Long.compare(o1.getStart(), o2.getStart());
  8.         }
  9.     });
  10.  
  11.     List<Tuple2<TimeWindow, Set<TimeWindow>>> merged = new ArrayList<>();
  12.     Tuple2<TimeWindow, Set<TimeWindow>> currentMerge = null;
  13.  
  14.     for (TimeWindow candidate: sortedWindows) {
  15.         if (currentMerge == null) {
  16.             currentMerge = new Tuple2<>();
  17.             currentMerge.f0 = candidate;
  18.             currentMerge.f1 = new HashSet<>();
  19.             currentMerge.f1.add(candidate);
  20.         } else if (currentMerge.f0.intersects(candidate)) {
  21.             currentMerge.f0 = currentMerge.f0.cover(candidate);
  22.             currentMerge.f1.add(candidate);
  23.         } else {
  24.             merged.add(currentMerge);
  25.             currentMerge = new Tuple2<>();
  26.             currentMerge.f0 = candidate;
  27.             currentMerge.f1 = new HashSet<>();
  28.             currentMerge.f1.add(candidate);
  29.         }
  30.     }
  31.  
  32.     if (currentMerge != null) {
  33.         merged.add(currentMerge);
  34.     }
  35.  
  36.     for (Tuple2<TimeWindow, Set<TimeWindow>> m: merged) {
  37.         if (m.f1.size() > 1) {
  38.             c.merge(m.f1, m.f0);
  39.         }
  40.     }
  41. }
  42.  
  43. // TimeWindow.intersects()
  44. public boolean intersects(TimeWindow other) {
  45.     return this.start <= other.end && this.end >= other.start;
  46. }
  47.  
  48. // TimeWindow.cover()
  49. public TimeWindow cover(TimeWindow other) {
  50.     return new TimeWindow(Math.min(start, other.start), Math.max(end, other.end));
  51. }

该方法将所有待合并的窗口按照起始时间升序排序，遍历排序好的窗口，并调用intersects()方法判断它们是否相交。如果相交，则调用cover()方法合并返回一个覆盖两个窗口的窗口；如果不相交，则启动下一次合并过程。列表merged中存储的就是［合并结果, 原窗口集合］的二元组，如果原窗口集合的大小大于1，说明发生了合并，需要调用回调方法MergeCallback.merge()。

就这么简单吗？当然不是。上面的逻辑只是在时域的角度合并了窗口，但是别忘了，窗口是需要维护状态和触发器的，所以它们也得被合并才能保证不出错。下面就来介绍跟踪窗口状态合并的MergingWindowSet组件。

MergingWindowSet

MergingWindowSet的思路很直接：既然状态的创建和维护是比较重的操作，那么就在一批窗口合并时，以其中一个窗口的状态为基准，其他窗口的状态都直接合并到这个基准窗口的状态里来，称为“状态窗口”。这样就避免了创建新的状态实例，只需要维护合并的窗口与状态窗口之间的映射关系，以及保证映射关系的容错（通过ListState）即可。

  1. // Mapping from window to the window that keeps the window state...
  2. private final Map<W, W> mapping;
  3.  
  4. // Mapping when we created the MergingWindowSet...
  5. private final Map<W, W> initialMapping;
  6.  
  7. private final ListState<Tuple2<W, W>> state;
  8.  
  9. public W getStateWindow(W window) {
  10.     return mapping.get(window);
  11. }
  12.  
  13. public void persist() throws Exception {
  14.     if (!mapping.equals(initialMapping)) {
  15.         state.clear();
  16.         for (Map.Entry<W, W> window : mapping.entrySet()) {
  17.             state.add(new Tuple2<>(window.getKey(), window.getValue()));
  18.         }
  19.     }
  20. }

MergingWindowSet的核心逻辑位于add()方法中。该方法输入一个新窗口，并试图将其时域和状态进行合并，代码如下。

  1. public W addWindow(W newWindow, MergeFunction<W> mergeFunction) throws Exception {
  2.     List<W> windows = new ArrayList<>();
  3.     windows.addAll(this.mapping.keySet());
  4.     windows.add(newWindow);
  5.  
  6.     final Map<W, Collection<W>> mergeResults = new HashMap<>();
  7.     windowAssigner.mergeWindows(windows,
  8.             new MergingWindowAssigner.MergeCallback<W>() {
  9.                 @Override
  10.                 public void merge(Collection<W> toBeMerged, W mergeResult) {
  11.                     if (LOG.isDebugEnabled()) {
  12.                         LOG.debug("Merging {} into {}", toBeMerged, mergeResult);
  13.                     }
  14.                     mergeResults.put(mergeResult, toBeMerged);
  15.                 }
  16.             });
  17.  
  18.     W resultWindow = newWindow;
  19.     boolean mergedNewWindow = false;
  20.  
  21.     // perform the merge
  22.     for (Map.Entry<W, Collection<W>> c: mergeResults.entrySet()) {
  23.         W mergeResult = c.getKey();
  24.         Collection<W> mergedWindows = c.getValue();
  25.         // if our new window is in the merged windows make the merge result the
  26.         // result window
  27.         if (mergedWindows.remove(newWindow)) {
  28.             mergedNewWindow = true;
  29.             resultWindow = mergeResult;
  30.         }
  31.         // pick any of the merged windows and choose that window's state window
  32.         // as the state window for the merge result
  33.         W mergedStateWindow = this.mapping.get(mergedWindows.iterator().next());
  34.         // figure out the state windows that we are merging
  35.         List<W> mergedStateWindows = new ArrayList<>();
  36.         for (W mergedWindow: mergedWindows) {
  37.             W res = this.mapping.remove(mergedWindow);
  38.             if (res != null) {
  39.                 mergedStateWindows.add(res);
  40.             }
  41.         }
  42.         this.mapping.put(mergeResult, mergedStateWindow);
  43.         // don't put the target state window into the merged windows
  44.         mergedStateWindows.remove(mergedStateWindow);
  45.         // don't merge the new window itself, it never had any state associated with it
  46.         // i.e. if we are only merging one pre-existing window into itself
  47.         // without extending the pre-existing window
  48.         if (!(mergedWindows.contains(mergeResult) && mergedWindows.size() == 1)) {
  49.             mergeFunction.merge(mergeResult,
  50.                     mergedWindows,
  51.                     this.mapping.get(mergeResult),
  52.                     mergedStateWindows);
  53.         }
  54.     }
  55.  
  56.     // the new window created a new, self-contained window without merging
  57.     if (mergeResults.isEmpty() || (resultWindow.equals(newWindow) && !mergedNewWindow)) {
  58.         this.mapping.put(resultWindow, resultWindow);
  59.     }
  60.     return resultWindow;
  61. }

前面调用MergingWindowAssigner.mergeWindows()方法的逻辑已经提过了，重点在后面状态的合并。注释写得比较详细，多读几遍即可理解，不再多废话，只解释一下四个关键变量的含义：

  • mergeResult：窗口的时域合并结果；

  • mergedWindows：本次被合并的窗口集合；

  • mergedStateWindow：将要合并的状态窗口结果（目前就是基准的状态窗口）；

  • mergedStateWindows：本次被合并的状态窗口集合。

最后，回调MergeFunction.merge()方法进行正式的合并。MergeFunction的定义同样位于MergingWindowSet中，其merge()方法的参数与上面四个变量是一一对应的。

  1. public interface MergeFunction<W> {
  2.     /**
  3.      * This gets called when a merge occurs.
  4.      *
  5.      * @param mergeResult The newly resulting merged {@code Window}.
  6.      * @param mergedWindows The merged {@code Window Windows}.
  7.      * @param stateWindowResult The state window of the merge result.
  8.      * @param mergedStateWindows The merged state windows.
  9.      * @throws Exception
  10.      */
  11.     void merge(W mergeResult, Collection<W> mergedWindows, W stateWindowResult, Collection<W> mergedStateWindows) throws Exception;
  12. }

接下来去到窗口算子WindowOperator中，完成最后一步。

Window Merging in WindowOperator

以下是WindowOperator.processElement()方法中，处理MergingWindowAssigner的部分。

  1. @Override
  2. public void processElement(StreamRecord<IN> element) throws Exception {
  3.     final Collection<W> elementWindows = windowAssigner.assignWindows(
  4.         element.getValue(), element.getTimestamp(), windowAssignerContext);
  5.  
  6.     //if element is handled by none of assigned elementWindows
  7.     boolean isSkippedElement = true;
  8.  
  9.     final K key = this.<K>getKeyedStateBackend().getCurrentKey();
  10.  
  11.     if (windowAssigner instanceof MergingWindowAssigner) {
  12.         MergingWindowSet<W> mergingWindows = getMergingWindowSet();
  13.  
  14.         for (W window: elementWindows) {
  15.             // adding the new window might result in a merge, in that case the actualWindow
  16.             // is the merged window and we work with that. If we don't merge then
  17.             // actualWindow == window
  18.             W actualWindow = mergingWindows.addWindow(window, new MergingWindowSet.MergeFunction<W>() {
  19.                 @Override
  20.                 public void merge(W mergeResult,
  21.                         Collection<W> mergedWindows, W stateWindowResult,
  22.                         Collection<W> mergedStateWindows) throws Exception {
  23.                     if ((windowAssigner.isEventTime() && mergeResult.maxTimestamp() + allowedLateness <= internalTimerService.currentWatermark())) {
  24.                         // ...
  25.                     } else if (!windowAssigner.isEventTime()) {
  26.                         // ...
  27.                     }
  28.  
  29.                     triggerContext.key = key;
  30.                     triggerContext.window = mergeResult;
  31.                     triggerContext.onMerge(mergedWindows);
  32.  
  33.                     for (W m: mergedWindows) {
  34.                         triggerContext.window = m;
  35.                         triggerContext.clear();
  36.                         deleteCleanupTimer(m);
  37.                     }
  38.  
  39.                     // merge the merged state windows into the newly resulting state window
  40.                     windowMergingState.mergeNamespaces(stateWindowResult, mergedStateWindows);
  41.                 }
  42.             });
  43.  
  44.             // drop if the window is already late
  45.             if (isWindowLate(actualWindow)) {
  46.                 mergingWindows.retireWindow(actualWindow);
  47.                 continue;
  48.             }
  49.             isSkippedElement = false;
  50.  
  51.             W stateWindow = mergingWindows.getStateWindow(actualWindow);
  52.             if (stateWindow == null) {
  53.                 throw new IllegalStateException("Window " + window + " is not in in-flight window set.");
  54.             }
  55.             windowState.setCurrentNamespace(stateWindow);
  56.             windowState.add(element.getValue());
  57.  
  58.             triggerContext.key = key;
  59.             triggerContext.window = actualWindow;
  60.             TriggerResult triggerResult = triggerContext.onElement(element);
  61.  
  62.             if (triggerResult.isFire()) {
  63.                 ACC contents = windowState.get();
  64.                 if (contents == null) {
  65.                     continue;
  66.                 }
  67.                 emitWindowContents(actualWindow, contents);
  68.             }
  69.             if (triggerResult.isPurge()) {
  70.                 windowState.clear();
  71.             }
  72.  
  73.             registerCleanupTimer(actualWindow);
  74.         }
  75.         // need to make sure to update the merging state in state
  76.         mergingWindows.persist();
  77.     } else {
  78.         // ......
  79.     }
  80.     // ......
  81. }

该方法先获得输入的流元素分配到的窗口，然后调用MergingWindowSet.addWindow()方法试图合并它。特别注意MergeFunction.merge()方法，它做了如下两件事：

  • 调用TriggerContext.onMerge()方法，更新触发器注册的定时器时间，然后遍历所有被合并的原始窗口，调用TriggerContext.clear()方法删除它们的触发器，保证合并后的窗口能够被正确地触发；

  • 调用InternalMergingState.mergeNamespaces()方法，将待合并窗口的状态与基准窗口的状态合并，产生的stateWindowResult就是状态窗口。

addWindow()方法返回的actualWindow就是合并之后的真正窗口，然后再根据MergingWindowSet中维护的映射关系，取出它所对应的状态窗口，并将输入元素加入状态窗口中。最后，根据更新后的触发器逻辑判断窗口需要fire还是purge，并触发执行相应的操作。整个窗口合并的流程就完成了。

Back on AggregateFunction

前面说了这么多，AggregateFunction.merge()方法到底在哪里呢？注意上一节中出现的用于合并窗口状态的InternalMergingState.mergeNamespaces()方法，InternalMergingState是Flink状态体系中所有能够合并的状态的基类。下面观察它的两个实现类：

  • 基于堆的AbstractHeapMergingState→HeapAggregatingState

  1. @Override
  2. public void mergeNamespaces(N target, Collection<N> sources) throws Exception {
  3.     if (sources == null || sources.isEmpty()) {
  4.         return; // nothing to do
  5.     }
  6.     final StateTable<K, N, SV> map = stateTable;
  7.     SV merged = null;
  8.     // merge the sources
  9.     for (N source : sources) {
  10.         // get and remove the next source per namespace/key
  11.         SV sourceState = map.removeAndGetOld(source);
  12.         if (merged != null && sourceState != null) {
  13.             merged = mergeState(merged, sourceState);  // <----
  14.         } else if (merged == null) {
  15.             merged = sourceState;
  16.         }
  17.     }
  18.     // merge into the target, if needed
  19.     if (merged != null) {
  20.         map.transform(target, merged, mergeTransformation);
  21.     }
  22. }
  23.  
  24. @Override
  25. protected ACC mergeState(ACC a, ACC b) {
  26.     return aggregateTransformation.aggFunction.merge(a, b);  // <----
  27. }

  • 基于RocksDB的RocksDBAggregatingState

  1. @Override
  2. public void mergeNamespaces(N target, Collection<N> sources) {
  3.     if (sources == null || sources.isEmpty()) {
  4.         return;
  5.     }
  6.     try {
  7.         ACC current = null;
  8.         // merge the sources to the target
  9.         for (N source : sources) {
  10.             if (source != null) {
  11.                 setCurrentNamespace(source);
  12.                 final byte[] sourceKey = serializeCurrentKeyWithGroupAndNamespace();
  13.                 final byte[] valueBytes = backend.db.get(columnFamily, sourceKey);
  14.                 backend.db.delete(columnFamily, writeOptions, sourceKey);
  15.                 if (valueBytes != null) {
  16.                     dataInputView.setBuffer(valueBytes);
  17.                     ACC value = valueSerializer.deserialize(dataInputView);
  18.                     if (current != null) {
  19.                         current = aggFunction.merge(current, value);  // <----
  20.                     }
  21.                     else {
  22.                         current = value;
  23.                     }
  24.                 }
  25.             }
  26.         }
  27.         // ......
  28.     }
  29.     catch (Exception e) {
  30.         throw new FlinkRuntimeException("Error while merging state in RocksDB", e);
  31.     }
  32. }

可见，累加器其实就是AggregateFunction维护的状态。当AggregateFunction与会话窗口一同使用来实现增量聚合时，就会调用用户实现的merge()方法来合并累加器中的数据了。也就是说，如果我们没有使用会话窗口，那么不实现merge()方法同样没问题。

Flink定时器

在flink实时处理中，涉及到延时处理可使用KeyedProcessFunction来完成，KeyedProcessFunction是flink提供面向用户的low level api，可以访问状态、当前的watermark或者当前的processingtime, 更重要的是提供了注册定时器的功能，分为：

  • 注册处理时间定时器，直到系统的processingTime超过了注册的时间就会触发定时任务

  • 注册事件时间定时器，直到watermark值超过了注册的时间就会触发定时任务另外也可以删除已经注册的定时器。

示例代码如下：

  1. // 创建bean类CountWithTimestamp，里面有三个字段
  2. package com.bolingcavalry.keyedprocessfunction;
  3.  
  4. public class CountWithTimestamp {
  5.     public String key;
  6.     public long count;
  7.     public long lastModified;
  8. }
  1. // 创建FlatMapFunction的实现类Splitter，作用是将字符串分割后生成多个Tuple2实例，f0是分隔后的单词，f1等于1：
  2. package com.bolingcavalry;
  3.  
  4. import org.apache.flink.api.common.functions.FlatMapFunction;
  5. import org.apache.flink.api.java.tuple.Tuple2;
  6. import org.apache.flink.util.Collector;
  7. import org.apache.flink.util.StringUtils;
  8.  
  9. public class Splitter implements FlatMapFunction<String, Tuple2<String, Integer>> {
  10.     @Override
  11.     public void flatMap(String s, Collector<Tuple2<String, Integer>> collector) throws Exception {
  12.  
  13.         if(StringUtils.isNullOrWhitespaceOnly(s)) {
  14.             System.out.println("invalid line");
  15.             return;
  16.         }
  17.  
  18.         for(String word : s.split(" ")) {
  19.             collector.collect(new Tuple2<String, Integer>(word, 1));
  20.         }
  21.     }
  22. }
  1. // 最后是整个逻辑功能的主体：ProcessTime.java，这里面有自定义的KeyedProcessFunction子类，还有程序入口的main方法
  2. package com.bolingcavalry.keyedprocessfunction;
  3.  
  4. import com.bolingcavalry.Splitter;
  5. import org.apache.flink.api.common.state.ValueState;
  6. import org.apache.flink.api.common.state.ValueStateDescriptor;
  7. import org.apache.flink.api.java.tuple.Tuple;
  8. import org.apache.flink.api.java.tuple.Tuple2;
  9. import org.apache.flink.configuration.Configuration;
  10. import org.apache.flink.streaming.api.TimeCharacteristic;
  11. import org.apache.flink.streaming.api.datastream.DataStream;
  12. import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
  13. import org.apache.flink.streaming.api.functions.AssignerWithPeriodicWatermarks;
  14. import org.apache.flink.streaming.api.functions.KeyedProcessFunction;
  15. import org.apache.flink.streaming.api.watermark.Watermark;
  16. import org.apache.flink.util.Collector;
  17. import java.text.SimpleDateFormat;
  18. import java.util.Date;
  19.  
  20.  
  21. /**
  22.  * @description 体验KeyedProcessFunction类(时间类型是处理时间)
  23.  */
  24. public class ProcessTime {
  25.  
  26.     /**
  27.      * KeyedProcessFunction的子类，作用是将每个单词最新出现时间记录到backend，并创建定时器，
  28.      * 定时器触发的时候，检查这个单词距离上次出现是否已经达到10秒，如果是，就发射给下游算子
  29.      */
  30.     static class CountWithTimeoutFunction extends KeyedProcessFunction<Tuple, Tuple2<String, Integer>, Tuple2<String, Long>> {
  31.  
  32.         // 自定义状态
  33.         private ValueState<CountWithTimestamp> state;
  34.  
  35.         @Override
  36.         public void open(Configuration parameters) throws Exception {
  37.             // 初始化状态，name是myState
  38.             state = getRuntimeContext().getState(new ValueStateDescriptor<>("myState", CountWithTimestamp.class));
  39.         }
  40.  
  41.         @Override
  42.         public void processElement(
  43.                 Tuple2<String, Integer> value,
  44.                 Context ctx,
  45.                 Collector<Tuple2<String, Long>> out) throws Exception {
  46.  
  47.             // 取得当前是哪个单词
  48.             Tuple currentKey = ctx.getCurrentKey();
  49.  
  50.             // 从backend取得当前单词的myState状态
  51.             CountWithTimestamp current = state.value();
  52.  
  53.             // 如果myState还从未没有赋值过，就在此初始化
  54.             if (current == null) {
  55.                 current = new CountWithTimestamp();
  56.                 current.key = value.f0;
  57.             }
  58.  
  59.             // 单词数量加一
  60.             current.count++;
  61.  
  62.             // 取当前元素的时间戳，作为该单词最后一次出现的时间
  63.             current.lastModified = ctx.timestamp();
  64.  
  65.             // 重新保存到backend，包括该单词出现的次数，以及最后一次出现的时间
  66.             state.update(current);
  67.  
  68.             // 为当前单词创建定时器，十秒后后触发
  69.             long timer = current.lastModified + 10000;
  70.  
  71.             ctx.timerService().registerProcessingTimeTimer(timer);
  72.  
  73.             // 打印所有信息，用于核对数据正确性
  74.             System.out.println(String.format("process, %s, %d, lastModified : %d (%s), timer : %d (%s)\n\n",
  75.                     currentKey.getField(0),
  76.                     current.count,
  77.                     current.lastModified,
  78.                     time(current.lastModified),
  79.                     timer,
  80.                     time(timer)));
  81.  
  82.         }
  83.  
  84.         /**
  85.          * 定时器触发后执行的方法
  86.          * @param timestamp 这个时间戳代表的是该定时器的触发时间
  87.          * @param ctx
  88.          * @param out
  89.          * @throws Exception
  90.          */
  91.         @Override
  92.         public void onTimer(
  93.                 long timestamp,
  94.                 OnTimerContext ctx,
  95.                 Collector<Tuple2<String, Long>> out) throws Exception {
  96.  
  97.             // 取得当前单词
  98.             Tuple currentKey = ctx.getCurrentKey();
  99.  
  100.             // 取得该单词的myState状态
  101.             CountWithTimestamp result = state.value();
  102.  
  103.             // 当前元素是否已经连续10秒未出现的标志
  104.             boolean isTimeout = false;
  105.  
  106.             // timestamp是定时器触发时间，如果等于最后一次更新时间+10秒，就表示这十秒内已经收到过该单词了，
  107.             // 这种连续十秒没有出现的元素，被发送到下游算子
  108.             if (timestamp == result.lastModified + 10000) {
  109.                 // 发送
  110.                 out.collect(new Tuple2<String, Long>(result.key, result.count));
  111.  
  112.                 isTimeout = true;
  113.             }
  114.  
  115.             // 打印数据，用于核对是否符合预期
  116.             System.out.println(String.format("ontimer, %s, %d, lastModified : %d (%s), stamp : %d (%s), isTimeout : %s\n\n",
  117.                     currentKey.getField(0),
  118.                     result.count,
  119.                     result.lastModified,
  120.                     time(result.lastModified),
  121.                     timestamp,
  122.                     time(timestamp),
  123.                     String.valueOf(isTimeout)));
  124.         }
  125.     }
  126.  
  127.  
  128.     public static void main(String[] args) throws Exception {
  129.         final StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
  130.  
  131.         // 并行度1
  132.         env.setParallelism(1);
  133.  
  134.        // 处理时间
  135.         env.setStreamTimeCharacteristic(TimeCharacteristic.ProcessingTime);
  136.  
  137.         // 监听本地9999端口，读取字符串
  138.         DataStream<String> socketDataStream = env.socketTextStream("localhost", 9999);
  139.  
  140.         // 所有输入的单词，如果超过10秒没有再次出现，都可以通过CountWithTimeoutFunction得到
  141.         DataStream<Tuple2<String, Long>> timeOutWord = socketDataStream
  142.                 // 对收到的字符串用空格做分割，得到多个单词
  143.                 .flatMap(new Splitter())
  144.                 // 设置时间戳分配器，用当前时间作为时间戳
  145.                 .assignTimestampsAndWatermarks(new AssignerWithPeriodicWatermarks<Tuple2<String, Integer>>() {
  146.  
  147.                     @Override
  148.                     public long extractTimestamp(Tuple2<String, Integer> element, long previousElementTimestamp) {
  149.                         // 使用当前系统时间作为时间戳
  150.                         return System.currentTimeMillis();
  151.                     }
  152.  
  153.                     @Override
  154.                     public Watermark getCurrentWatermark() {
  155.                         // 本例不需要watermark，返回null
  156.                         return null;
  157.                     }
  158.                 })
  159.                 // 将单词作为key分区
  160.                 .keyBy(0)
  161.                 // 按单词分区后的数据，交给自定义KeyedProcessFunction处理
  162.                 .process(new CountWithTimeoutFunction());
  163.  
  164.         // 所有输入的单词，如果超过10秒没有再次出现，就在此打印出来
  165.         timeOutWord.print();
  166.  
  167.         env.execute("ProcessFunction demo : KeyedProcessFunction");
  168.     }
  169.  
  170.     public static String time(long timeStamp) {
  171.         return new SimpleDateFormat("yyyy-MM-dd hh:mm:ss").format(new Date(timeStamp));
  172.     }
  173. }
定时器原理

上图表示flink延时调用的总体流程，其设计也是借助于优先级队列（小顶堆）来完成，堆使用二叉树实现，而二叉树使用数组存储。队列中存储的数据结构如下：

  1. @Internal
  2. public final class TimerHeapInternalTimer<K, N> implements InternalTimer<K, N>, HeapPriorityQueueElement {
  3.  
  4.     // Key 表示KeyedStream中提取的Key
  5.     @Nonnull
  6.     private final K key;
  7.  
  8.     // Namespace 表示命名空间，在普通的KeyedStream中是固定的VoidNamespace,在WindowedStream表示的是Window
  9.     @Nonnull
  10.     private final N namespace;
  11.  
  12.     // Timestamp表示触发的时间戳，在优先级队列中升序排序               
  13.     // 由于该类重写了equals方法，在插入队列，即使尝试重复插入相同的TimerHeapInternalTimer对象多次，也会确保只有一个TimerHeapInternalTimer对象入队成功。详情见下文。
  14.     private final long timestamp;
  15.  
  16.     @Override
  17.     public boolean equals(Object o) {
  18.         if (this == o) {
  19.             return true;
  20.         }
  21.  
  22.         if (o instanceof InternalTimer) {
  23.             InternalTimer<?, ?> timer = (InternalTimer<?, ?>) o;
  24.             return timestamp == timer.getTimestamp()
  25.                 && key.equals(timer.getKey())
  26.                 && namespace.equals(timer.getNamespace());
  27.         }
  28.  
  29.         return false;
  30.     }
  31. }

注册

ProcessingTime类型注册使用registerProcessingTimeTimer，传入的是一个触发的时间戳，内部会将获取到当前的Key、VoidNamespace 、timestamp封装成为一个InternalTimer对象存入优先级队列（小顶堆）中。并且会针对堆顶元素，使用ScheduledThreadPoolExecutor注册一个堆顶元素触发时间与当前时间差值大小的延时调用。

EventTime类型注册使用registerEventTimeTimer，与ProcessingTime类型注册不同的是不需要做延时调用，并且二者使用的是不同的队列

下面以TimerService#registerProcessingTimeTimer为入口，分析一下基于process time的定时器的入队过程：

  1. // 自定义KeyedProcessFunction
  2. static class CountWithTimeoutFunction extends KeyedProcessFunction<Tuple, Tuple2<String, Integer>, Tuple2<String, Long>> {
  3.         // 每来一条数据，都会经过此方法进行处理
  4.        @Override
  5.         public void processElement(
  6.                 Tuple2<String, Integer> value,
  7.                 Context ctx,
  8.                 Collector<Tuple2<String, Long>> out) throws Exception {
  9.         ...
  10.             long timer = current.lastModified + 10000;
  11.             // 注册定时器
  12.             ctx.timerService().registerProcessingTimeTimer(timer);
  13.         ...
  14.         }
  15.  
  16.         // 定时器回调函数
  17.        @Override
  18.         public void onTimer(
  19.                 long timestamp,
  20.                 OnTimerContext ctx,
  21.                 Collector<Tuple2<String, Long>> out) throws Exception {
  22.         ...
  23.         CountWithTimestamp result = state.value();
  24.         // 定时器到达时间，则往下游发送数据
  25.         out.collect(new Tuple2<String, Long>(result.key, result.count));
  26.         ...
  27.         }
  28. }
  1. @Internal
  2. public class SimpleTimerService implements TimerService {
  3.     @Override
  4.     public void registerProcessingTimeTimer(long time) {
  5.         // 注册定时器
  6.         internalTimerService.registerProcessingTimeTimer(VoidNamespace.INSTANCE, time);
  7.     }
  8. }
  1. public class InternalTimerServiceImpl<K, N> implements InternalTimerService<N> {
  2.     @Override
  3.     public void registerProcessingTimeTimer(N namespace, long time) {
  4.         InternalTimer<K, N> oldHead = processingTimeTimersQueue.peek();
  5.         // 定时器入队
  6.         // 一旦if条件满足，则证明入队成功且入队的是小顶堆的堆顶元素，要针对小顶堆堆顶元素创建延迟调用
  7.         if (processingTimeTimersQueue.add(new TimerHeapInternalTimer<>(time, (K) keyContext.getCurrentKey(), namespace))) {
  8.             long nextTriggerTime = oldHead != null ? oldHead.getTimestamp() : Long.MAX_VALUE;
  9.             // check if we need to re-schedule our timer to earlier
  10.             if (time < nextTriggerTime) {
  11.                 if (nextTimer != null) {
  12.                     nextTimer.cancel(false);
  13.                 }
  14.                 nextTimer = processingTimeService.registerTimer(time, this::onProcessingTime);
  15.             }
  16.         }
  17.     }
  18. }
  1. public abstract class AbstractHeapPriorityQueue<T extends HeapPriorityQueueElement> implements InternalPriorityQueue<T> {
  2.     @Override
  3.     public boolean add(@Nonnull T toAdd) {
  4.         // 定时器入队
  5.         addInternal(toAdd);
  6.         // 如果入队后的定时器是堆顶节点，则返回true，后面的逻辑会根据这里是否返回true，来判断是否需要建立ScheduledThreadPoolExecutor延迟调用；换言之，延迟调用只会根据堆顶节点来建立
  7.         return toAdd.getInternalIndex() == getHeadElementIndex();
  8.     }
  9. }

经过以上步骤，就完成了定时器的入队操作。如果入队的是小顶堆的堆顶元素，则需要针对其创建延迟调用。代码如下：

  1. public class SystemProcessingTimeService implements TimerService {
  2.     @Override
  3.     public ScheduledFuture<?> registerTimer(long timestamp, ProcessingTimeCallback callback) {
  4.         // 这里延迟调用的时间颇有讲究，并非是用定时器时间减去当前时间这么简单，而是要将相减的值再加1ms
  5.         // 这么做是为了与watemark的语义保持一致（虽然基于processtime的定时器用不到watermark）
  6.         // 例如，在窗口 [20000, 30000)中，30000这个时间点是不会触发窗口计算的，只有当watermark至少为30001时，才会触发窗口操作。有兴趣的同学可以看一下该方法源码中的注释。
  7.         long delay = ProcessingTimeServiceUtil.getProcessingTimeDelay(timestamp, getCurrentProcessingTime());
  8.  
  9.         // we directly try to register the timer and only react to the status on exception
  10.         // that way we save unnecessary volatile accesses for each timer
  11.         try {
  12.             // 这里wrapOnTimerCallback(callback, timestamp)中的一波lambda操作秀我一脸，看似复杂，其实直接看作是callback即可
  13.             // 往上追溯一下，你就会发现callback其实就是InternalTimerServiceImpl#onProcessingTime方法
  14.             return timerService.schedule(wrapOnTimerCallback(callback, timestamp), delay, TimeUnit.MILLISECONDS);
  15.         }
  16.         catch (RejectedExecutionException e) {
  17.             final int status = this.status.get();
  18.             if (status == STATUS_QUIESCED) {
  19.                 return new NeverCompleteFuture(delay);
  20.             }
  21.             else if (status == STATUS_SHUTDOWN) {
  22.                 throw new IllegalStateException("Timer service is shut down");
  23.             }
  24.             else {
  25.                 // something else happened, so propagate the exception
  26.                 throw e;
  27.             }
  28.         }
  29.     }
  30. }

到这里，保存定时器的小顶堆维护好了，基于堆顶元素触发时间创建的延时调用也创建好了，接下来到时间就会触发回调函数了。

ProcessingTime类型的定时触发由注册的时候的延时调度触发，会不断从小顶堆堆顶弹出定时器，触发KeyedProcessFunction#onTimer方法，onTimer方法中可以从上下文OnTimerContext中获取到当前的key以及触发时间，有了key就可以从ValueState中提取出当前key对应的值（ValueState是一个散列表，其根据上下文中key获取value的逻辑对用户不可见，进一步进行某些计算。

当获取到InternalTimer对象中的时间大于延时调度时间，停止弹出定时器并处罚onTimer方法，重新针对堆顶元素建立新的延迟调用。

  1. public class InternalTimerServiceImpl<K, N> implements InternalTimerService<N>, ProcessingTimeCallback {
  2.  
  3.   @Override
  4.     public void onProcessingTime(long time) throws Exception {
  5.         // null out the timer in case the Triggerable calls registerProcessingTimeTimer()
  6.         // inside the callback.
  7.         nextTimer = null;
  8.  
  9.         InternalTimer<K, N> timer;
  10.         // 从小顶堆堆顶依次弹出到达时间的定时器，调用用户自定义的KeyedProcessFunction#onTimer方法
  11.         // 一旦堆顶元素不满足触发时间，则重新针对堆顶元素建立延迟调用
  12.         while ((timer = processingTimeTimersQueue.peek()) != null && timer.getTimestamp() <= time) {
  13.             processingTimeTimersQueue.poll();
  14.             keyContext.setCurrentKey(timer.getKey());
  15.             triggerTarget.onProcessingTime(timer);
  16.         }
  17.  
  18.     // 这段逻辑调用processingTimeService实现类SystemProcessingTimeService中的registerTimer方法，该方法中将上次遍历中的最后一个timer的触发时间注册到ScheduledThreadPoolExecutor线程池中，实现再次延迟调用当前  InternalTimerServiceImpl#onProcessingTime，以此实现while逻辑的不断执行，即优先级队列的不断遍历
  19.         if (timer != null && nextTimer == null) {
  20.             nextTimer = processingTimeService.registerTimer(timer.getTimestamp(), this);
  21.         }
  22.     }
  23. }

EventTime类型的定时器触发是由Watermark决定的，同样会不断遍历优先级队列触发任务，直到获取到InternalTimer对象中的时间大于Watermark值；

延迟队列state

为了保证任务重启仍然能够执行未完成的延时调用，flink会在checkpoint过程中将优先级队列中的数据一起持久化到hdfs上，待下次任务重启仍然能够获取到这部分数据。由于EventTime类型定时器是由Watermark,那么只要任务产生watermark就能正常触发恢复的定时任务，但是ProcessingTime类型的定时器是由系统注册的延时调度来触发，所以在重启的时候获取到队列中第一个元素来注册延时调度，保证其恢复之后的正常触发。

定时器注意事项

优先级队列默认使用的是内存存储，在一些数据量比较大并且重度依赖定时触发的任务会占用比较大的内存，可以选择Rocksdb存储定时信息

flink为了保证定时触发操作(onTimer)与正常处理(processElement)操作的线程安全，做了同步处理，在调用触发时必须要获取到锁，也就是二者同时只能有一个执行，因此一定要保证onTimer处理的速度，以免任务发生阻塞。

如果不做同步处理，processElement方法中会进行state.update()，onTimer中会进行state.value()，两者会发生不一致从而引发线程安全问题。

Hudi on Flink在顺丰的实践应用

数据湖在大数据典型场景下应用调研个人笔记

基于Flink和Druid的实时多维分析系统在蔚来汽车的应用

欢迎点赞+收藏+转发朋友圈素质三连

文章不错？点个【在看】吧！ 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小蓝xlanll/article/detail/541897
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号