分类
devops

Tumbling and Sliding

滚动窗口 vs 滑动窗口:流处理窗口类型的深度对比

在实时计算、指标监控、日志分析这类场景里,几乎每一个需求最终都会落到同一个问题上:“我要按时间把数据切段统计”。

而”怎么切”这件事,恰恰是最容易出错的地方。同样是”统计最近 5 分钟的数据”,有人用滚动窗口,有人用滑动窗口,两边的数字能差好几倍——而且两边看起来都”跑通了”。

本文从窗口的本质讲起,把滚动窗口(Tumbling)与滑动窗口(Sliding)的语义差异彻底说清楚,再横向对比 Flink、Kafka Streams、Spark、Beam 四大框架的 API 实现与工程取舍。


一、 先把”窗口”这件事说清楚

1.1 窗口解决的问题

一条流是无限的:每秒钟都有新事件到达。要在这条无限流上做”计数、求和、排名”这类有意义的统计,就必须先给流”切段”——这就是窗口。

窗口本质上是一个时间区间 [start, end),外加一条归属规则:每条数据根据自己的时间戳,被划入某一个(或某几个)窗口。

区间一律是左闭右开 [start, end)。这一点在所有主流框架里都一致;但恰恰因为 [0:00,1:00) 和 [1:00,2:00) 不重叠,手写判定时很容易写成 [start, end] 而把边界数据算两次。

1.2 描述一个窗口的三个要素

任何窗口最终都可以被三个参数完全刻画:

要素 符号 含义 典型取值
窗口大小 W (size) 每个窗口覆盖的时间跨度 1 分钟、1 小时
滑动步长 S (advance / slide / hop) 相邻窗口起点之间的间隔 1 分钟、5 分钟
时间语义 T 用事件时间还是处理时间打点 event time / processing time

其中 W 与 S 的关系,决定了窗口属于哪一类——这正是本文的核心。

1.3 没有窗口的”流式聚合”是什么

值得先澄清一个常见误解:流式聚合不一定需要窗口。

像”当前在线人数””累计订单金额”这类指标,聚合状态是从流开始一直累积的,不做任何切分,输出的是”截至此刻的累计值”。但这类指标有两个致命问题:

  1. 无法回溯:你没法回答”昨天下午 3 点到 4 点有多少订单”——状态里根本没有那段历史。
  2. 无法对齐:指标值随事件流不断抖动,做不了同比环比,也没法和离线数仓对账。

窗口正是为解决这两点而生的:把无限流切成有限个、可寻址、可回溯、互不干扰的时间段。


二、 两类窗口的语义对比(核心)

2.1 滚动窗口(Tumbling Window):整点报时

想象收音机里的整点报时:”现在是北京时间 10 点整”——10:00 到 11:00 报一次,11:00 到 12:00 报一次。每个格子挨着上一个,但绝不重叠。

把时间轴切成固定大小、互不重叠、连续不断的格子:

  时间轴            0            1            2            3            4
  ┬───────────┬───────────┬───────────┬───────────┬───────────┬──►
  │           │           │           │           │           │
     窗口 1        窗口 2        窗口 3        窗口 4
   0:00-1:00   1:00-2:00   2:00-3:00   3:00-4:00

关键性质:

  • 窗口长度固定(这里是 1 分钟)
  • 相邻窗口首尾相接,完整覆盖时间轴,没有空洞
  • 一条数据只属于一个窗口(Spark 官方文档的原话:“An input can only be bound to a single window.”)
  • 相邻窗口的输出可以直接相加,等于全量

典型场景: 每分钟的订单数、每分钟的 PV/UV;1 分钟或 5 分钟 K 线;按天/按小时的分桶统计;日志按分钟聚合的错误数。

2.2 滑动窗口(Sliding Window / Hopping Window):最近 1 小时

想象车里的”最近 1 小时平均油耗”:这个 1 小时的窗口,每过 1 分钟就往前滚 1 分钟。相邻两个窗口有 59 分钟是重叠的。

窗口长度固定,但起点持续前移,于是窗口之间互相重叠:

  时间轴            0            1            2            3            4            5
  ┬───────────┬───────────┬───────────┬───────────┬───────────┬───────────┬──►
  │▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓   ← 窗口 1  [0:00, 3:00)
  │            ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓   ← 窗口 2  [1:00, 4:00)
  │                        ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓   ← 窗口 3  [2:00, 5:00)

