Flink 1.6.0 Windows操作

原文连接 https://ci.apache.org/projects/flink/flink-docs-release-1.6/dev/stream/operators/windows.html

Windows是无限数据流(infinite streams)处理的核心,Windows将一个stream拆分成有限大小的"桶(buckets)",可以在这些桶上做计算操作。

窗口化的Flink程序的一般结构如下,第一个代码段中是分组的流,第二段是非分组的流。区别是分组的stream调用keyBy(...)window(...),非分组的stream中window(...)换成了windowAll(...)

分组窗口(Keyed Windows)

stream
       .keyBy(...)               <-  keyed versus non-keyed windows
       .window(...)              <-  required: "assigner"
      [.trigger(...)]            <-  optional: "trigger" (else default trigger)
      [.evictor(...)]            <-  optional: "evictor" (else no evictor)
      [.allowedLateness(...)]    <-  optional: "lateness" (else zero)
      [.sideOutputLateData(...)] <-  optional: "output tag" (else no side output for late data)
       .reduce/aggregate/fold/apply()      <-  required: "function"
      [.getSideOutput(...)]      <-  optional: "output tag"

无分组窗口(Non-Keyed Windows)

stream
       .windowAll(...)           <-  required: "assigner"
      [.trigger(...)]            <-  optional: "trigger" (else default trigger)
      [.evictor(...)]            <-  optional: "evictor" (else no evictor)
      [.allowedLateness(...)]    <-  optional: "lateness" (else zero)
      [.sideOutputLateData(...)] <-  optional: "output tag" (else no side output for late data)
       .reduce/aggregate/fold/apply()      <-  required: "function"
      [.getSideOutput(...)]      <-  optional: "output tag"

方括号[]内的命令是可选的,这表明Flink允许你根据最符合你的要求来定义自己的window逻辑。

Window生命周期(Window Lifecycle)

简单地说,当一个属于window的元素到达之后这个window就创建了,而当时间(event time或者processing time)超过window的创建时间和用户指定的延迟时间相加时,窗口将被彻底清除。

Flink确保了==只清除基于时间的window,其他类型的window不清除==,例如:Global window。举个例子:对于一个每5分钟创建无覆盖的窗口,允许一个1分钟的时延的窗口策略,Flink将会在12:00到12:05这段时间内第一个元素到达时创建窗口,当水印(wartmark)通过12:06时,移除这个窗口。

此外,每个window都有一个 Trigger 和一个Function(例如:ProcessWindowFunction,ReduceFunction,AggregateFunction和FoldFunction)。Function包含了应用于窗口内容的计算,Trigger指定了函数何时被触发。一个触发策略可以是 "当窗口中的元素个数超过4个时" 或者 "当水印达到窗口的边界时"。触发器还可以决定在窗口创建和删除之间的任意时刻,清除窗口的内容。清除仅指清除window内的元素而不是window的元数据,新的数据还是可以被添加到当前的window中。

除了上面的提到之外,还可以指定一个 Evictor,Evictor可以在触发器触发之后和在函数被应用之前或者之后,清除窗口中的元素。

分组和非分组Windows(Keyed vs Non-Keyed Windows)

首先,第一件事是==指定stream是分组的还是未分组的,这个必须在定义window之前定义好==。使用keyBy(...)会将stream拆分成逻辑分组的数据流,如果keyBy(...)函数不被调用的话,stream将不是分组的。

在分组stream中,任何正在传入的事件的属性都可以被当做 Specifying Keys分组stream将通过多任务并发执行window计算,每一个逻辑分组stream在执行中是独立地进行的。

在非分组stream中,原始stream不会拆分成多个逻辑stream并且所有的window逻辑将在一个任务中执行,并发度为1。

窗口分配器(Window Assingers)

指定完你的数据流是分组的还是非分组的之后,接下来需要定义一个窗口分配器(WindowAssigner)。窗口分配定义了元素如何分配到窗口中,这是通过调用window(...)或者windowAll(...)时,选择的窗口分配器(WindowAssigner)来指定的。

