时间窗口聚合

概述

在流式计算中,窗口(Window) 是将无限数据流划分为有限数据块的核心机制。对于热搜榜系统,窗口聚合决定了我们如何统计用户行为、计算热度值,以及如何平衡实时性与准确性。

窗口聚合的本质是在时间维度上对数据进行分组和聚合。通过合理设计窗口策略,可以实现不同时间粒度的热度统计,满足多样化的业务需求。

为什么需要窗口

无限数据流的挑战

用户行为数据是持续不断产生的无限流:

时间 →
│ 点击  │  分享  │  点击  │  评论  │  点击  │  分享  │  点击  │ ...
└─────────────────────────────────────────────────────────────────→

如果不使用窗口,我们需要:

  • 维护所有历史数据的状态
  • 每次计算都遍历全部历史
  • 无法界定”当前热度”的时间范围

这显然是不现实的。窗口提供了一种有界计算的方式。

窗口的作用

  1. 限定计算范围:只统计特定时间段内的数据
  2. 控制状态大小:避免状态无限增长
  3. 支持多粒度分析:同时计算 1 分钟、5 分钟、1 小时的热度
  4. 处理乱序数据:配合水位线处理延迟到达的事件

窗口类型详解

滚动窗口(Tumbling Window)

滚动窗口是最简单的窗口类型,特点是固定大小、无重叠、无间隙。

时间轴:
│─────1 分钟─────│─────1 分钟─────│─────1 分钟─────│
│  窗口 1        │  窗口 2        │  窗口 3        │
│ [10:00-10:01)  │ [10:01-10:02)  │ [10:02-10:03)  │

特点:

  • 每个事件只属于一个窗口
  • 窗口之间互不重叠
  • 计算简单,资源消耗低

适用场景:

  • 统计每分钟的独立指标
  • 不需要跨窗口聚合的场景

代码示例:

滑动窗口(Sliding Window)

滑动窗口是热搜榜系统最常用的窗口类型,特点是固定大小、可重叠。

时间轴:
│─────────5 分钟窗口─────────│
      │─────────5 分钟窗口─────────│
            │─────────5 分钟窗口─────────│
                  │─────────5 分钟窗口─────────│

参数:

  • 窗口大小(Window Size):窗口覆盖的时间范围
  • 滑动步长(Slide Interval):窗口移动的间隔

特点:

  • 每个事件可能属于多个窗口
  • 窗口平滑过渡,避免边界效应
  • 计算开销较大(数据重复计算)

适用场景:

  • 需要平滑的热度曲线
  • 消除突发流量的影响
  • 多时间维度聚合

代码示例:

会话窗口(Session Window)

会话窗口是动态窗口,基于活动间隙(Gap)来划分窗口。

时间轴:
│─活动─│  空闲 5 分钟  │─活动─│─活动─│  空闲 5 分钟  │─活动─│
│ 窗口 1              │      窗口 2           │ 窗口 3  │

特点:

  • 窗口大小不固定
  • 由用户行为活跃度决定
  • 实现复杂度较高

适用场景:

  • 用户会话分析
  • 活跃度检测
  • 不适用于热搜榜的连续热度计算

滑动窗口实现详解

窗口分配器

滑动窗口的核心是窗口分配器(Window Assigner),它决定了每个事件分配到哪些窗口。

分配逻辑说明:

假设窗口大小 5 分钟,滑动步长 30 秒,事件时间 10:03:15:

  1. 计算最后窗口起始:10:03:00
  2. 向前遍历:10:03:00、10:02:30、10:02:00、10:01:30、10:01:00
  3. 检查是否覆盖事件时间:10:01:00 + 5 分钟 = 10:06:00 > 10:03:15 ✓
  4. 该事件分配到 5 个窗口

窗口触发器

触发器(Trigger) 决定何时执行窗口计算。

触发时机:

  • 事件时间触发:水位线超过窗口结束时间
  • 处理时间触发:系统时间到达指定时刻
  • 元素触发:每个新元素到达时