(上例:窗口大小 W = 3 分钟,滑动步长 S = 1 分钟)

关键性质:

  • 窗口长度固定(这里是 3 分钟)
  • 窗口起点每次前进 S(这里是 1 分钟)
  • 一条数据最多属于 ⌈W/S⌉ 个窗口(上例中为 3 个)
  • 相邻窗口的输出不能直接相加——会重复统计

典型场景:“最近 60 秒”的 CPU 使用率曲线;”最近 5 分钟”的平均延迟;监控大盘的滚动趋势线;任何需要”持续观察最近 N 分钟”的场景。

2.3 统一模型:只用一个参数关系区分

把两类窗口放进同一个模型,立刻就清楚了:

步长 S 与窗口大小 W 的关系 窗口类型 重叠度 一条数据的归属
S W 滚动窗口 Tumbling 无重叠 恰好 1 个窗口
S < W 滑动窗口 Sliding / Hopping 重叠 W – S ⌈W/S⌉ 个窗口
S > W 空洞窗口(Kafka UnlimitedWindows 除外,几乎无人使用) 有空隙 0 或 1 个窗口

判断标准只有一个:相邻窗口重不重叠。

  • 不重叠 → 滚动窗口(如 1 分钟 K 线、每分钟订单数)
  • 有重叠 → 滑动窗口(如「最近 60 秒」的 CPU 曲线、最近 5 分钟平均值)

换个参数化的说法:滑动步长就是 W 的”取样间隔”。W = 60 秒时:

步长 S 效果
60 秒 每分钟一个点,相邻点完全不重叠 —— 滚动窗口
10 秒 每 10 秒一个点,相邻点共享 50 秒数据
1 秒 每秒一个点,相邻点共享 59 秒数据

滑动窗口本质上就是在滚动窗口的基础上做降采样——它牺牲了”互不重复”的性质,换取了更平滑、更及时的曲线。

2.4 重叠的直接后果:同一条数据被统计多次

这是滑动窗口最容易被忽略、也最容易造成线上数据对不上的地方。

上图中 W = 3 分钟、S = 1 分钟时,一条发生在 2:30 的数据,会同时进入 [0:00,3:00)、[1:00,4:00)、[2:00,5:00) 三个窗口。它在 3 个窗口里各被统计了一次。

所以:

滚动窗口:   总订单数 = Σ(所有窗口的订单数)        ✅ 可以直接相加
滑动窗口:   总订单数 ≠ Σ(所有窗口的订单数)       ❌ 每条数据被重复计入

实务中的三个连锁反应:

  1. 报表口径对不上:下游把滑动窗口的结果加总,得到的是真实值的 W/S 倍。
  2. 下游必须去重:若下游要精确总量,得自己按 (key, 数据 id) 去重——而流式去重需要额外状态,代价不小。
  3. 存储放大:滑动窗口的输出条数是滚动窗口的 W/S 倍,Kafka topic 的写入量、ClickHouse 的写入量都跟着涨。

💡 经验法则:滑动窗口的输出应当被当作”采样点”来消费(画曲线、算最大值、触发告警),而不是当作”可累加的分片”。如果需要对账,先把窗口切成滚动的。

2.5 状态开销的放大

滑动窗口还有第二个隐藏成本:需要同时维护多个窗口的聚合状态。

假设 W = 10 分钟、S = 1 分钟:

  • 滚动窗口:每个 key 同时只保留 1 份聚合状态
  • 滑动窗口:每个 key 同时要保留 10 份聚合状态(覆盖过去 10 个窗口起点)

在 Flink 里这意味着 RocksDB StateBackend 的 state 体积、checkpoint 时长、故障恢复时间都会成倍上升。窗口越小、步长越密、key 基数越大,状态膨胀越明显。


三、 另外两类窗口:会话窗口与累积窗口

除了滚动和滑动,主流框架还普遍支持另外两种窗口类型。看懂它们,整张地图就完整了。

3.1 会话窗口(Session Window):按”活跃间隔”切分

会话窗口没有固定长度,边界由不活跃间隔(inactivity gap)决定:

想象”用户会话”:只要用户每隔不到 30 分钟就有一次点击,就算同一个会话;一旦沉默了超过 30 分钟,会话结束,下一次点击开启新会话。

10:00  ●━━ 10:12  ●━━━━━━━━━━ 10:25  ●        ← 会话 1(相邻间隔 < 30min,持续合并)
                 10:58  ●━━━ 11:20  ●          ← 会话 2(10:25 与 10:58 间隔 > 30min,分裂)

特点:

  • 窗口边界由数据”自己长出来”,不是预先切好的格子
  • 同一时刻不同 key 的会话互不干扰(不会因为 A 的活跃而延长 B 的会话)
  • 窗口长度事先未知,但在有界流上有上界
  • 只能基于事件时间——处理时间没有意义,因为要靠事件时间戳判断间隔

典型场景: 用户会话分析、在线状态计算、连续操作序列识别。

3.2 累积窗口(Cumulative Window / Landmark Window):”从起点到当前”

累积窗口是一种特殊形态:起点固定在某个锚点,终点随着时间推移不断向右延伸,输出的永远是”从锚点到当前时刻”的累计值。

Flink SQL 的 CUMULATE 会输出一串逐渐变长的窗口:

  时间轴          0          2          4          6          8         10   (分钟)
  ┬─────────┬─────────┬─────────┬─────────┬─────────┬──►
  ├─────────┤                                           [0, 2)
  ├───────────────────┤                                 [0, 4)
  ├─────────────────────────────┤                       [0, 6)
  ├───────────────────────────────────────┤             [0, 8)
  ├─────────────────────────────────────────────────┤   [0, 10)
-- Flink SQL:第三个参数是步长(step),第四个是总长度(size)
SELECT window_start, window_end, SUM(price) AS total_price
FROM TABLE(
  CUMULATE(TABLE Bid, DESCRIPTOR(bidtime), INTERVAL '2' MINUTES, INTERVAL '10' MINUTES)
)
GROUP BY window_start, window_end;

Kafka Streams 有一个语义相近的 UnlimitedWindows,官方称为 landmark window,Javadoc 原文:“It has a fixed starting point while its window end is defined as infinite.” 与 CUMULATE 的区别在于它终点是无穷的。

Spark 和 Beam 没有原生的累积窗口。

⚠️ 注意 CUMULATE 的参数顺序是步长在前、长度在后,与 Flink DataStream API 相反(见 5.7)。


四、 时间语义:事件时间、处理时间与水位线

窗口的”格子”按什么时间划,直接决定了结果对不对。

4.1 两种时钟

时间语义 定义 优点 缺点
处理时间 Processing Time 数据到达引擎的时刻 简单、延迟低、窗口能立即关闭 结果依赖到达顺序,重放同一份数据会得到不同结果,无法与离线对账
事件时间 Event Time 事件自身携带的业务时间戳 结果确定、可重放、符合业务语义 需要处理乱序,必须引入水位线

4.2 乱序与水位线

现实中的数据流几乎总是乱序的:网络抖动、多个上游分区、GC 停顿,都会让事件乱序到达。水位线(watermark) 是流处理引擎用来表达”我判断时间戳不大于 W 的数据都已经到了”的进度标记。

引擎维护的通常是两种水位线:

  • 事件时间水位线:由所有输入分区取最小值推进,因此会被最慢的分区拖住
  • 处理时间水位线:由机器时钟推进

关键在于:窗口不会在”时间到了”时立即输出,而是要等水位线越过窗口右边界。这中间的时间差,就是”允许迟到(allowed lateness)”的额度。

4.3 迟到数据的三种命运

策略 行为 典型配置
丢弃 超出水位线的迟到数据直接扔掉 Spark 默认(未开启状态保留时)
修正重发 允许迟到数据更新已输出的窗口,并再次发出修正结果 Flink allowedLateness + 触发器
旁路输出 迟到数据不参与主流程,流到侧输出流单独处理 Flink sideOutputLateData

Flink 的完整配置链路(下例中 .trigger(...) 与 .evictor(...) 为占位写法,实际要传入 Trigger 与 Evictor 实例):