WindowAssigner是==负责将每一个到来的元素分配给一个或者多个窗口==,Flink提供了一些常用的预定义窗口分配器,即:滚动窗口(tumbling windows)、滑动窗口(sliding windows)、会话窗口(session windows)和全局窗口(globalwindows),也可以通过继承WindowAssigner类来自定义自己的窗口。除了全局窗口分配器,其他所有的内置窗口分配器都是通过时间来分配元素到窗口中的,这个时间要么是event time,要么是processing time。

了解更多processing time和event time的区别及时间戳(timestamp)和水印(watermark)是如何产生的,查看 event time

滚动窗口(Tumbling Windows)

滚动窗口分配器将每个元素分配的一个指定窗口大小的窗口中,==滚动窗口有一个固定的大小,并且不会出现重叠==。例如:指定了一个5分钟大小的滚动窗口,当前窗口将被评估并将按下图说明每5分钟创建一个新的窗口。

Tumbling Windows
val input: DataStream[T] = ...

// 滚动event-time窗口
input
    .keyBy(<key selector>)
    .window(TumblingEventTimeWindows.of(Time.seconds(5)))
    .<windowed transformation>(<window function>)

// 滚动processing-time窗口
input
    .keyBy(<key selector>)
    .window(TumblingProcessingTimeWindows.of(Time.seconds(5)))
    .<windowed transformation>(<window function>)

// 每日偏移8小时的滚动event-time窗口
input
    .keyBy(<key selector>)
    .window(TumblingEventTimeWindows.of(Time.days(1), Time.hours(-8)))
    .<windowed transformation>(<window function>)

时间间隔可以通过Time.milliseconds(x)Time.seconds(x)Time.minutes(x)等其中的一个来指定。

在上面的最后一个例子中,滚动窗口分配器接受了一个可选的偏移参数,可以用来改变窗口的排列。例如:没有偏移的情况,按小时的滚动窗口将按整点时间对齐,会得到一系列窗口如: 1:00:00 ~ 1:59:59、 2:00:00 ~ 2:59:59 等。如果指定了一个15分钟的偏移,将得到的窗口如下: 1:15:00 ~ 2:14:59、 2:15:00 ~ 3:14:59 等。
时间偏移一个很大的用处是用来调准非0时区的窗口,例如:在中国你需要指定一个8小时的时间偏移。

滑动窗口(Sliding Windows)

滑动窗口分配器将元素分配到固定长度的窗口中,与滚动窗口类似,窗口的大小由窗口大小参数来配置,另一个==窗口滑动参数控制滑动窗口开始的频率==。因此,滑动窗口如果滑动参数小于滚动参数的话,窗口是可以重叠的,在这种情况下元素会被分配到多个窗口中。例如:你有10分钟的窗口和5分钟的滑动,那么每个窗口中5分钟的窗口里包含着上个10分钟产生的数据。

Sliding Windows
val input: DataStream[T] = ...

// 滑动event-time窗口
input
    .keyBy(<key selector>)
    .window(SlidingEventTimeWindows.of(Time.seconds(10), Time.seconds(5)))
    .<windowed transformation>(<window function>)

// 滑动processing-time窗口
input
    .keyBy(<key selector>)
    .window(SlidingProcessingTimeWindows.of(Time.seconds(10), Time.seconds(5)))
    .<windowed transformation>(<window function>)

// 偏移8小时的滑动processing-time窗口
input
    .keyBy(<key selector>)
    .window(SlidingProcessingTimeWindows.of(Time.hours(12), Time.hours(1), Time.hours(-8)))
    .<windowed transformation>(<window function>)

除了需要指定滑动时间参数,其他与滚动窗口类似,也可以指定偏移

会话窗口(Session Windows)

会话窗口分配器==通过session活动来对元素进行分组==,会话窗口跟滚动窗口和滑动窗口相比,==不会有重叠和固定的开始时间和结束时间的情况==。相应的,当它在一个固定的时间周期内不再收到元素,即非活动间隔产生,那个这个窗口就会关闭