聚合函数

聚合函数定义了如何合并窗口内的数据。

完整方案示例

把前面讲的窗口分配器、水位线、触发器和聚合函数串成一个完整的作业。代码演示的是滑动窗口 + 增量聚合 + 多粒度输出的组合。

import org.apache.flink.api.common.eventtime.WatermarkStrategy;
import org.apache.flink.api.common.functions.AggregateFunction;
import org.apache.flink.api.common.state.ListState;
import org.apache.flink.api.common.state.ListStateDescriptor;
import org.apache.flink.configuration.Configuration;
import org.apache.flink.streaming.api.CheckpointingMode;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.KeyedProcessFunction;
import org.apache.flink.streaming.api.windowing.assigners.SlidingEventTimeWindows;
import org.apache.flink.streaming.api.windowing.time.Time;
import org.apache.flink.streaming.api.windowing.triggers.EventTimeTrigger;
import org.apache.flink.util.Collector;

import java.time.Duration;

/**
 * 热搜热度窗口聚合作业。
 *
 * 窗口配置:5 分钟窗口、30 秒步长、容忍 30 秒乱序。
 * 聚合方式:增量聚合,状态里只保留一个累加分数。
 */
public class HotSearchWindowJob {

    private static final Duration WINDOW_SIZE = Duration.ofMinutes(5);
    private static final Duration SLIDE_INTERVAL = Duration.ofSeconds(30);
    private static final Duration MAX_OUT_OF_ORDERNESS = Duration.ofSeconds(30);

    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.enableCheckpointing(60_000L);
        env.getCheckpointConfig().setCheckpointingMode(CheckpointingMode.EXACTLY_ONCE);
        // 保留一份外部化状态,作业重启后恢复更快
        env.getCheckpointConfig().setExternalizedCheckpointCleanup(
                org.apache.flink.streaming.api.checkpointing.ExternalizedCheckpointCleanup
                        .RETAIN_ON_CANCELLATION);

        WatermarkStrategy<InteractionEvent> watermarks = WatermarkStrategy
                .<InteractionEvent>forBoundedOutOfOrderness(MAX_OUT_OF_ORDERNESS)
                .withTimestampAssigner((event, timestamp) -> event.timestamp());

        DataStream<InteractionEvent> events = env
                .fromSource(source(), watermarks, "interaction-source")
                .name("kafka-source");

        // 滑动事件时间窗口 + 增量聚合
        DataStream<WindowHeat> aggregated = events
                .keyBy(event -> event.contentId())
                .window(SlidingEventTimeWindows.of(
                        Time.milliseconds(WINDOW_SIZE.toMillis()),
                        Time.milliseconds(SLIDE_INTERVAL.toMillis())))
                .trigger(EventTimeTrigger.create())
                .aggregate(new HeatAggregate())
                .name("window-aggregate");

        // 把窗口结果按用户维度关联,输出最终热度
        DataStream<HotSearchEntry> result = aggregated
                .keyBy(windowHeat -> windowHeat.contentId())
                .process(new MergeWindowFunction())
                .name("merge-window");

        result.addSink(new RedisWriteSink("ranking:hot")).name("redis-sink");

        env.execute("hot-search-window");
    }
}

窗口聚合函数用增量聚合实现,状态里只保留一个累加分数:

/**
 * 热度增量聚合函数。
 *
 * 累加逻辑要满足结合律和交换律,否则窗口合并和重分区时结果会不一致。
 */
public class HeatAggregate
        implements AggregateFunction<InteractionEvent, double[], WindowHeat> {

    private static final long serialVersionUID = 1L;

    /** 状态数组:第 0 位是热度总和,第 1 位是事件计数。 */
    @Override
    public double[] createAccumulator() {
        return new double[2];
    }

    @Override
    public double[] add(InteractionEvent event, double[] accumulator) {
        accumulator[0] += event.contribution();
        accumulator[1] += 1;
        return accumulator;
    }

    @Override
    public WindowHeat getResult(double[] accumulator) {
        return new WindowHeat(null, accumulator[0], (long) accumulator[1]);
    }

    @Override
    public double[] merge(double[] a, double[] b) {
        // 逐位相加,满足结合律与交换律
        a[0] += b[0];
        a[1] += b[1];
        return a;
    }
}

