流式计算架构
在热搜榜系统中,实时性是最核心的要求之一。用户的每一次点击、搜索、分享行为都会影响内容的热度值,而这些行为数据是以流的形式持续产生的。传统的批处理方式(如每小时或每天计算一次热度)无法满足实时热搜的需求,因此需要引入流式计算架构。
流式计算(Stream Processing)是指对连续不断产生的数据进行实时处理和分析的技术。与批处理不同,流式计算不需要等待数据全部到达,而是边接收边处理,能够实现毫秒级到秒级的延迟。
批处理的局限性
传统的批处理架构在处理热搜榜时面临以下问题:
- 延迟高:需要积累一段时间的数据才能进行计算,导致热搜榜更新滞后
- 资源浪费:即使数据量很小,也需要启动完整的批处理作业
- 无法响应突发事件:突发热点事件无法及时反映在热搜榜上
- 状态管理复杂:需要手动维护中间状态,容错性差
流式计算的优势
流式计算架构能够有效解决上述问题:
- 低延迟:数据到达即刻处理,延迟通常在秒级以内
- 增量计算:只处理新增数据,无需重复计算历史数据
- 自动状态管理:框架自动维护计算状态,支持容错和恢复
- 弹性扩展:可以根据流量自动扩缩容
整体架构
热搜榜的流式计算架构通常包含以下几个核心组件:
┌─────────────┐ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐
│ 用户行为 │────▶│ 消息队列 │────▶│ 流式计算 │────▶│ 热度存储 │
│ 数据采集 │ │ (Kafka) │ │ (Flink) │ │ (Redis) │
└─────────────┘ └─────────────┘ └─────────────┘ └─────────────┘
│ │ │ │
▼ ▼ ▼ ▼
点击/搜索/ 缓冲/解耦/ 实时聚合/ 排序/查询/
分享/评论 持久化 窗口计算 过期清理
数据流说明
- 数据采集层:收集用户的各种行为数据,包括点击、搜索、分享、评论、停留时长等
- 消息队列层:使用 Kafka 等消息队列作为数据缓冲,解耦生产和消费,保证数据不丢失
- 流式计算层:使用 Flink/Spark Streaming 等进行实时聚合计算,应用热度算法
- 存储层:将计算结果存储到 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 是衰减周期 - 分段衰减:不同时间段使用不同的衰减率
指数衰减是最常用的方法,因为它计算简单且效果良好。
防刷机制
热搜榜系统需要防止恶意刷榜行为。常见的防刷策略包括:
- 用户维度限流:同一用户的行为在单位时间内只计算一定权重
- 设备指纹识别:识别同一设备的多次操作
- 异常检测:检测异常的行为模式(如短时间内大量点击)
- 行为验证:对可疑行为进行二次验证
流式计算框架对比
| 框架 | 延迟 | 吞吐量 | 容错性 | 学习曲线 | 适用场景 |
|---|---|---|---|---|---|
| Flink | 毫秒级 | 高 | 强(Checkpoint) | 中等 | 复杂计算、精确一次 |
| Spark Streaming | 秒级 | 高 | 强 | 中等 | 批流一体、生态丰富 |
| Kafka Streams | 毫秒级 | 中 | 中 | 低 | 简单聚合、轻量级 |
| Storm | 毫秒级 | 中 | 中 | 较高 | 低延迟、复杂拓扑 |
对于热搜榜系统,Flink 是最常用的选择,因为它支持精确一次语义、强大的状态管理和丰富的窗口操作。
存储选型
| 存储 | 读写性能 | 数据结构 | 持久性 | 适用场景 |
|---|---|---|---|---|
| Redis | 极高 | 丰富(有序集合等) | 可选 | 实时排行、缓存 |
| Aerospike | 极高 | 简单 | 强 | 高并发、低延迟 |
| Cassandra | 高 | 简单 | 强 | 海量数据、写多读少 |
| Elasticsearch | 中 | 复杂 | 强 | 搜索、分析 |
Redis 的有序集合(Sorted Set) 是存储热搜榜的理想选择,因为它天然支持排序和范围查询。
Flink 流式计算代码示例
前面介绍了增量更新的思路:新热度 = 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. 背压处理
监控背压情况,及时调整上游数据发送速率或增加计算资源。
热搜榜系统需要完善的监控体系:
- 延迟监控:事件从产生到更新的端到端延迟
- 吞吐量监控:每秒处理的事件数
- 准确率监控:与离线计算结果的对比
- 异常告警:延迟超标、吞吐量下降、错误率上升
流式计算架构是实时热搜榜系统的核心。通过合理设计数据流、选择适当的窗口策略、应用时间衰减算法,可以实现低延迟、高准确的热度更新。在实际应用中,还需要考虑防刷机制、性能优化和监控告警等因素,确保系统的稳定性和可靠性。
在下一节中,我们将深入探讨窗口聚合的具体实现方法。
发现内容有问题?
告诉我们哪里需要改进。