会话窗口可以配置一个静态session gap或定义了非活跃周期的session gap提取函数。当这个非活跃周期产生,当前的会话窗口将关闭并且后续的元素将被分配到新的会话窗口中。

Session Windows
val input: DataStream[T] = ...

// event-time Session窗口,固定的Session gap
input
    .keyBy(<key selector>)
    .window(EventTimeSessionWindows.withGap(Time.minutes(10)))
    .<windowed transformation>(<window function>)

// event-time Session窗口,动态的Session gap
input
    .keyBy(<key selector>)
    .window(EventTimeSessionWindows.withDynamicGap(new SessionWindowTimeGapExtractor[String] {
      override def extract(element: String): Long = {
        // 确定和返回session gap
      }
    }))
    .<windowed transformation>(<window function>)

// processing-time Session窗口,固定的Session gap
input
    .keyBy(<key selector>)
    .window(ProcessingTimeSessionWindows.withGap(Time.minutes(10)))
    .<windowed transformation>(<window function>)


// processing-time Session窗口,动态的Session gap
input
    .keyBy(<key selector>)
    .window(DynamicProcessingTimeSessionWindows.withDynamicGap(new SessionWindowTimeGapExtractor[String] {
      override def extract(element: String): Long = {
        // 确定和返回session gap
      }
    }))
    .<windowed transformation>(<window function>)

session windows没有一个固定的开始和结束时间。session windows操作为每一个到达的元素创建一个新的窗口,并合间隔时间小于指定时间间隔的窗口。为了进行合并,session windows的操作需要指定一个合并触发器(Trigger)和一个合并窗口函数(Window Function),如:ReduceFunction、AggregateFunction或者ProcessWindowFunction。

全局窗口(Global Windows)

全局窗口分配器==将所有具有相同key的元素分配到同一个全局窗口中==,这个窗口模式++仅适用于用户还需自定义触发器的情况++。否则,由于==全局窗口没有一个自然的结尾==,无法执行元素的聚合,将不会有计算被执行。
[图片上传失败...(image-24f35a-1534762158575)]

val input: DataStream[T] = ...

input
    .keyBy(<key selector>)
    .window(GlobalWindows.create())
    .<windowed transformation>(<window function>)

窗口函数(Window Functions)

定义完窗口分配器后,我们还需要为每一个窗口指定我们需要执行的计算,这是窗口的责任,当系统决定一个窗口已经准备好执行之后,这个窗口函数将被用来处理窗口中的每一个元素(可能是分组的)。当一个窗口准备好之后,Flink是如何决定的?

window函数可以是ReduceFunction、AggregateFunction、FoldFunction或ProcessWindowFunction中的一个。前面两个更高效一些,因为在++每个窗口中增量地对每一个到达的元素执行聚合操作++。一个ProcessWindowFunction可以获取一个窗口中的所有元素的迭代器(Iterable)以及元素所属窗口的额外元信息。

有ProcessWindowFunction的窗口化操作会比其他的操作效率要差一些,因为Flink内部在调用函数之前会将窗口中的所有元素都缓存起来。这个可以通过ProcessWindowFunction和ReduceFunction、AggregateFunction、FoldFunction结合使用来获取窗口中所有元素的增量聚合和额外的窗口元数据

ReduceFunction

ReduceFunction指定了如何==通过两个输入的参数进行合并输出一个同类型的参数==的过程,Flink使用ReduceFunction来对窗口中的元素进行增量聚合。

val input: DataStream[(String, Long)] = ...

input
    .keyBy(<key selector>)
    .window(<window assigner>)
    .reduce { (v1, v2) => (v1._1, v1._2 + v2._2) }

AggregateFunction

聚合函数是ReduceFunction的一种广义函数,具有三种类型:输入类型(in)、累加器类型(ACC)和输出类型(out)。输入类型是输入流中的元素类型,而聚合函数有一种将一个输入元素添加到累加器的方法。该接口还具有用于创建初始累加器的方法,用于将两个累加器合并为一个累加器,并从累加器中提取输出。

