流式计算架构

概述

在热搜榜系统中,实时性是最核心的要求之一。用户的每一次点击、搜索、分享行为都会影响内容的热度值,而这些行为数据是以流的形式持续产生的。传统的批处理方式(如每小时或每天计算一次热度)无法满足实时热搜的需求,因此需要引入流式计算架构。

流式计算(Stream Processing)是指对连续不断产生的数据进行实时处理和分析的技术。与批处理不同,流式计算不需要等待数据全部到达,而是边接收边处理,能够实现毫秒级到秒级的延迟。

为什么需要流式计算

批处理的局限性

传统的批处理架构在处理热搜榜时面临以下问题:

  1. 延迟高:需要积累一段时间的数据才能进行计算,导致热搜榜更新滞后
  2. 资源浪费:即使数据量很小,也需要启动完整的批处理作业
  3. 无法响应突发事件:突发热点事件无法及时反映在热搜榜上
  4. 状态管理复杂:需要手动维护中间状态,容错性差

流式计算的优势

流式计算架构能够有效解决上述问题:

  1. 低延迟:数据到达即刻处理,延迟通常在秒级以内
  2. 增量计算:只处理新增数据,无需重复计算历史数据
  3. 自动状态管理:框架自动维护计算状态,支持容错和恢复
  4. 弹性扩展:可以根据流量自动扩缩容

流式计算架构设计

整体架构

热搜榜的流式计算架构通常包含以下几个核心组件:

┌─────────────┐     ┌─────────────┐     ┌─────────────┐     ┌─────────────┐
│  用户行为    │────▶│  消息队列    │────▶│  流式计算    │────▶│  热度存储    │
│  数据采集    │     │  (Kafka)    │     │  (Flink)    │     │  (Redis)    │
└─────────────┘     └─────────────┘     └─────────────┘     └─────────────┘
       │                   │                   │                   │
       ▼                   ▼                   ▼                   ▼
   点击/搜索/           缓冲/解耦/          实时聚合/          排序/查询/
   分享/评论            持久化               窗口计算            过期清理

数据流说明

  1. 数据采集层:收集用户的各种行为数据,包括点击、搜索、分享、评论、停留时长等
  2. 消息队列层:使用 Kafka 等消息队列作为数据缓冲,解耦生产和消费,保证数据不丢失
  3. 流式计算层:使用 Flink/Spark Streaming 等进行实时聚合计算,应用热度算法
  4. 存储层:将计算结果存储到 Redis 等高性能存储中,支持快速查询和排序

核心概念

事件时间(Event Time)

在流式计算中,时间是一个关键概念。我们需要区分三种时间:

  • 事件时间(Event Time):事件实际发生的时间,通常由数据源携带
  • 处理时间(Processing Time):数据被系统处理的时间
  • 摄入时间(Ingestion Time):数据进入流式系统的时间

对于热搜榜系统,事件时间是最准确的,因为它反映了用户行为的真实发生时间。但在实际应用中,需要考虑事件乱序到达的问题。

水位线(Watermark)

由于网络延迟、系统故障等原因,事件可能乱序到达。水位线是一种机制,用于判断某个时间点之前的数据是否已经全部到达。

时间轴:  10:00  10:01  10:02  10:03  10:04  10:05
          │      │      │      │      │      │
事件:    E1     E3     E2     E5     E4     E6
          │      │      │      │      │      │
水位线:  W1           W3            W5            W6

水位线的设置需要权衡:设置太激进可能导致数据丢失,设置太保守会增加延迟。

窗口(Window)

窗口是流式计算的基本单位,用于将无限的数据流划分为有限的数据块进行处理。常见的窗口类型包括:

  • 滚动窗口(Tumbling Window):固定大小、不重叠的窗口
  • 滑动窗口(Sliding Window):固定大小、可重叠的窗口
  • 会话窗口(Session Window):基于活动间隙的动态窗口

对于热搜榜,通常使用滑动窗口来平滑热度变化,避免热度值剧烈波动。

实时热度更新策略

增量更新

热度值的计算应该是增量的,即每次只根据新到达的事件更新热度,而不是重新计算所有历史数据。

新热度 = f(旧热度,新事件,时间衰减)

其中 f 是热度计算函数,通常包含以下因素:

  • 新事件的权重(点击、分享、评论的权重不同)
  • 时间衰减因子(越早的事件权重越低)
  • 内容本身的属性(作者影响力、内容类型等)

时间衰减

为了让热搜榜能够反映最新趋势,需要对历史事件进行时间衰减。常见的衰减函数包括:

  • 指数衰减:weight = e^(-λt),其中 λ 是衰减率,t 是时间差
  • 线性衰减:weight = max(0, 1 - t/T),其中 T 是衰减周期
  • 分段衰减:不同时间段使用不同的衰减率

指数衰减是最常用的方法,因为它计算简单且效果良好。

防刷机制

