flink事件属于窗口的计算方法

最新推荐文章于 2024-04-26 12:22:03 发布
最新推荐文章于 2024-04-26 12:22:03 发布
阅读量1.8k 收藏
点赞数
分类专栏： Flink之路 文章标签： flink 大数据 big data
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_18218071/article/details/122045573
版权

背景

疑问1.一个窗口会不会变化？

我们都知道flink有窗口和watermark的概念，当watermark大于窗口的endTime，将触发窗口中数据的计算，watermark是一个不断递增的时间戳，是不断变化的，如果我们假设一个窗口的开始时间和结束时间也是不断变化的，那么watermark就不好触发窗口计算。所以根据我们的假设，内心也是认为一个特定的窗口的开始和结束时间肯定是固定的。

疑问2.窗口是怎么初始化的？

如果一个特定的窗口是不会变化的，比如滚动窗口，我们在代码中只需要传入窗口的size，就可以完成窗口的构建，那么窗口的开始时间和结束时间是怎么获取的。

例如我们定义一个窗口：window(TumblingProcessingTimeWindows.of(Time.seconds(10))),当我们当前事件的处理时间是2021-12-20 10:17:14，那么这个事件是属于下面窗口中的哪一个？[10:17:10, 10:17:20)，[10:17:11, 10:17:21)，[10:17:12, 10:17:22)，[10:17:14, 10:17:24)，…（共十种可能）

疑问3.如果窗口是固定的，那么第一个窗口开始时间是哪个？

我们知道如果我们设置了窗口大小，那么这些窗口都是固定不变的，也就是说这些窗口都是真实存在的，不管你用不用它，那么第一个窗口是哪一个呢？
答案就是所有类型的窗口，第一个窗口的开始时间都是1970-01-01 08:00:00

ok，我们来着上面的疑问向下走。。。

下面列出窗口的示例代码

source.map(new MyMapFunction()).setParallelism(8).keyBy(s -> s.f0)
  .window(TumblingProcessingTimeWindows.of(Time.seconds(10)))
  .process(new MyProcessWindowFunction()).setParallelism(8).print();

通过上面TumblingProcessingTimeWindows.of(Time.seconds(10))创建是一个窗口大小是10s的窗口。

public static TumblingProcessingTimeWindows of(Time size) {
  return new TumblingProcessingTimeWindows(size.toMilliseconds(), 0, WindowStagger.ALIGNED);
}

也就完成了窗口中三个变量的初始化：

private TumblingProcessingTimeWindows(long size, long offset, WindowStagger windowStagger) {
  if (Math.abs(offset) >= size) {
    throw new IllegalArgumentException(
      "TumblingProcessingTimeWindows parameters must satisfy abs(offset) < size");
  }

  this.size = size;
  this.globalOffset = offset;
  this.windowStagger = windowStagger;
}

可以看到窗口中的size=10000(10秒), globalOffset=0, windowStagger=WindowStagger.ALIGNED(所有窗口都是从0开始)

现在看下TumblingProcessingTimeWindows分配窗口的功能：assignWindows

@Override
public Collection<TimeWindow> assignWindows(
  Object element, long timestamp, WindowAssignerContext context) {
  final long now = context.getCurrentProcessingTime();
  if (staggerOffset == null) {
    staggerOffset =
      windowStagger.getStaggerOffset(context.getCurrentProcessingTime(), size);
  }
  long start =
    TimeWindow.getWindowStartWithOffset(
    now, (globalOffset + staggerOffset) % size, size);
  return Collections.singletonList(new TimeWindow(start, start + size));
}

有三个参数element用户发送数据流数据，timestamp该数据流的时间戳，context窗口分配向下文信息，该方法在WindowOperator被调用。该类是处理事件的窗口类，所以该类不是不会使用timestamp该数据流的时间戳。由于windowStagger.getStaggerOffset(context.getCurrentProcessingTime(), size);返回0，所以staggerOffset就是0。