多窗口融合通过自定义 ProcessFunction 完成,它负责把同一个内容的多个窗口结果合并成一个最终分数:

/**
 * 多窗口融合:把同一个内容的多个滑动窗口结果汇总。
 *
 * 滑动窗口会让同一个内容出现在多个窗口中,这里按内容 ID 聚合,
 * 取最新窗口的分数,并用一个平滑系数与上一轮分数融合,
 * 避免分数在相邻窗口之间剧烈跳动。
 */
public class MergeWindowFunction
        extends KeyedProcessFunction<String, WindowHeat, HotSearchEntry> {

    private static final long serialVersionUID = 1L;

    /** 平滑系数:0 到 1,越接近 1 越信任新窗口的结果。 */
    private final double alpha;

    /** 每个内容最近一次的融合分数。 */
    private transient org.apache.flink.api.common.state.ValueState<Double> mergedState;

    public MergeWindowFunction() {
        this(0.7);
    }

    public MergeWindowFunction(double alpha) {
        this.alpha = alpha;
    }

    @Override
    public void open(Configuration parameters) {
        mergedState = getRuntimeContext().getState(
                new org.apache.flink.api.common.state.ValueStateDescriptor<>(
                        "merged-score", Double.class));
    }

    @Override
    public void processElement(
            WindowHeat value,
            Context ctx,
            Collector<HotSearchEntry> out) throws Exception {

        Double previous = mergedState.value();
        double merged = previous == null
                ? value.score()
                : alpha * value.score() + (1 - alpha) * previous;

        mergedState.update(merged);
        out.collect(new HotSearchEntry(value.contentId(), merged, value.windowEnd()));
    }
}

几个实现上的说明:

  • 增量聚合的代价是拿不到窗口结束时刻。AggregateFunction 在窗口触发前就能输出中间结果,这是它状态小的原因,但也意味着无法在聚合阶段做基于窗口末尾的衰减。需要在窗口结束时做修正,就改用 ProcessWindowFunction。
  • merge 的正确性是精确一次语义的前提。上面的实现逐位相加,天然满足结合律与交换律。如果聚合逻辑里有「取最大值」这类操作,也满足;但如果写成「累加后再乘一个系数」就不满足了,合并时必须重新应用系数。
  • 多窗口融合用平滑而不是取最新。滑动窗口相邻两次的结果本身就有重叠,直接取最新的那个会让分数随窗口滑动而抖动。用指数平滑把相邻结果融合,用户看到的变化会平缓很多。
  • 融合状态也要设 TTL。如果内容不再产生新互动,它的状态会一直保留。给 ValueState 设置状态 TTL,让过期内容自动回收,否则长期运行后状态会不断膨胀。

多时间窗口融合

实际生产中,通常需要融合多个时间窗口的结果:

单个窗口只能回答「最近 5 分钟什么最热」。但真实业务里,热度有好几个时间尺度:爆发力(5 分钟内涨得多快)、持续力(1 小时内是否稳定)、沉淀量(24 小时内积累了多少)。只看其中一个,都会误判。

典型误判场景:

内容5 分钟窗口1 小时窗口24 小时窗口实际情况
突发热点极高中等低正在爆发,应该上
慢热长文低中等高讨论在发酵,不该埋没
过期内容低低极高只是历史累积,该沉底

只按 5 分钟窗口排,慢热长文永远上不了榜;只按 24 小时窗口排,突发热点要等一天才被看到。

融合的基本思路是给每个窗口一个权重,加权求和:

FinalScore=∑iwi⋅Scorei\text{FinalScore} = \sum_{i} w_i \cdot \text{Score}_i
窗口权重回答的问题
5 分钟0.5现在是不是正在爆发
1 小时0.3这一波的热度是否稳定
24 小时0.2是否有持续的沉淀

权重不是固定的。不同场景对「爆发力」和「沉淀量」的重视程度不同:新闻榜更看重爆发,学术讨论榜更看重沉淀。

实现上的两种路线:

路线一:在 Flink 里一次算完所有窗口。用不同大小的窗口分别聚合,再合并:

import org.apache.flink.api.common.state.ValueState;
import org.apache.flink.api.common.state.ValueStateDescriptor;
import org.apache.flink.configuration.Configuration;
import org.apache.flink.streaming.api.functions.KeyedProcessFunction;
import org.apache.flink.util.Collector;

import java.util.HashMap;
import java.util.Map;

/**
 * 多时间窗口融合。
 *
 * 上游按不同窗口长度分别输出了窗口热度,
 * 这里按内容 ID 汇总各个窗口的结果,加权得到最终分数。
 *
 * 融合权重按内容类型区分:新闻看重爆发,讨论看重沉淀。
 */
public class MultiWindowFusionFunction
        extends KeyedProcessFunction<String, WindowHeat, HotSearchEntry> {

    private static final long serialVersionUID = 1L;

    /** 各时间窗口的融合权重。 */
    private static final double W_SHORT = 0.5;
    private static final double W_MEDIUM = 0.3;
    private static final double W_LONG = 0.2;

    /** 各窗口长度对应的键前缀。 */
    private static final String KEY_SHORT = "w5m";
    private static final String KEY_MEDIUM = "w1h";
    private static final String KEY_LONG = "w24h";

    /** 每个内容在各个窗口上的最新热度。 */
    private transient ValueState<Map<String, Double>> windowScores;

    @Override
    public void open(Configuration parameters) {
        windowScores = getRuntimeContext().getState(
                new ValueStateDescriptor<>("window-scores", Map.class));
    }

    @Override
    public void processElement(
            WindowHeat value,
            Context ctx,
            Collector<HotSearchEntry> out) throws Exception {

        Map<String, Double> scores = windowScores.value();
        if (scores == null) {
            scores = new HashMap<>();
        }

        // 按窗口长度归类,保存该窗口的最新分数
        scores.put(windowKeyOf(value.windowSizeHours()), value.score());
        windowScores.update(scores);

        // 三个窗口都有数据时才做融合,避免用不完整的数据计算
        if (scores.size() < 3) {
            return;
        }

        double fused = W_SHORT * scores.getOrDefault(KEY_SHORT, 0.0)
                + W_MEDIUM * scores.getOrDefault(KEY_MEDIUM, 0.0)
                + W_LONG * scores.getOrDefault(KEY_LONG, 0.0);

        out.collect(new HotSearchEntry(value.contentId(), fused, value.windowEnd()));
    }

    /**
     * 根据窗口长度归类。
     */
    private String windowKeyOf(double hours) {
        if (hours <= 0.25) {
            return KEY_SHORT;
        }
        if (hours <= 2.0) {
            return KEY_MEDIUM;
        }
        return KEY_LONG;
    }
}

路线二:在存储层做融合。各个窗口各自写入 Redis 的不同 key,查询时再加权合并。这条路线的好处是每个窗口的计算完全独立,可以各自扩容和重启;代价是查询时要读多个 key。

# 各窗口独立存储
ZADD ranking:hot:w5m  120.5 content:10086
ZADD ranking:hot:w1h   98.2 content:10086
ZADD ranking:hot:w24h  76.4 content:10086

# 查询时融合:需要先取各窗口的候选,再按内容 ID 合并

路线二的关键是取并集。融合的前提是拿到所有窗口的候选内容,因此每个窗口都要多取一些(比如各取前 200 条),取并集后再算融合分。内容在某个窗口里没进前 200,说明它在该维度上不重要,但仍可能在另一个维度上表现突出。

两条路线的对比:

维度Flink 内融合存储层融合
查询延迟低,一次查询拿到最终分高,要读多个 key 再合并
权重调整难,要改作业并重启容易,改配置即可
计算成本融合逻辑在流里各窗口独立,可分别扩容
故障影响融合逻辑出错则整体不可用单窗口故障只影响该维度

实践中推荐先做路线二。它的灵活性更高——权重调整是业务高频需求,改配置比重启 Flink 作业快得多。等到查询延迟确实成为瓶颈,再迁移到路线一。

融合权重要配置化,并带版本号。权重变了要能说清「某段时间的榜单是按哪版权重算的」,否则权重调整和流量波动会纠缠在一起,事后无法归因。

几个容易忽略的细节:

  • 各窗口的分数要先归一化再融合。5 分钟窗口的分数天然比 24 小时窗口小(累计的时间少),直接加权会让长窗口的分数主导结果。正确做法是每个窗口内部先做归一化(比如按窗口内的最高分归一),再融合。
  • 缺失的窗口按 0 处理,但要记录。某个内容在 24 小时窗口里没有数据(可能是刚发布),直接按 0 融合会让它的分数偏低。要区分「真的是 0」和「没有这个窗口的数据」。
  • 融合结果要可追溯。落库时记录每个窗口的原始分和当时的融合权重,排查时才能回答「为什么这条内容排在第八」。

性能优化策略

1. 窗口状态优化

问题:滑动窗口导致状态膨胀

解决方案:

  • 使用增量聚合(Incremental Aggregate)
  • 定期清理过期窗口
  • 合理设置窗口大小和滑动步长

2. 并行度调优

推荐并行度 = max(
    Kafka 分区数,
    预期吞吐量 / 单实例处理能力,
    CPU 核心数 * 0.8
)

注意事项:

  • 并行度必须是窗口大小的因子(避免数据倾斜)
  • 使用 Rebalance 算子均匀分布数据

3. 水位线优化

调优建议:

  • 乱序时间设置过大 → 延迟增加
  • 乱序时间设置过小 → 数据丢失
  • 根据实际数据分布动态调整

4. 背压处理

背压(Backpressure)指的是下游算子处理速度跟不上上游,导致上游被迫降速的现象。Flink 的背压是自适应的:下游缓冲区使用率高时,上游的发送会被阻塞,整个作业的速度自动降到下游能承受的水平。

背压本身不是故障,而是流处理框架的正常保护机制。真正的问题是持续且无法缓解的背压——它意味着作业的处理能力长期不足,数据在持续积压。

如何确认存在背压:观察 Flink 的 Web UI 或指标中的三个时间占比:

指标含义健康值
backPressuredTimeMsPerSecond每秒被背压阻塞的时长接近 0
busyTimeMsPerSecond每秒真正在处理的时长接近 1000
idleTimeMsPerSecond每秒空闲的时长接近 0

持续背压说明算子处于 busy 状态而下游处于 backPressured 状态,需要顺着拓扑往下游逐个排查。

根因与对策:

根因表现对策
Sink 写入慢最后一个算子长时间背压批量写入、增加 Sink 并行度、改用异步 IO
状态后端慢有状态算子处理耗时高改用增量聚合、配置 RocksDB、换用更快的磁盘
数据倾斜少数 subtask 长期 busy,其余 idle优化 keyBy、加随机前缀打散、两阶段聚合
计算逻辑过重单条记录处理耗时长拆分算子、把重逻辑下沉到离线
GC 压力gcTime 占比高,表现为周期性卡顿增大堆内存、减少对象创建、复用序列化器
网络传输量大Shuffle 阶段耗时高调整分区策略、压缩 Shuffle 数据