/**
 * 这个AverageAggregate用来持续计算sum和count,getResult方法计算平均值
 */
class AverageAggregate extends AggregateFunction[(String, Long), (Long, Long), Double] {
  // 创建初始累加器
  override def createAccumulator() = (0L, 0L)

  // 将一个输入元素添加到累加器
  override def add(value: (String, Long), accumulator: (Long, Long)) =
    (accumulator._1 + value._2, accumulator._2 + 1L)

  // 输出结果
  override def getResult(accumulator: (Long, Long)) = accumulator._1 / accumulator._2

  // 合并累加器
  override def merge(a: (Long, Long), b: (Long, Long)) =
    (a._1 + b._1, a._2 + b._2)
}

/* */
val input: DataStream[(String, Long)] = ...

input
    .keyBy(<key selector>)
    .window(<window assigner>)
    .aggregate(new AverageAggregate)

FoldFunction

1.6.0+已经过期

FoldFunction指定了一个输入元素如何与一个输出类型的元素合并的过程,这个FoldFunction会被每一个加入到窗口中的元素和当前的输出值增量地调用,第一个元素是与一个预定义的类型为输出类型的初始值合并。

val input: DataStream[(String, Long)] = ...

input
    .keyBy(<key selector>)
    .window(<window assigner>)
    // 追加所有输入的长整型到一个空的字符串中。
    .fold("") { (acc, v) => acc + v._2 }

fold()不能应用于Session window或者其他可合并的窗口中。

ProcessWindowFunction

一个ProcessWindowFunction获得一个包含了window中的所有元素的迭代器(Iterable),和一个Context对象包含访问时间和状态信息,提供了更大的灵活性。这些带来了性能的成本和资源的消耗,因为window中的元素无法进行增量迭代,而是缓存起来直到window被认为是可以处理时。

val input: DataStream[(String, Long)] = ...

input
  .keyBy(_._1)
  .timeWindow(Time.minutes(5))
  .process(new MyProcessWindowFunction())

class MyProcessWindowFunction extends ProcessWindowFunction[(String, Long), String, String, TimeWindow] {

  def process(key: String, context: Context, input: Iterable[(String, Long)], out: Collector[String]): () = {
    var count = 0L
    for (in <- input) {
      count = count + 1
    }
    out.collect(s"Window ${context.window} count: $count")
  }
}

上面的例子展示了统计一个window中元素个数,此外,还将window的信息添加到输出中。

使用ProcessWindowFunction来做简单的聚合操作,如:计数操作,性能是相当差的。将ReduceFunction跟ProcessWindowFunction结合起来,来获取增量聚合和添加到ProcessWindowFunction中的信息,性能更好。

ProcessWindowFunction with Incremental Aggregation

ProcessWindowFunction可以跟ReduceFunction、AggregateFunction或者FoldFunction结合来增量地对到达window中的元素进行聚合。当window关闭之后,ProcessWindowFunction就能提供聚合结果。当获取到WindowFunction额外的window元信息后就可以进行增量计算窗口了。

Incremental Window Aggregation with ReduceFunction

val input: DataStream[SensorReading] = ...

input
  .keyBy(<key selector>)
  .timeWindow(<duration>)
  .reduce(
    (r1: SensorReading, r2: SensorReading) => { if (r1.value > r2.value) r2 else r1 },
    ( key: String,
      window: TimeWindow,
      minReadings: Iterable[SensorReading],
      out: Collector[(Long, SensorReading)] ) =>
      {
        val min = minReadings.iterator.next()
        out.collect((window.getStart, min))
      }
  )

Incremental Window Aggregation with AggregateFunction

val input: DataStream[(String, Long)] = ...

input
  .keyBy(<key selector>)
  .timeWindow(<duration>)
  .aggregate(new AverageAggregate(), new MyProcessWindowFunction())