热搜榜系统需要防止恶意刷榜行为。常见的防刷策略包括:

  1. 用户维度限流:同一用户的行为在单位时间内只计算一定权重
  2. 设备指纹识别:识别同一设备的多次操作
  3. 异常检测:检测异常的行为模式(如短时间内大量点击)
  4. 行为验证:对可疑行为进行二次验证

技术选型

流式计算框架对比

框架延迟吞吐量容错性学习曲线适用场景
Flink毫秒级高强(Checkpoint)中等复杂计算、精确一次
Spark Streaming秒级高强中等批流一体、生态丰富
Kafka Streams毫秒级中中低简单聚合、轻量级
Storm毫秒级中中较高低延迟、复杂拓扑

对于热搜榜系统,Flink 是最常用的选择,因为它支持精确一次语义、强大的状态管理和丰富的窗口操作。

存储选型

存储读写性能数据结构持久性适用场景
Redis极高丰富(有序集合等)可选实时排行、缓存
Aerospike极高简单强高并发、低延迟
Cassandra高简单强海量数据、写多读少
Elasticsearch中复杂强搜索、分析

Redis 的有序集合(Sorted Set) 是存储热搜榜的理想选择,因为它天然支持排序和范围查询。

实现示例

前面介绍了增量更新的思路:新热度 = f(旧热度,新事件,时间衰减)。下面用 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;

/**
 * 增量式热度更新。
 *
 * 每条事件到达时:
 * 1. 取出该内容当前的热度;
 * 2. 按距上次更新的时间做一次衰减;
 * 3. 叠加本次事件的贡献;
 * 4. 写回状态并输出。
 */
public class IncrementalHeatFunction
        extends KeyedProcessFunction<String, InteractionEvent, HeatUpdate> {

    private static final long serialVersionUID = 1L;

    /** 衰减系数(每小时)。 */
    private final double lambdaPerHour;

    /** 各行为类型的基础权重。 */
    private final java.util.Map<String, Double> behaviorWeights;

    /** 每个内容的当前热度。 */
    private transient ValueState<HeatState> heatState;

    public IncrementalHeatFunction(
            double lambdaPerHour,
            java.util.Map<String, Double> behaviorWeights) {
        this.lambdaPerHour = lambdaPerHour;
        this.behaviorWeights = behaviorWeights;
    }

    /** 内容的状态:热度分数与最后更新时间。 */
    public static class HeatState implements java.io.Serializable {
        private static final long serialVersionUID = 1L;
        public double heat;
        public long updatedAt;

        public HeatState() {
        }

        public HeatState(double heat, long updatedAt) {
            this.heat = heat;
            this.updatedAt = updatedAt;
        }
    }

    @Override
    public void open(Configuration parameters) {
        ValueStateDescriptor<HeatState> descriptor =
                new ValueStateDescriptor<>("heat-state", HeatState.class);
        this.heatState = getRuntimeContext().getState(descriptor);
    }

    @Override
    public void processElement(
            InteractionEvent event,
            Context ctx,
            Collector<HeatUpdate> out) throws Exception {

        HeatState state = heatState.value();
        if (state == null) {
            state = new HeatState(0.0, event.timestamp());
        }

        // 第一步:把热度衰减到当前时刻
        double elapsedHours = (event.timestamp() - state.updatedAt) / 3_600_000.0;
        if (elapsedHours < 0) {
            // 事件乱序或时钟回拨,按不衰减处理
            elapsedHours = 0.0;
        }
        double decayed = state.heat * Math.exp(-lambdaPerHour * elapsedHours);

        // 第二步:叠加本次事件的贡献
        double behaviorWeight = behaviorWeights.getOrDefault(event.behaviorType(), 1.0);
        double increment = behaviorWeight * event.weight;
        double updated = decayed + increment;

        // 第三步:写回状态
        state.heat = updated;
        state.updatedAt = event.timestamp();
        heatState.update(state);

        // 第四步:输出,供下游排序或写入存储
        out.collect(new HeatUpdate(event.contentId(), updated, event.timestamp()));
    }
}

为什么这里用增量更新而不是窗口聚合:两种方法各有适用场景。

对比项增量更新窗口聚合
状态大小与内容数量成正比与窗口内内容数量成正比,但窗口有多个
时间衰减天然支持(每次更新时衰减一次)需要额外处理
结果精度依赖事件到达顺序,略有偏差窗口内聚合,结果确定
适合场景实时榜单、热度趋势统计类指标、TopN 排序

热搜榜的实时热度更新适合用增量更新:每个内容只需要维护一个分数,状态极小,而且天然处理了时间衰减。窗口聚合更适合「每分钟统计一次各类行为总数」这类统计需求。

增量更新的一个已知偏差:分数的精度取决于事件到达的疏密。如果一个内容在十分钟内只有一条事件,那么这十分钟里它只被衰减了一次,而不是持续衰减。结果会比真实情况略高。缓解办法是在下游加一个定时刷新任务,对长时间没有更新的内容做一次精确修正。

状态时间戳的选择:用事件时间而不是处理时间记录 updatedAt,才能保证重放和乱序场景下的正确性。用处理时间会让结果依赖机器的调度,无法复现。