几个具体的优化手段:

  1. 优先解决数据倾斜。倾斜是背压最常见的根因,而且它表现为「大部分 subtask 空闲、少数 subtask 忙碌」,很容易被平均指标掩盖。排查方式是看各 subtask 的 numRecordsIn 分布,如果最大值远大于中位数,就是倾斜。

  2. 用两阶段聚合打散热点 key。如果倾斜来自少数几个超热的 key,可以先按 key + 随机后缀 做一次局部聚合,再按原始 key 做二次聚合,把热点分散到多个 subtask 上。

  3. 启用自适应调度。较新版本的 Flink 提供了自适应调度器,能根据背压情况自动调整并行度,把空闲的 subtask 资源调配给繁忙的 subtask。这能自动缓解倾斜和临时性的处理能力不足,但前提是下游的资源是共享的——如果瓶颈在外部系统(Redis 集群)上,自适应并行度帮不上忙,反而会增加对外部系统的压力。

  4. 控制 Source 的拉取速率。背压时上游会自然降速,但在某些情况下消费得太快,会把大量数据一次性塞进 Source 的缓冲区,挤占网络内存。给 Source 设置速率上限或更短的 idle-timeout,可以避免这种情况。

  5. 调整内存与网络配置。Flink 1.18 之后引入了细粒度的内存管理,网络内存、托管内存、堆内存的比例可以分开配置。背压严重且状态较小时,增加网络内存的占比往往能显著改善吞吐。

背压时的降级策略。有些背压短时间内无法解决,需要业务上的降级手段:

  • 跳过次要计算。例如在背压时关闭多样性重排、个性化调整等非核心计算,先保证主流程能产出结果。
  • 降低输出频率。把 TopN 的输出周期从 30 秒拉长到 2 分钟,减少下游的写入压力。
  • 丢弃过期数据。对时效性要求不高的分支,可以直接丢弃过期的中间结果而不是继续处理。
  • 切换到兜底榜单。如果背压持续超过一定时间,查询服务应该切到上一份成功写入的快照,而不是一直等待。

监控上要盯的三个信号:

  1. 背压比例的趋势。平稳的高背压说明容量不足需要扩容;突然出现的背压通常对应某次流量高峰或某个下游故障。
  2. 消费延迟。Kafka 消费位点与最新位点的差值。背压最终会表现为延迟增长,这个指标比背压本身更接近业务影响。
  3. 状态大小与恢复时间。背压期间 Checkpoint 会变慢甚至超时,作业重启时的恢复时间也会变长。这两项是背压的间接后果,需要一起监控。

排查顺序建议:先看背压发生在拓扑的哪个位置(Flink UI 的算子视图会标出背压的边),再判断是哪个算子处于 busy 状态,然后看那个算子的 subtask 分布是否均匀。均匀但都 busy 说明是容量问题,不均匀说明是倾斜问题。

常见问题与解决方案

问题 1:窗口数据丢失

原因: 水位线推进过快,延迟数据被丢弃

解决:

问题 2:状态膨胀

原因: 热点内容过多,状态无法清理

解决:

问题 3:计算结果不一致

原因: 并行计算时的状态合并问题

解决:

  • 确保聚合函数满足结合律和交换律
  • 使用 Checkpoint 保证精确一次语义
  • 在合并方法中正确处理时间衰减

监控指标

关键监控指标包括:

指标说明告警阈值
window_lateness窗口延迟时间> 30 秒
window_trigger_count窗口触发次数异常波动
state_size状态大小> 100 MB
watermark_delay水位线延迟> 10 秒
checkpoint_durationCheckpoint 耗时> 1 分钟

小结

窗口聚合是热搜榜流式计算的核心机制。滑动窗口通过重叠的时间范围,实现了平滑的热度计算,避免了滚动窗口的边界效应。在实际应用中,需要:

  1. 选择合适的窗口类型:滑动窗口适合热搜榜
  2. 合理配置窗口参数:平衡实时性与计算开销
  3. 处理延迟数据:使用水位线和允许延迟机制
  4. 优化状态管理:防止状态膨胀
  5. 完善监控体系:及时发现和解决问题

掌握窗口聚合技术,是构建高质量实时热搜榜系统的关键。

发现内容有问题?

告诉我们哪里需要改进。