// Function definitions
class AverageAggregate extends AggregateFunction[(String, Long), (Long, Long), Double] {
  ...
}

class MyProcessWindowFunction extends ProcessWindowFunction[Double, (String, Double), String, TimeWindow] {

  def process(key: String, context: Context, averages: Iterable[Double], out: Collector[(String, Double]): () = {
    val average = averages.iterator.next()
    out.collect((key, average))
  }
}

Incremental Window Aggregation with FoldFunction

val input: DataStream[SensorReading] = ...

input
 .keyBy(<key selector>)
 .timeWindow(<duration>)
 .fold (
    ("", 0L, 0),
    (acc: (String, Long, Int), r: SensorReading) => { ("", 0L, acc._3 + 1) },
    ( key: String,
      window: TimeWindow,
      counts: Iterable[(String, Long, Int)],
      out: Collector[(String, Long, Int)] ) =>
      {
        val count = counts.iterator.next()
        out.collect((key, window.getEnd, count._3))
      }
  )

触发器(Triggers)

触发器决定了一个窗口何时可以被窗口函数处理,每一个窗口分配器都有一个默认的触发器,如果默认的触发器不能满足需要,你可以通过调用trigger(...)来指定一个自定义的触发器。

触发器的接口有5个方法来允许触发器处理不同的事件:

  • onElement()方法,每个元素被添加到窗口时调用
  • onEventTime()方法,当一个已注册的事件时间计时器启动时调用
  • onProcessingTime()方法,当一个已注册的处理时间计时器启动时调用
  • onMerge()方法,与状态性触发器相关,当使用会话窗口时,两个触发器对应的窗口合并时,合并两个触发器的状态。
  • clear()方法,执行任何需要清除的相应窗口

上面的方法中有两个需要注意的地方:

  1. 前三个通过返回一个TriggerResult来决定如何操作调用他们的事件,这些操作可以是下面操作中的一个:
    CONTINUE:什么也不做
    FIRE:触发计算
    PURGE:清除窗口中的数据
    FIRE_AND_PURGE:触发计算并清除窗口中的数据
  2. 这些函数可以注册 "处理时间定时器" 或者 "事件时间计时器",被用来为后续的操作使用

触发和清除(Fire and Purge)

一旦一个触发器决定一个窗口已经准备好进行处理,它将触发并返回FIRE或者FIRE_AND_PURGE。这是窗口操作==发送当前窗口结果的信号==,给定一个拥有一个ProcessWindowFunction的窗口,那么所有的元素都将发送到ProcessWindowFunction中(可能之后还会发送到驱逐器[Evitor]中)。ReduceFunction、AggregateFunction或者FoldFunction的窗口仅仅发送他们想要的聚合结果。

当一个触发器触发时,它可以是FIRE或者FIRE_AND_PURGE,如果是FIRE,将保持window中的内容,如果是FIRE_AND_PURGE,会清除window的内容。默认情况下,预实现的触发器仅仅是FIRE,不会清除window的状态。

清除操作仅清除window的内容,并留下潜在的窗口元信息和完整的触发器状态。

默认触发器(Default Triggers of WindowAssigners)

默认的触发器适用于许多种情况,例如:所有的事件时间分配器都有一个EventTimeTrigger作为默认的触发器,这个触发器仅在当水印通过窗口的最后时间时触发。

GlobalWindow默认的触发器是NeverTrigger,是永远不会触发的,因此,在使用GlobalWindow时,需要定义一个自定义触发器。

通过调用trigger(...)来指定一个触发器,你就重写了WindowAssigner的默认触发器。例如:如果你为TumblingEventTimeWindows指定了一个CountTrigger,就不会再通过时间来获取触发了,而是通过计数。现在,如果你想通过时间和计数来触发的话,你需要写自定义的触发器。

内置的和自定义的触发器(Build-in and Custom Triggers)

Flink有一些内置的触发器:

  • EventTimeTrigger,根据由水印衡量的事件时间的进度来的
  • ProcessingTimeTrigger,根据处理时间来触发
  • CountTrigger,一旦窗口中的元素个数超出了给定的限制就会触发
  • PurgingTrigger,作为另一个触发器的参数并将它转换成一个清除类型

如果想实现一个自定义的触发器,需要使用抽象类Trigger。这个API还在优化中,后续的Flink版本可能会改变。

驱逐器(Evictors)

Flink的窗口模型允许指定一个除了WindowAssigner和Trigger之外的可选参数Evitor,这个可以通过调用evitor(...)方法来实现。这个驱逐器可以在触发器触发之前或者之后,或者窗口函数被应用之前清理窗口中的元素。为了达到这个目的,Evitor接口有两个方法:

void evictBefore(Iterable<TimestampedValue<T>> elements, int size, W window, EvictorContext evictorContext);

void evictAfter(Iterable<TimestampedValue<T>> elements, int size, W window, EvictorContext evictorContext);

evitorBefore()方法包含了在window function之前应用的驱逐逻辑,而evitorAfter()方法包含了在window function之后应用的驱逐逻辑。在window function应用之前被驱逐的元素将不会再被window function处理。

Flink有三个预实现的驱逐器:

  • CountEvitor:在窗口中保持一个用户指定数量的元素,并在窗口的开始处丢弃剩余的其他元素
  • DeltaEvitor:通过一个DeltaFunction和一个阈值,计算窗口缓存中最近的一个元素和剩余的所有元素的delta值,并清除delta值大于或者等于阈值的元素
  • TimeEvitor:对于一个给定的窗口,使用一个毫秒级的interval作为参数,它会找出元素中的最大时间戳max_ts,并清除时间戳小于(max_ts - interval)的元素。

默认情况下,所有预实现的evitor都是在window function前应用它们的逻辑

指定一个Evitor要防止预聚合,因为窗口中的所有元素必须得在计算之前传递到驱逐器中

Flink 并不保证窗口中的元素是有序的,所以驱逐器可能从窗口的开始处清除,元素到达的先后不是那么必要。

允许延迟(Allowed Lateness)

当使用event-time的window时,可能会出现元素到达晚了,Flink用来与事件时间联系的水印(watermark)已经过了元素所属的窗口的最后时间。

默认情况下,当水印已经过了窗口的最后时间时,晚到的元素会被丢弃。然而,Flink允许为窗口操作指定一个最大允许时延,允许时延指定了元素可以晚到多长时间,默认情况下是0,也就是说水印之后到达的元素将被丢弃。
水印已经过了窗口最后时间后才来的元素,如果还未到窗口最后时间加时延时间,那么元素任然添加到窗口中。如果依赖触发器的使用的话,晚到但是未丢弃的元素可能会导致窗口再次被触发。

为了达到这个目的,Flink将保持窗口的状态直到允许时延的发生,一旦发生,Flink将清除Window,删除window的状态。

val input: DataStream[T] = ...

input
    .keyBy(<key selector>)
    .window(<window assigner>)
    .allowedLateness(<time>)
    .<windowed transformation>(<window function>)

当使用GlobalWindows分配器时,没有数据会被认为是延迟的,因为Global Window的最后时间是Long.MAX_VALUE。

以Side Output来获取延迟数据(Getting late data as a side output)

使用Flink的 Side Output 特性,你可以获得一个已经被丢弃的延迟数据流。

首先你需要在窗口化的数据流中调用sideOutputLateData(OutputTag)指定你需要获取延迟数据。然后,你就可以在window操作的结果中获取到Side output了。

val lateOutputTag = OutputTag[T]("late-data")

val input: DataStream[T] = ...

val result = input
    .keyBy(<key selector>)
    .window(<window assigner>)
    .allowedLateness(<time>)
    .sideOutputLateData(lateOutputTag)
    .<windowed transformation>(<window function>)

val lateStream = result.getSideOutput(lateOutputTag)

推荐阅读更多精彩内容