下面就是重点了，就是获取一个窗口的开始时间，获取开始时间后+窗口大小就是结束时间。

通过以上可知TimeWindow.getWindowStartWithOffset(now, (globalOffset + staggerOffset) % size, size);,第二个参数就是0，now是当前时间戳，size是窗口大小。

public static long getWindowStartWithOffset(long timestamp, long offset, long windowSize) {
  return timestamp - (timestamp - offset + windowSize) % windowSize;
}

上面的公式可以简化为timestamp - timestamp % windowSize;

也即是当前时间戳-时间戳在窗口多余的时间，肯定是窗口开始时间。

下面具体例子：2021-12-20 10:17:14 通过 2021-12-20 10:17:14 - 4秒，所以该数据落在[10:17:10-10:17:20)的窗口，同样在10:17:10-10:17:19产生的数据都会落在该窗口中。

所以实际上是不存在这些窗口的[10:17:11, 10:17:21)，[10:17:12, 10:17:22)，[10:17:14, 10:17:24)…

总结：窗口在定义时候，可以说窗口固化了窗口.
因为我们看到通过上面算法，每个时间都会落到特定的窗口。
后面会验证第一个窗口的开始时间是1970-01-01 08:00:00

再举一个例子：窗口大小改为8秒。

下面是一分钟内，各个处理时间对一个的窗口

id处理时间窗口对应的开始时间
02021-12-20 16:57:132021-12-20 16:57:12
12021-12-20 16:57:142021-12-20 16:57:12
22021-12-20 16:57:152021-12-20 16:57:12
32021-12-20 16:57:162021-12-20 16:57:12
42021-12-20 16:57:172021-12-20 16:57:12
52021-12-20 16:57:182021-12-20 16:57:12
62021-12-20 16:57:192021-12-20 16:57:12
72021-12-20 16:57:202021-12-20 16:57:20
82021-12-20 16:57:212021-12-20 16:57:20
92021-12-20 16:57:222021-12-20 16:57:20
102021-12-20 16:57:232021-12-20 16:57:20
112021-12-20 16:57:242021-12-20 16:57:20
122021-12-20 16:57:252021-12-20 16:57:20
132021-12-20 16:57:262021-12-20 16:57:20
142021-12-20 16:57:272021-12-20 16:57:20
152021-12-20 16:57:282021-12-20 16:57:28
162021-12-20 16:57:292021-12-20 16:57:28
172021-12-20 16:57:302021-12-20 16:57:28
182021-12-20 16:57:312021-12-20 16:57:28
192021-12-20 16:57:322021-12-20 16:57:28
202021-12-20 16:57:332021-12-20 16:57:28
212021-12-20 16:57:342021-12-20 16:57:28
222021-12-20 16:57:352021-12-20 16:57:28
232021-12-20 16:57:362021-12-20 16:57:36
242021-12-20 16:57:372021-12-20 16:57:36
252021-12-20 16:57:382021-12-20 16:57:36
262021-12-20 16:57:392021-12-20 16:57:36
272021-12-20 16:57:402021-12-20 16:57:36
282021-12-20 16:57:412021-12-20 16:57:36
292021-12-20 16:57:422021-12-20 16:57:36
302021-12-20 16:57:432021-12-20 16:57:36
312021-12-20 16:57:442021-12-20 16:57:44
322021-12-20 16:57:452021-12-20 16:57:44
332021-12-20 16:57:462021-12-20 16:57:44
342021-12-20 16:57:472021-12-20 16:57:44
352021-12-20 16:57:482021-12-20 16:57:44
362021-12-20 16:57:492021-12-20 16:57:44
372021-12-20 16:57:502021-12-20 16:57:44
382021-12-20 16:57:512021-12-20 16:57:44
392021-12-20 16:57:522021-12-20 16:57:52
402021-12-20 16:57:532021-12-20 16:57:52
412021-12-20 16:57:542021-12-20 16:57:52
422021-12-20 16:57:552021-12-20 16:57:52
432021-12-20 16:57:562021-12-20 16:57:52
442021-12-20 16:57:572021-12-20 16:57:52
452021-12-20 16:57:582021-12-20 16:57:52
462021-12-20 16:57:592021-12-20 16:57:52
472021-12-20 16:58:002021-12-20 16:58:00
482021-12-20 16:58:012021-12-20 16:58:00
492021-12-20 16:58:022021-12-20 16:58:00
502021-12-20 16:58:032021-12-20 16:58:00
512021-12-20 16:58:042021-12-20 16:58:00
522021-12-20 16:58:052021-12-20 16:58:00
532021-12-20 16:58:062021-12-20 16:58:00
542021-12-20 16:58:072021-12-20 16:58:00
552021-12-20 16:58:082021-12-20 16:58:08
562021-12-20 16:58:092021-12-20 16:58:08
572021-12-20 16:58:102021-12-20 16:58:08
582021-12-20 16:58:112021-12-20 16:58:08
592021-12-20 16:58:122021-12-20 16:58:08