input
    .keyBy(Event::userId)
    .window(TumblingEventTimeWindows.of(Duration.ofMinutes(1)))
    .trigger(...)                          // 可选:控制何时触发
    .evictor(...)                          // 可选:窗口关闭前剔除旧数据
    .allowedLateness(Duration.ofMinutes(5)) // 允许迟到 5 分钟内做修正
    .sideOutputLateData(lateTag)           // 超过 5 分钟的迟到数据走侧输出
    .aggregate(new CountAgg(), new WindowResult())
    .getSideOutput(lateTag);               // 消费侧输出

⚠️ 注意 Flink 2.x 的变化:窗口 API 的时间类型从 org.apache.flink.streaming.api.windowing.time.Time 换成了 JDK 的 java.time.Duration。从 1.x 迁移时,Time.minutes(1) 要改成 Duration.ofMinutes(1)。


五、 四大框架的 API 对照

5.1 总览

能力 Flink Kafka Streams Spark Structured Streaming Apache Beam
滚动窗口 TumblingEventTimeWindows.of(size) TimeWindows.ofSizeWithNoGrace(size) window(ts, size) FixedWindows.of(size)
滑动窗口 SlidingEventTimeWindows.of(size, slide) TimeWindows.ofSizeWithNoGrace(size).advanceBy(slide) window(ts, size, slide) SlidingWindows.of(size).every(slide)
会话窗口 EventTimeSessionWindows.withGap(gap) SessionWindows.ofInactivityGapWithNoGrace(gap) session_window(ts, gap) Sessions.withGapDuration(gap)
累积窗口 SQL CUMULATE UnlimitedWindows(landmark) 无原生 无原生
事件时间 *EventTimeWindows TimestampExtractor withWatermark() EventTime
时长类型 java.time.Duration java.time.Duration 字符串,如 "10 minutes" org.joda.time.Duration
迟到数据 allowedLateness + sideOutputLateData grace period watermark 阈值 AccumulationMode
窗口对齐 默认 epoch,可传 offset 固定对齐 epoch 按 interval 对齐 可 withOffset

5.2 Flink DataStream API

// 滚动窗口:1 分钟一个格子,互不重叠
input.keyBy(Event::userId)
     .window(TumblingEventTimeWindows.of(Duration.ofMinutes(1)))
     .aggregate(new CountAgg(), new WindowResult());

// 滑动窗口:10 分钟窗口,每 1 分钟往前挪一格
//          → 同一条数据最多落进 10 个窗口
input.keyBy(Event::userId)
     .window(SlidingEventTimeWindows.of(Duration.ofMinutes(10), Duration.ofMinutes(1)))
     .aggregate(new CountAgg(), new WindowResult());

// 带偏移的滚动窗口:按 UTC-8 的自然日切分,而不是按 UTC 日切
TumblingEventTimeWindows.of(Duration.ofDays(1), Duration.ofHours(-8));

// 会话窗口:不活跃间隔 10 分钟
input.keyBy(Event::userId)
     .window(EventTimeSessionWindows.withGap(Duration.ofMinutes(10)))
     .aggregate(new CountAgg(), new WindowResult());

Flink DataStream 里,事件时间版本(*EventTimeWindows)和处理时间版本(*ProcessingTimeWindows)是两套完全独立的类,名字不同、方法不同。选错不会报错,只会让结果悄悄地对不上。

5.3 Flink SQL

-- 滚动窗口
SELECT window_start, window_end, SUM(price) AS total_price
FROM TABLE(TUMBLE(TABLE Bid, DESCRIPTOR(bidtime), INTERVAL '10' MINUTES))
GROUP BY window_start, window_end;

-- 滑动窗口:⚠️ 参数顺序是「步长在前、长度在后」
SELECT window_start, window_end, SUM(price) AS total_price
FROM TABLE(HOP(TABLE Bid, DESCRIPTOR(bidtime), INTERVAL '1' MINUTE, INTERVAL '10' MINUTES))
GROUP BY window_start, window_end;

-- 会话窗口
SELECT window_start, window_end, SUM(price) AS total_price
FROM TABLE(SESSION(TABLE Bid, DESCRIPTOR(bidtime), INTERVAL '30' MINUTES))
GROUP BY window_start, window_end;

Flink 官方文档对 HOP 的原话是:“A hopping time window has a fixed duration (second interval parameter) and hops by a specified hop interval (first interval parameter).” ——即 HOP(ts, hop, size),步长在前。