Redis 存储示例

计算结果需要落到 Redis,供查询服务读取。热搜榜的存储有几个特点:需要按分数排序、需要按内容 ID 反查分数、需要频繁地覆盖写入。

Key 设计:

# 实时热榜:一个有序集合,成员是内容 ID,分数是热度
ZADD ranking:hot 1250.5 "content:10086"
ZADD ranking:hot 980.2  "content:10087"

# 各分类的热榜:按分类拆分,避免单 key 过大
ZADD ranking:hot:tech 850.0 "content:20001"
ZADD ranking:hot:sports 640.0 "content:20002"

# 内容详情:字符串,存标题等元信息
SET content:10086 '{"title":"...","category":"tech"}'
EXPIRE content:10086 86400

常用操作:

# 写入热度(ZADD 本身会覆盖旧分数)
ZADD ranking:hot 1250.5 "content:10086"

# 批量写入:一次命令写入多个成员
ZADD ranking:hot 1250.5 "content:10086" 980.2 "content:10087" 760.0 "content:10088"

# 读取前 N 名
ZREVRANGE ranking:hot 0 49 WITHSCORES

# 查询某个内容的名次(从 0 开始,返回 null 表示不在榜上)
ZREVRANK ranking:hot "content:10086"

# 查询某个内容的分数
ZSCORE ranking:hot "content:10086"

# 清理已经过期的条目:按分数阈值删除低分内容
ZREMRANGEBYSCORE ranking:hot 0 10

# 查询总分数量
ZCARD ranking:hot

Java 写入实现:

import java.util.List;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.Tuple;

/**
 * 热搜榜的 Redis 存储。
 */
public class HotRankingStore {

    private final JedisPool jedisPool;
    private final String key;

    public HotRankingStore(JedisPool jedisPool, String key) {
        this.jedisPool = jedisPool;
        this.key = key;
    }

    /**
     * 批量写入热度分数。
     *
     * 使用 Pipeline 把多次写入合并成一次网络往返。
     */
    public void saveAll(List<HeatUpdate> updates) {
        if (updates.isEmpty()) {
            return;
        }
        try (Jedis jedis = jedisPool.getResource()) {
            redis.clients.jedis.Pipeline pipeline = jedis.pipelined();
            for (HeatUpdate update : updates) {
                pipeline.zadd(key, update.score(), update.contentId());
            }
            pipeline.sync();
        }
    }

    /**
     * 读取前 N 名。
     */
    public List<Tuple> topN(int count) {
        try (Jedis jedis = jedisPool.getResource()) {
            return jedis.zrevrangeWithScores(key, 0, count - 1);
        }
    }

    /**
     * 清理分数低于阈值的条目。
     *
     * 分数低的条目对榜单没有价值,但会持续占用内存,
     * 定期清理可以控制 ZSet 的规模。
     */
    public long removeBelow(double threshold) {
        try (Jedis jedis = jedisPool.getResource()) {
            return jedis.zremrangeByScore(key, 0, threshold);
        }
    }
}

存储设计的三个考量:

  • 为什么用 ZSet 而不是自己维护排序。ZSet 的分数排序是 Redis 内置的,ZREVRANGE 能直接取到排名区间,不需要应用层排序。代价是分数相同时的顺序由 Redis 内部规则决定,如果业务对并列有明确要求,需要把并列信息编码进分数里。
  • 单 key 要控制大小。一个 ZSet 里放几十万个成员时,ZREMRANGEBYSCORE 之类的操作会变慢,内存占用也高。建议按分类拆分成多个 key,每个 key 的规模控制在可管理范围内。
  • 写入和清理要分开。写入路径只做 ZADD,保证延迟可控;清理是低优先级的后台任务,按固定周期执行,不要放在写入路径上。

性能优化

1. 数据本地化

将计算任务尽量调度到数据所在的节点,减少网络传输。

2. 状态后端优化

  • 使用 RocksDB 状态后端处理大状态
  • 合理设置 Checkpoint 间隔
  • 启用增量 Checkpoint

3. 并行度调整

根据数据量和分析结果动态调整并行度:

并行度 = 吞吐量 / 单节点处理能力

4. 背压处理

监控背压情况,及时调整上游数据发送速率或增加计算资源。

监控与告警

热搜榜系统需要完善的监控体系:

  1. 延迟监控:事件从产生到更新的端到端延迟
  2. 吞吐量监控:每秒处理的事件数
  3. 准确率监控:与离线计算结果的对比
  4. 异常告警:延迟超标、吞吐量下降、错误率上升

小结

流式计算架构是实时热搜榜系统的核心。通过合理设计数据流、选择适当的窗口策略、应用时间衰减算法,可以实现低延迟、高准确的热度更新。在实际应用中,还需要考虑防刷机制、性能优化和监控告警等因素,确保系统的稳定性和可靠性。

在下一节中,我们将深入探讨窗口聚合的具体实现方法。

发现内容有问题?

告诉我们哪里需要改进。