用上面的时间验证第一个窗口的开始时间。例如上面第一个时间是2021-12-20 16:57:13那么也就是1639990633000，所以(1639990633000-0)/8000=204998829 (取整），然后204998829 * 8000 = 1639990632000 也就是2021-12-20 16:57:12就是这个窗口的开始时间。
ok 上面0就是1970-01-01 08:00:00

我们WindowOperator就是封窗用户WindowFunction处理功能的类,下面贴下代码

@Override
public void processElement(StreamRecord<IN> element) throws Exception {
 final Collection<W> elementWindows =
   windowAssigner.assignWindows(
   element.getValue(), element.getTimestamp(), windowAssignerContext);
 	...
}

对于事件时间也是一样处理，只是不是使用当前时间计算所属的窗口，而是使用事件时间

@Override
public Collection<TimeWindow> assignWindows(
  Object element, long timestamp, WindowAssignerContext context) {
  if (timestamp > Long.MIN_VALUE) {
    if (staggerOffset == null) {
      staggerOffset =
        windowStagger.getStaggerOffset(context.getCurrentProcessingTime(), size);
    }
    // Long.MIN_VALUE is currently assigned when no timestamp is present
    long start =
      TimeWindow.getWindowStartWithOffset(
      timestamp, (globalOffset + staggerOffset) % size, size);
    return Collections.singletonList(new TimeWindow(start, start + size));
  } else {
    throw new RuntimeException(
      "Record has Long.MIN_VALUE timestamp (= no timestamp marker). "
      + "Is the time characteristic set to 'ProcessingTime', or did you forget to call "
      + "'DataStream.assignTimestampsAndWatermarks(...)'?");
  }
}
陪你一起捡蛋壳
关注
专栏目录
Flink时间和窗口
L
07-24 1261
如图所示，由事件生成器（Event Producer）生成事件，生成的事件数据被收集起来，首先进入分布式消息队列（Message Queue），然后被 Flink 系统中的 Source 算子（Data Source）读取消费，进而向下游的窗口算子（Window Operator）传递，最终由窗口算子进行计算处理。​ 有两个非常重要的时间点：（1）一个是数据产生的时刻，我们把它叫作“事件时间”（Event Time）；
大数据Flink（一百一十七）：Flink SQL的窗口操作
最新发布
Lansonli（蓝深李）的博客
09-12 1341
在流处理应用中，数据是连续不断的，因此我们不可能等到所有数据都到了才开始处理。当然我们可以每来一个消息就处理一次，但是有时我们需要做一些聚合类的处理，例如：在过去的1分钟内有多少用户点击了我们的网页。在这种情况下，我们必须定义一个窗口，用来收集最近一分钟内的数据，并对这个窗口内的数据进行计算。Flink 认为 Batch 是 Streaming 的一个特例，所以 Flink 底层引擎是一个流式引擎，在上面实现了流处理和批处理。而窗口（window）就是从 Streaming 到 Batch 的一个桥梁。
Flink 窗口计算
water drop的博客
03-15 810
Flink 窗口计算 一、概述 窗⼝计算是流计算的核⼼，窗⼝将流数据切分成有限⼤⼩的“buckets”，我们可以对这个“buckets”中的有限数据做运算。 在Flink中整体将窗⼝计算按分为两⼤类：keyedstream窗⼝、datastream窗⼝,以下是代码结构： keyedStream stream .keyBy(…) <--------------- k...
Flink（十）窗口计算
又小雨的博客
08-18 2431
一、简介 窗口计算：flink的灵魂 窗口计算就是把无界数据流切分为有限大小的“bucket”—>窗口（bucket/window/panel），在窗口上应用计算换上完成计算处理 核心：窗口的划分和计算 我们经常需要在一个时间窗口维度上对数据进行聚合，窗口是流处理应用中经常需要解决的问题。Flink的窗口算子为我们提供了方便易用的API，我们可以将数据流切分成一个个窗口，对窗口内的数据进行处理。 大致程序结构： 按照有没有进行keyby分成了两种 不同的处理方式 首先，我们要决定是否对一个DataS
Flink核心技术与实战（2）- 窗口计算（1）
一角残叶的博客
02-24 2309
1 窗口计算 1.1 window抽象概念 1.2 Window Assigner Flink支持的窗口类型 1.3 预置的 Keyed Windows 1.4 触发器 一次触发
Flink窗口计算
weixin_53209289的博客
07-27 288
DataStream result = input .keyBy(0) // 根据键值进行分组 .timeWindow(Time.minutes(1)) // 定义1分钟的时间窗口 .sum(1);首先根据键值进行分组（keyBy），然后定义一个1分钟的时间窗口（timeWindow），最后对窗口内的数据进行求和（sum）。注意，Flink还支持更复杂的窗口计算，如会话窗口（Session Windows）和全局窗口（Global Windows）。
【Flink】各种窗口的使用（处理时间窗口、事件时间窗口、窗口聚合窗口）
weixin_43923463的博客
11-27 3795
streaming流式计算是一种被设计用于处理无限数据集的数据处理引擎，而无限数据集是指一种不断增长的本质上无限的数据集，而window是一种切割无限数据为有限块进行处理的手段。Window是无限数据流处理的核心，Window将一个无限的stream拆分成有限大小的”buckets”桶，我们可以在这些桶上做计算操作。ProcessFunction：不分流直接聚合，不可以使用定时器和状态变量，因为其没有经过keyBy，定时器和状态变量都是针对key的，只有processElement。
Flink窗口
qq_38016945的博客
09-04 1134
除了由时间驱动之外， 窗口其实也可以由数据驱动，也就是说按照固定的数量，来截取一段数据集，这种窗口叫作“计数窗口”（Count Window），如图。这很好理解，“会话”终止的标志就是“隔一段时间没有数据来”，如果不依赖时间而改成个数，就成了“隔几个数据没有数据来”，这完全是自相矛盾的说法。滑动的距离代表了下个窗口开始的时间间隔，而窗口大小是固定的，所 以也就是两个窗口结束时间的间隔；在这种情况下，我们 就可以定义一个窗口，收集最近一分钟内的所有用户点击数据，然后进行聚合统计，最终输出 一个结果就可以了。
【深入浅出flink】第10篇：聊聊flink窗口计算的触发器（Trigger）
雷恩Layne
01-17 7205
Trigger（触发器）决定了什么时候窗口准备就绪了，一旦窗口准备就绪就可以使用WindowFunction（窗口计算操作）进行计算。每一个 WindowAssigner（窗口分配器） 都会有一个默认的Trigger。如果默认的Trigger不满足用户的需求，用户可以自定义Trigger。
Flink: 窗口计算
McGrady_Durant的博客
08-19 573
文章目录Event-time WindowEvent TimeWatermark-水位线迟到数据 Event-time Window Event Time Flink在流计算的过程中，支持多种时间概念。Event Time / Processing Time / Ingestion Time Processing Time：处理时间是指执行相应操作的机器的系统时间。 Event Time：事件时间是每个事件在其生产设备上发生的时间。处理乱序数据（数据的处理和数据的生成顺序乱啦） Ingestion：摄取
基础篇（三）：Flink window窗口计算
firefish009的博客
02-17 750
一、基本概念理解 1、窗口： 是将无限的数据流根据时间语义维度切割成一个有限大小的桶，然后对这个桶内的数据进行计算 2、窗口分类： 滚动窗口 tumbling window 描述：按照固定的时间长度对数据流切分，且窗口之间不会出现重叠 滑动窗口 sliding window 描述：由固定的窗口长度和滑动间隔组成，窗口之间有重叠，通常滑动间隔要小于窗口长度 会话窗口 session window 描述：在一定的时间长度timeout没有接收到数据，则生成一个新的窗口 全局窗口 g
Flink窗口计算（二）
m0_37651941的博客
11-19 982
Window Trigger 如果想让窗口每隔两分钟就触发一次结果输出呢？ PuringTrigger会对窗口里面的状态做一次清理 在第二次输出12：00 -12：05窗口结果的时候是3而不是6，这样可以保障下游的算子接收到的上游处理完成的结果后可以做累加产生正确的结果。 ...
Flink的窗口计算（章节四）
origin_cx的博客
03-13 1402
Flink的窗口计算（章节四） windows 介绍 窗⼝计算是流计算的核⼼，窗⼝将流数据切分成有限⼤⼩的“buckets”，我们可以对这个“buckets”中的有限数据做运算。 在Flink中整体将窗⼝计算按分为两⼤类：keyedstream窗⼝、datastream窗⼝,以下是代码结构： Keyed Windows stream .keyBy(...) <- keyed versus ...
Flink的窗口计算案例
ZH519080的博客
04-15 3239
Flink的关于窗口算子的一般应用
10分钟了解Flink窗口计算
程序员半支烟，wechat：yclxiao
04-26 509
本文主要讲了窗口的时间概念、窗口分配、窗口函数的使用，以及触发器、清除器的使用。
（十）Flink Datastream API 编程指南 算子-2 Windows窗口计算
京河小蚁的博客
06-05 663
窗口是处理无限流的核心。Windows将流分成有限大小的“桶”，我们可以在桶上应用计算。本文主要讨论如何在Flink中执行窗口操作，以及程序员如何最大限度地利用Flink提供的功能。一个带窗口的Flink程序的总体结构如下所示。第一个片段引用键控流，第二个片段引用非键控流。可以看到，唯一的区别是键控流的keyBy(…)调用和非键控流的window(…)调用，后者变成windowall(…)。这也将作为页面其余部分的路线图。Keyed Windows Non-Keyed Windows 上面的方括号([…])
《Flink应用实战》(二)--窗口函数聚合计算
一锅粥
05-23 2411
窗口计算是流式计算中常用的数据计算方式之一，通过按照固定时间或长度将数据流切分成不同的窗口，再对数据进行相应的聚合操作，得到一定时间范围内的统计结果，例如统计最近5分钟内某网站的点击数，此时，点击数据在不断产生，通过5分钟窗口将数据限定在固定时间范围内，就可以对该范围内的有界数据执行聚合，得到最近5分钟的网站点击数。 2、窗口计算函数分类 • Flink提供了四种类型的窗口计算函数，分别是ReduceFunction、AggregateFunction、Fol...
Flink Table API与SQL时间窗口详解
时间窗口是Flink中进行实时计算的核心概念，它允许用户按照时间间隔对数据进行分组和聚合，以便于分析和处理连续的数据流。 GroupWindows是Flink Table API和SQL中的一种窗口类型，它将数据按照时间或行数间隔聚合...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值