而 HOP 在 Flink 官方术语里叫 hopping window,文档括号里注明 “called sliding window in the Table API”——同一个东西,在 DataStream API 里叫 Sliding,在 SQL 里叫 Hopping。

5.4 Kafka Streams

KGroupedStream<String, Event> grouped = stream.groupByKey();

// 滚动窗口:size == advance
grouped.windowedBy(TimeWindows.ofSizeWithNoGrace(Duration.ofMinutes(1)))
       .aggregate(() -> 0L, (key, value, aggregate) -> aggregate + 1);

// 滑动窗口:advanceBy 让窗口按步长往前挪
grouped.windowedBy(TimeWindows.ofSizeWithNoGrace(Duration.ofMinutes(10))
                                .advanceBy(Duration.ofMinutes(1)))
       .aggregate(() -> 0L, (key, value, aggregate) -> aggregate + 1);

// 会话窗口
grouped.windowedBy(SessionWindows.ofInactivityGapWithNoGrace(Duration.ofMinutes(5)))
       .aggregate(() -> 0L,
                  (key, value, aggregate) -> aggregate + 1,
                  (key, a, b) -> a + b);   // ⚠️ 会话窗口必须传 Merger,见下

⚠️ 会话窗口的 aggregate 多一个参数。Kafka Streams 的 TimeWindowedKStream.aggregate(initializer, aggregator) 只有两个参数,但 SessionWindowedKStream.aggregate(initializer, aggregator, **merger**) 必须传第三个 Merger。原因很实在:会话窗口是会合并的——两个会话合并时,两个部分聚合结果也必须能被合并(比如求和可以相加,取最大值则不能)。这个 Merger 告诉引擎”两个部分结果该怎么合”。

写成两参数版本,编译器会直接报错;而如果用 reduce(而不是 aggregate)则没有这个问题,因为 reduce 天然知道怎么合并。

Kafka Streams 的官方 Javadoc 把语义写得最直白:

“Every T1 (advance) milliseconds, compute the aggregate total for T2 (size) milliseconds. If advance < size a hopping windows is defined: it discretize a stream into overlapping windows, which implies that a record maybe contained in one and or more ‘adjacent’ windows. If advance size a tumbling window is defined: it discretize a stream into non-overlapping windows, which implies that a record is only ever contained in one and only one tumbling window.”

——这正是 2.3 节那张对照表的官方出处。

⚠️ Kafka 4.x 的 API 变更:旧版的 TimeWindows.of(size, advance) 和 SessionWindows.with(gap) 已经移除。4.x 改为 ofSizeWithNoGrace(size) / ofSizeAndGrace(size, grace) / ofInactivityGapWithNoGrace(gap) / ofInactivityGapAndGrace(gap, afterWindowEnd)——grace(宽限期)被并入了窗口定义本身,滑动则通过链式调用 .advanceBy(advance) 表达。

另外,Kafka 的窗口是固定对齐到 epoch(1970-01-01) 的。Javadoc 明确说明:“the first window starts at timestamp zero”。5 秒窗口 3 秒步长的边界是 [0;5000)、[3000;8000),而不是 [1000;6000)。

5.5 Spark Structured Streaming

// 滚动窗口:window() 只给时长
val tumbling = events
  .withWatermark("timestamp", "10 minutes")
  .groupBy(window($"timestamp", "10 minutes"), $"userId")
  .count()

// 滑动窗口:第三个参数是滑动步长
val sliding = events
  .withWatermark("timestamp", "10 minutes")
  .groupBy(window($"timestamp", "10 minutes", "1 minute"), $"userId")
  .count()

// 会话窗口
val sessions = events
  .withWatermark("timestamp", "10 minutes")
  .groupBy(session_window($"timestamp", "5 minutes"), $"userId")
  .count()

Spark 的设计有一个值得注意的地方:滚动和滑动共用同一个 window() 函数,靠参数个数区分——两个参数是滚动,三个参数是滑动。这比 Flink 里两套不同的类更容易踩坑,因为传错参数个数不会报错,只会静默地变成另一种语义。

Spark 官方对三类窗口的定义也值得一读:

“Tumbling windows are a series of fixed-sized, non-overlapping and contiguous time intervals. An input can only be bound to a single window. Sliding windows are similar to the tumbling windows from the point of being ‘fixed-sized’, but windows can overlap if the duration of slide is smaller than the duration of window, and in this case an input can be bound to the multiple windows. Session window has a dynamic size of the window length, depending on the inputs.”

Spark 默认是微批(micro-batch) 引擎:数据先攒成一小批,再当作一个批处理任务执行,因此窗口天然按批推进。Spark 还提供 dropDuplicatesWithinWatermark,用于在 watermark 范围内对流做去重。

5.6 Apache Beam

// 滚动窗口
PCollection<Event> tumbling =
    input.apply(Window.into(FixedWindows.of(Duration.standardMinutes(1))));

// 滑动窗口:of(size) 之后用 every(slide) 指定步长
PCollection<Event> sliding =
    input.apply(Window.into(SlidingWindows.of(Duration.standardMinutes(10))
                                         .every(Duration.standardMinutes(1))));

// 会话窗口
PCollection<Event> sessions =
    input.apply(Window.into(Sessions.withGapDuration(Duration.standardMinutes(5))));

Beam 的命名最直观:FixedWindows(固定窗口)和 SlidingWindows(滑动窗口),一眼就能分辨。Beam 还能通过 withOffset(Duration) 改变窗口的对齐方式。

⚠️ 两个易踩的点:

  1. 窗口是通过 PTransform 应用的,写法是 input.apply(Window.into(...)),而不是 input.windowInto(...)——后者是 Beam 2.x 之前的旧 API,早已移除。
  2. Beam 用的是 Joda-Time,不是 java.time:FixedWindows.of 的参数类型是 org.joda.time.Duration,所以要写 Duration.standardMinutes(1)(Joda 的工厂方法),而不是 Duration.ofMinutes(1)(JDK 的写法)。而 Flink 2.x 和 Kafka 4.x 都已经改用 java.time.Duration 了。三个框架的 Duration 不是同一个类,跨框架抄代码时极易编译不过。

5.7 ⚠️ 最大的坑:同一个产品里,滑动窗口的参数顺序是相反的

这是实践中最容易造成线上事故的一个细节:

API 参数顺序 10 分钟窗口 / 1 分钟步长 应该写成
Flink DataStream SlidingEventTimeWindows.of(size, slide) 长度在前,步长在后 of(Duration.ofMinutes(10), Duration.ofMinutes(1))
Flink SQL HOP(ts, hop, size) 步长在前,长度在后 HOP(..., INTERVAL '1' MINUTE, INTERVAL '10' MINUTES)
Beam SlidingWindows.of(size).every(period) 长度在前,步长在后 of(10min).every(1min)
Kafka Streams ofSizeWithNoGrace(size).advanceBy(advance) 长度在前,步长在后 ofSizeWithNoGrace(10min).advanceBy(1min)
Spark window(ts, size, slide) 长度在前,步长在后 window($"ts", "10 minutes", "1 minute")

只有 Flink SQL 的 HOP(以及 CUMULATE)把步长放在了前面,其余全部是”长度在前”。记不住没关系,只要代码评审时对着上面这张表核一遍就能避开——写错了不会抛异常,只会安静地产出一份错误的结果。


六、 选型:到底该用哪一种

6.1 决策依据

你的需求 应该选 理由
每分钟/每小时/每天的分桶统计 滚动窗口 天然互斥,输出可直接累加,对账无歧义
“最近 N 分钟/小时”的持续观察 滑动窗口 语义就是连续视角
精确总量、GMV、订单数 滚动窗口 滑动会重复计数,除非下游去重
告警阈值判断(最近 5 分钟错误数 > 100) 滑动窗口 需要覆盖”刚刚发生”的连续区间
用户会话、连续操作识别 会话窗口 边界由数据决定
“从某个锚点开始到现在的累计” 累积窗口 起点固定、终点滚动
画趋势曲线、监控大盘 滑动窗口 采样点密集、平滑
生成 K 线 滚动窗口 K 线本身不重叠

6.2 一条实用的默认建议

先用滚动窗口。 滚动窗口的输出是可加的、口径清晰的,出了问题能对账。除非需求本身就是”最近 N 分钟”这种连续视角,否则滑动窗口带来的复杂度(重复计数、状态放大、输出量激增)通常不划算。

确实需要滑动时,再问三个问题:

  1. 步长 S 定多大? 步长越密越平滑,但状态量和输出量都按 W/S 线性增长。可以先从 W/10 起步。
  2. 下游知道结果不可累加吗? 如果下游有可能把它加总,务必在数据契约里写清楚。
  3. 能否降级为滚动? “最近 5 分钟”有时可以用”每分钟一格,取最近 5 格”来近似,代价是精度降到分钟级,但状态量降为 1。

6.3 性能与开销对比

维度 滚动窗口 滑动窗口
每 key 活跃状态数 1 ⌈W/S⌉
输出条数(相对) 1× W/S ×
相同数据被统计次数 1 ⌈W/S⌉
输出可累加 ✅ ❌
端到端延迟 相同(都受 watermark 约束) 相同
典型瓶颈 无 StateBackend 膨胀、checkpoint 变慢、恢复困难

七、 常见陷阱清单

陷阱一:把滑动窗口的输出直接累加

最常见的数据对不上事故。滑动窗口的输出是”采样点”,不是”分片”。

陷阱二:滑动步长写错位置

见 5.7。Flink SQL 的 HOP 步长在前,DataStream API 步长在后。

陷阱三:Spark 里 window() 少传一个参数

window($"ts", "10 minutes") 是滚动,window($"ts", "10 minutes", "1 minute") 是滑动。少写第三个参数不会报错,只会静默变成滚动窗口。

陷阱四:忘了设置事件时间

Spark 里不调用 withWatermark(),就只能用处理时间,窗口按到达时间切分——重放同一份历史数据时,每个窗口的统计结果都不一样。Kafka Streams 不设置 TimestampExtractor 同理。

陷阱五:窗口不是”到点就出”

所有引擎都要等水位线推进才输出窗口结果。如果下游期望”到整点立刻看到这一分钟的统计”,需要仔细评估 watermark 阈值与允许迟到时间的实际影响。

陷阱六:空窗口不会产生输出

滚动窗口如果某分钟没有任何数据,不会输出一行 0。做报表时如果指望”没数据就是 0″,需要自己补齐。

陷阱七:时区与对齐

Kafka 固定对齐 epoch;Flink 默认对齐 epoch,可用 offset 改成自然日;Spark 按 interval 对齐。跨时区的日报一定要显式指定偏移,否则”一天”的边界会差 8 小时。

陷阱八:会话窗口没有固定长度

会话窗口的长度事先未知,在无界流上无法预先开窗,需要引擎动态维护。状态开销和迟到处理都比定长窗口复杂。

陷阱九:Kafka 4.x 的窗口 API 已变更

TimeWindows.of(size, advance)、SessionWindows.with(gap) 在 4.x 中已被移除,从旧版本迁移的代码需要改写。

陷阱十:跨框架抄代码时,Duration 不是同一个类

Flink 2.x 和 Kafka 4.x 用 java.time.Duration,Beam 用 org.joda.time.Duration,Spark 用字符串。Beam 那边要写 Duration.standardMinutes(1),另外两边要写 Duration.ofMinutes(1)——抄错就是编译不过。

陷阱十一:Kafka 会话窗口的 aggregate 多一个 Merger 参数

因为会话会合并,两个部分聚合结果也得能合并。用 reduce 则没有这个问题。


总结

  • 滚动窗口把时间轴切成固定、互不重叠的格子,像「整点报时」——每条数据只被算一次,输出可以直接累加。
  • 滑动窗口长度固定但不断前移,像「最近 1 小时」——相邻窗口有重叠,同一条数据会被重复统计。
  • 判断标准只有一个:相邻窗口重不重叠。 用参数表达就是:步长 S 等于窗口大小 W 是滚动,小于 W 是滑动。
  • 选型时优先考虑滚动窗口。 滑动窗口换来的是”连续视角”,代价是重复计数、状态放大和输出量激增。
  • 无论选哪种,事件时间 + 水位线 + 迟到策略是绕不开的三大件,它们决定了窗口结果何时可见、是否可重放、能否与离线对账。

理解了这些,你就能在面对 Flink、Kafka Streams、Spark、Beam 的各种窗口 API 时,知道它们只是同一套语义的不同方言,而不是四套互不相干的概念。