用 Rust 从零搭一个流处理引擎:水位线决定"什么时候能出结果"
前面几个系统都在处理"存下来的数据"。流处理处理的是一个更别扭的东西:一份永远没有结尾的数据。
批处理引擎的代码里有一个天然的时间点:输入读完了,结果就是结果。 流处理引擎没有这个点——它必须自己造一个,然后为这个造出来的东西估计错误承担后果。
这个"造出来的进度"就是水位线(watermark)。这篇的一切设计都围绕它展开。
第一步:为什么不能用"处理时间"
数据有两个时间:
事件时间(event time):事情真正发生的时刻,由产生数据的设备打上
处理时间(process time):引擎收到这条数据的时刻两者之差就是传输延迟,而这个延迟不是常数:
设备产生事件 @ 10:00:00
→ 本地缓存 3 秒(离线了)
→ 网络传输 200 毫秒(重传了一次)
→ 队列里排队 5 秒(消费积压)
→ 引擎处理 @ 10:00:08
延迟 = 8 秒,而且下一次可能是 2 秒,也可能是 3 分钟如果按处理时间做窗口统计,会有两个致命后果:
后果一:结果依赖"系统当时有多忙"。 同一个时间段的数据,在系统空闲时被分到窗口 A,在系统繁忙时被分到窗口 B。同一个查询跑两次结果不同——而这不是 bug,是设计如此。
后果二:历史数据无法回填。 想重算上周的数据,就要把上周的数据重放一遍。但重放时的处理时间和上周不一样,所以结果也不一样。 也就是说:你永远无法回答"上周这个指标到底是多少"。
所以事件时间是唯一可用的选择。 而它的代价立刻出现:
数据按事件时间到达的顺序,是乱的。
到达顺序:10:00:05, 10:00:02, 10:00:09, 10:00:03, 10:00:07 ...
真实顺序:10:00:02, 10:00:03, 10:00:05, 10:00:07, 10:00:09
问题:我算到 10:00:05 的时候,能输出"10:00:00 - 10:00:05"这段的结果吗?
不能 —— 因为 10:00:02 和 10:00:03 可能还没到。于是需要一个东西来回答"我认为到 10:00:05 之前的数据都到齐了"——这就是水位线。
事件时间把"正确性"从"系统状态"里解放出来,代价是引入了一个"必须被估计的量"。 所有流处理的复杂度都从这个估计里长出来:估计太保守就慢,估计太激进就错,而估错之后必须有补救机制。
第二步:水位线——一个单调的、必然是错的估计
/// 水位线:引擎对"事件时间进度"的下界估计
pub struct WatermarkGenerator {
/// 到目前为止见到的最大事件时间
max_observed: i64,
/// 允许的乱序程度:这是唯一需要人工调的参数
allowed_lateness: i64,
/// 已经发出的水位线(必须单调)
current: i64,
}
impl WatermarkGenerator {
pub fn on_event(&mut self, event_time: i64) {
self.max_observed = self.max_observed.max(event_time);
}
/// 周期性调用(比如每 200ms),产出一个新的水位线
pub fn emit(&mut self) -> Option<i64> {
// 核心公式:水位线 = 见过的最大事件时间 - 允许乱序
let candidate = self.max_observed - self.allowed_lateness;
// ★ 单调性检查:水位线只能前进,绝不能后退
if candidate > self.current {
self.current = candidate;
Some(self.current)
} else {
None // 不发出,保持当前水位线
}
}
}这个公式只有一行,但它蕴含了三件事:
第一,水位线是一个估计,不是事实。 allowed_lateness 就是"我愿意为正确性付出多少延迟"。设成 5 秒,意味着最多 5 秒的乱序数据能被正确归窗——而第 6 秒才到的数据,就是一个"迟到事件"。
第二,水位线的单调性是硬约束。
如果水位线回退了,会发生什么?
窗口 [10:00, 10:05) 已经因为水位线越过 10:05 而被触发并输出
水位线回退到 10:03 —— 这个窗口"又没到时间"了
→ 它会再次被触发,重复输出
→ 或者更糟:状态已经被清理,无法重新计算所以"单调"这一条不是优化,而是整个正确性的前提。 而它带来的一个直接后果是:水位线不能"跟随最新数据下降",即使数据看起来确实变慢了。 数据变慢只意味着水位线停止前进,永远不会后退。
多分区的水位线:取最小值
pub struct MultiPartitionWatermark {
/// 每个输入分区自己的水位线
per_partition: Vec<i64>,
}
impl MultiPartitionWatermark {
/// ★ 全局水位线 = 所有分区里的最小值
pub fn global(&self) -> i64 {
self.per_partition.iter().copied().min().unwrap_or(i64::MIN)
}
}为什么必须取最小值? 设想两个分区:
分区 A:数据活跃,水位线到了 10:10
分区 B:卡住了(网络问题 / 上游暂停),水位线还在 10:00
取最大值 → 全局水位线 10:10
→ 引擎认为"10:00 到 10:10 的数据都到齐了"
→ 但分区 B 里 10:00 到 10:10 的数据一条都还没到
→ 这些数据全部变成迟到事件,窗口已经输出过了
取最小值 → 全局水位线 10:00
→ 引擎继续等
→ 慢分区一旦恢复,数据能被正确处理
→ 代价:整个作业的延迟被最慢的分区拖住这是一个非常典型的"正确性优先于延迟"的取舍。 而且它有一个讨厌的后果:一个分区卡住,整个作业的输出都停了。 这就是"水位线停滞"(watermark stall),是流处理运维里最常见的一类故障——表面上作业还活着,指标上还在消费,但输出一条都没有。
水位线的最优估计依赖于"最慢的那条路径",而不是"平均情况"。 这和分布式系统的其它地方是同一个道理:整体延迟由最慢的那部分决定,而所有基于"平均情况"的优化都会在异常路径上失效。
空闲分区的问题
上面那个设计有个直接的问题:如果一个分区现在根本没有数据(比如某个地区的流量在凌晨是零),它的水位线会永远停在那里,把全局水位线也拖住。
pub struct PartitionState {
pub watermark: i64,
/// 最后一次看到数据的时间(处理时间)
pub last_activity: Instant,
}
impl MultiPartitionWatermark {
pub fn global(&self, now: Instant, idle_timeout: Duration) -> i64 {
self.partitions.iter()
.filter(|p| {
// ★ 长时间没数据的分区,标记为"空闲",不参与最小值计算
now.duration_since(p.last_activity) < idle_timeout
})
.map(|p| p.watermark)
.min()
.unwrap_or_else(|| {
// 所有分区都空闲:用最大已见时间推进,否则作业永远不动
self.partitions.iter().map(|p| p.watermark).max().unwrap_or(i64::MIN)
})
}
}"空闲检测"是一个必须的设计,而且它的阈值需要小心选:
| 阈值 | 后果 |
|---|---|
| 太短(秒级) | 分区稍一抖动就被判为空闲,水位线跳进 → 数据变成迟到 |
| 太长(分钟级) | 一个分区真的停了,整个作业陪着它一起停 |
正确的判断标准是"这个分区正常的到达间隔是多少"——通常设成正常间隔的若干倍。
"没有数据"和"数据迟到"是两件事,但水位线机制无法区分它们。 这就是需要一个显式的"空闲"概念的原因:它是引擎在"我看到的输入"之外,额外使用的一个信息源(处理时间)。
第三步:窗口、触发与清理——三个不同的时刻
窗口分派本身很简单:
pub enum Window {
/// 滚动窗口:不重叠,[t, t+size)
Tumbling { size: i64 },
/// 滑动窗口:可重叠,每 slide 启动一个新窗口
Sliding { size: i64, slide: i64 },
/// 会话窗口:间隔超过 gap 就断开
Session { gap: i64 },
}
impl Window {
pub fn assign(&self, event_time: i64) -> Vec<(i64, i64)> {
match self {
Window::Tumbling { size } => {
let start = event_time.div_euclid(*size) * size;
vec![(start, start + size)]
}
Window::Sliding { size, slide } => {
// 一个事件可能属于多个滑动窗口
let latest = event_time.div_euclid(*slide) * slide;
let mut out = Vec::new();
let mut start = latest;
while start > event_time - size {
out.push((start, start + size));
start -= slide;
}
out
}
Window::Session { .. } => todo!("会话窗口要按 key 维护活跃区间"),
}
}
}滑动窗口这里有个容易忽略的点:while start > event_time - size 的循环次数是 size / slide。 如果窗口 1 小时、滑动 1 秒,一个事件要写进 3600 个窗口——这是流处理里最经典的性能陷阱之一("滑动窗口把状态炸了")。
接下来是真正难的部分:窗口有四个不同的时刻,而它们经常被实现者混成两个。
pub enum WindowAction {
/// 输出结果给下游(用户可以看到了)
Output,
/// 允许迟到数据继续更新状态(结果可能会再更新一次)
AllowLate,
/// 清理状态,但用户还能收到更新后的结果
Evict,
/// 彻底删除状态,之后来的数据算作"太迟了",直接丢弃
Purge,
}时间轴(窗口 [10:00, 10:05),水位线越过 10:05 时触发,allowed_lateness = 1 分钟)
10:00 ──────────────────────────────────────────────────────→ 10:06
│ │ │ │
窗口数据到达 Output Evict Purge
水位线越过 10:05 可再更新 仍在更新 状态删除
(第一次输出) (迟到数据处理) (最后一次输出)这四个时刻为什么不能合并?
如果 Output 和 Purge 合并(触发即删状态):迟到的数据无处可归,只能丢弃。结果是概率性的数据丢失——取决于网络延迟。
如果 Evict 和 Purge 合并:迟到窗口期内的数据无处暂存,要么丢弃,要么整个作业的状态无限增长。
所以两个"间隔"都是必须的:
pub struct WindowState {
pub start: i64,
pub end: i64,
pub accumulator: Accumulator,
/// 已经输出过几次(用于判断是"首次输出"还是"更新")
pub emitted: u32,
/// 水位线越过 end 的时刻(处理时间),用来算 evict / purge 的截止
pub triggered_at: Option<Instant>,
}
impl WindowState {
/// 四个动作各自的条件
pub fn actions(&self, watermark: i64, now: Instant, cfg: &Config) -> Vec<WindowAction> {
let mut out = Vec::new();
// ① 水位线越过窗口结束 → 首次输出
if watermark >= self.end && self.emitted == 0 {
out.push(WindowAction::Output);
}
// ② 触发之后,仍然接受迟到数据(直到 purge)
if self.triggered_at.is_some() && watermark < self.end + cfg.allowed_lateness {
out.push(WindowAction::AllowLate);
}
// ③ 允许迟到期结束 → 最后一次输出,然后清理
if watermark >= self.end + cfg.allowed_lateness {
if self.emitted > 0 {
out.push(WindowAction::Evict);
}
out.push(WindowAction::Purge);
}
out
}
}这里有一个关键洞察:Output 是可以发生多次的。
10:05:00 水位线越过 → 输出 "count = 100"
10:05:30 来了 2 条迟到数据 → 再输出一次 "count = 102"
10:06:00 允许迟到期结束 → 最后输出 "count = 102"(如果没变化可以不输出)而下游必须能处理"同一个窗口被输出多次"这件事。 处理方式有两种:
| 方式 | 下游要求 | 说明 |
|---|---|---|
| 更新(upsert) | 下游能按 key 覆盖 | 窗口作为主键,每次都覆盖 |
| 追加(append)+ 去重 | 下游能看到"这是第几次" | 输出里带一个序号或"是否最终"标记 |
这也是为什么很多流处理作业的下游是"可 upsert 的存储"——因为这天然解决了重复输出的问题,而这就是第一章那个时序库的降采样表在做的事(按 (series, window) 覆盖写)。
"结果可能被更新"这件事必须写在接口里。 如果一个流处理系统对外承诺"每个窗口输出一次且仅一次",那它就只能在延迟和正确性之间二选一——而"允许更新"是把选择权交给下游的一种方式。
第四步:状态后端——为什么内存状态是不够的
现在到系统层面最关键的一步。
算子是带状态的:窗口的累加器、join 的缓冲区、去重的集合、水位线本身。而"状态放内存"会同时撞上三面墙:
| 墙 | 具体表现 |
|---|---|
| 容量 | keyed state 可能有几千万个 key,每个 key 一个累加器 |
| 恢复 | 进程重启,内存里的一切消失 |
| 弹性 | 扩容时要把状态重新分配给新实例 |
所以状态必须落到一个"可持久化、可范围遍历、可快照"的存储上。 这就是状态后端。而业界的选择是 LSM-Tree(RocksDB):
pub struct LsmStateBackend {
db: LsmStore,
/// 算子的命名空间,避免不同算子的 key 撞在一起
operator_id: String,
}
impl LsmStateBackend {
fn key(&self, keyed_key: &[u8], window: i64) -> Vec<u8> {
// 布局:operator_id | key_hash | window
// 前面说过:定长 + 大端拼接,让 (key, window) 的字典序等于元组序
let mut k = Vec::new();
k.extend_from_slice(self.operator_id.as_bytes());
k.push(0); // 分隔符,防止前缀歧义
k.extend_from_slice(keyed_key);
k.extend_from_slice(&window.to_be_bytes());
k
}
/// 更新窗口累加器:这是一次"读-改-写"
pub fn update_window<F>(&mut self, keyed_key: &[u8], window: i64, f: F) -> Result<()>
where
F: FnOnce(&mut Accumulator),
{
let k = self.key(keyed_key, window);
// 注意:这里读出来的值可能是反序列化过的旧状态
let mut acc = match self.db.get(&k)? {
Some(bytes) => decode_accumulator(&bytes),
None => Accumulator::default(),
};
f(&mut acc);
self.db.put(&k, &encode_accumulator(&acc))?;
Ok(())
}
}这里有一个必须承认的代价:LSM 最不擅长"随机点更新",而状态访问恰好是随机点更新。
LSM 擅长的:顺序追加、批量写
状态访问的:每个事件都要读一个 key、改一个值、写回去
→ 大量小的随机读 + 小的随机写
→ MemTable 反复被填满,频繁 flush,写放大严重那为什么还是用 LSM? 因为它有另外三个更重要的性质:
性质一:按 key range 的增量快照。
RocksDB 的 SST 文件是不可变的(和时序库的段是同一个思路)。
所以"做一次快照"不需要拷贝数据 —— 只要记录"当前包含哪些 SST 文件"。
下次快照只需要记录"新增了哪些 SST 文件"。
这就是增量 checkpoint 的实现基础:
全量 checkpoint = 拷贝所有 SST
增量 checkpoint = 只记新增的 SST(通常小一两个数量级)这是 LSM 在流处理里不可替代的理由。 换成 B+ 树,"做快照"意味着要把整棵树的脏页写出去。
性质二:状态可以大于内存。 几千万个 key 的累加器,LSM 会自然把它溢写到磁盘,而哈希表会直接 OOM。
性质三:范围遍历是有序的。 会话窗口合并、join 的区间扫描、状态的按 key 重分配——这些都依赖"按 key 有序遍历",而哈希表做不到。
一个存储引擎被选中,往往不是因为它在"常规操作"上最快,而是因为它在某个关键操作上能做到别人做不到的事。 LSM 在点更新上输给 B+ 树,但它"不可变文件 + 元数据快照"这个结构,让增量 checkpoint 成为可能——而在一个必须周期性给几百 GB 状态做快照的系统里,这一条就压倒了一切。
第五步:Checkpoint——"所有状态在同一个逻辑时刻"
有了状态后端,第二个问题来了:怎么得到一份"所有算子的状态都停在同一个逻辑时刻"的快照?
注意这句话里的难点是"同一个逻辑时刻"。 如果算子 A 的状态快照停在第 1000 条数据,算子 B 停在第 995 条,那么这份快照是不自洽的——恢复之后,B 会重放第 996 条,而 A 已经把它算过了。结果就是重复计算。
解法是注入一个"屏障"(barrier),让它随数据流走。
Source 每 N 秒注入一个 barrier:
Source ──[a][b][BARRIER-1][c][d]──→ 算子 A ──[a'][b'][BARRIER-1][c']──→ 算子 B
│
A 看到 BARRIER-1 时:
① 快照自己的状态
② 把 barrier 往下游转发关键规则:屏障之前的数据属于"上一个 checkpoint",之后的数据属于"下一个"。 而屏障在流里的位置,就定义了这个 checkpoint 覆盖到哪。
屏障对齐:为什么它必然导致反压
如果一个算子有两个输入(比如 join),两个输入的屏障到达时间必然不同:
输入 1: ──[a][b][BARRIER-1][c][d]──→
╲
╱ 算子(双输入)
╱
输入 2: ──[x][y][z]──────────[BARRIER-1]──→
↑
输入 2 的屏障慢了很多算子必须做的事:
impl TwoInputOperator {
fn on_barrier(&mut self, input: usize, barrier: Barrier) -> Result<()> {
self.received_barrier[input] = Some(barrier);
// ★ 对齐:在收齐所有输入的同一个 barrier 之前,
// 已经收到 barrier 的那个输入的数据必须被缓冲起来
if self.all_inputs_have_barrier(&barrier) {
// 收齐了:快照状态,下游转发 barrier
self.snapshot()?;
self.checkpoint_barrier = Some(barrier.id);
self.forward_barrier(barrier)?;
} else {
// 没齐:停止从这个输入读数据
// 而这个输入的队列会满 → 上游被阻塞 → 反压逐级传回 Source
self.block_input(input);
}
Ok(())
}
}这就是流处理里"反压会逐级传导"的根源,而且它不是 bug,是 checkpoint 机制的必然代价:
一个分支慢 → 它的 barrier 到得晚 → 算子一直在等
→ 已经拿到 barrier 的那个输入被停读
→ 它的上游队列满 → 上游停写 → 一路传到 Source
→ 整个作业的吞吐被最慢的分支拖住"对齐全阻塞"是流处理里最被诟病的性能问题。 优化方案叫非对齐 checkpoint(unaligned checkpoint):
pub enum CheckpointMode {
/// 对齐:等所有输入的 barrier 到齐,期间阻塞
Aligned,
/// 非对齐:不等,把"已经缓冲的、属于当前 checkpoint 的数据"一起快照
Unaligned,
}非对齐的做法是:收到第一个 barrier 就立刻开始快照,同时把"其他输入里已经到但还没处理的那些数据"也写进快照。
| 对齐 | 非对齐 | |
|---|---|---|
| 阻塞 | 会(等最慢的分支) | 不会 |
| 快照大小 | 只有状态 | 状态 + 途中缓冲的数据 |
| 恢复时的重放量 | 小 | 大(要重放缓冲的数据) |
| 适用 | 状态大、反压不严重 | 反压严重、状态小 |
"非对齐"是把阻塞的代价换成快照大小的代价。 这是一个很干净的交易,但它有一个前提:途中缓冲的数据量不能太大——因为如果反压很严重,缓冲的数据可能有几百 MB,那快照本身就会变成一个巨大的 IO 事件,反而让整个作业更慢。
"快照"这件事的难点从来不是"把状态写出去",而是"让所有部分的状态停在同一时刻"。 而所有让这个"同一时刻"变得容易的机制(对齐),代价都是阻塞;所有避免阻塞的机制(非对齐),代价都是快照变大。没有免费的"一致性时刻"。
checkpoint 什么时候算完成
pub struct CheckpointCoordinator {
/// 这次 checkpoint 里所有算子的确认
acks: HashSet<OperatorId>,
/// 参与本次 checkpoint 的所有算子
participants: HashSet<OperatorId>,
}
impl CheckpointCoordinator {
/// ★ 只有所有算子都确认了,这次 checkpoint 才算完成
pub fn on_ack(&mut self, op: OperatorId) -> bool {
self.acks.insert(op);
self.acks.len() == self.participants.len()
}
pub fn complete(&mut self, cp: CheckpointId) -> Result<()> {
// ① 把 checkpoint 元数据(包含哪些 SST 文件、写到哪个路径)
// 持久化到"检查点目录" —— 这一步才是真正的"提交点"
self.durable_store.commit_checkpoint(cp)?;
// ② 提交之后,可以通知 Source 去 ack 消息队列了(第六步)
// ③ 更早的 checkpoint 可以标记为可删除
Ok(())
}
}这里有一个"提交点"的概念,非常容易被忽略:
"所有算子都写完了快照" ≠ "这次 checkpoint 有效"
真相是:
快的算子写完了 → 慢的算子还在写 → 这时候崩溃
→ 快算子的快照存在,但这次 checkpoint 不完整
→ 恢复时必须回退到上一次完整的 checkpoint
→ 快算子的那次快照是垃圾,必须能识别并清理所以必须有一个"提交点":只有当所有参与者都确认、并且元数据被持久化之后,这次 checkpoint 才算存在。 在这之前的所有快照文件都只是"候选",需要被垃圾回收。
"完成"和"提交"是两个不同的动作,而中间隔着一次持久化。 这个模式在分布式系统里无处不在:两阶段提交、WAL 的 fsync 时刻、对象存储的 multipart complete。它的本质是:在多个参与者都说了"我好了"之后,需要一个权威的、持久的、原子的记录来宣布"这件事成立了"。
第六步:端到端一次性——ack 的时机是全部的秘密
现在可以把"恰好一次"这个词拆开了。
流处理作业的完整链路:
消息队列 ──→ Source ──→ 算子 ──→ Sink ──→ 外部存储
↑
什么时候 ack(告诉队列"这条我处理完了,可以删了")?错误做法一:读到就 ack
// 错误:读一条就 ack 一条
loop {
let (msg, offset) = queue.poll()?;
process(msg)?;
queue.ack(offset)?; // ← 数据已经不在队列里了
}崩溃之后,这条数据永久消失。 因为队列已经删了它,而状态快照还没做。这是 at-most-once(最多一次),也就是会丢数据。
错误做法二:处理完就 ack
// 也错
loop {
let (msg, offset) = queue.poll()?;
process(msg)?;
state.update(msg)?;
queue.ack(offset)?; // ← 状态还在内存里,没做 checkpoint
}崩溃之后,状态回退到上一次 checkpoint,但队列里的数据已经被 ack 掉了。 还是要丢数据。
正确做法:checkpoint 完成之后再 ack
impl Source {
async fn run(&mut self) -> Result<()> {
loop {
let (msg, offset) = self.queue.poll().await?;
// 处理 + 更新状态(状态在 LSM 里,随时可快照)
self.process(msg)?;
// ★ 把 offset 记在"待确认"里,不立刻 ack
self.pending_offsets.push(offset);
// 如果收到"checkpoint N 已完成"的通知
if let Some(cp) = self.checkpoint_notifier.poll() {
// 这时候才能 ack:因为 checkpoint 里已经包含了
// "处理到这个 offset 时的状态"
let upto = self.offsets_covered_by(cp);
self.queue.ack_upto(upto).await?;
self.pending_offsets.retain(|o| *o > upto);
}
}
}
}恢复路径完全自洽:
崩溃 → 加载上一个完整 checkpoint → 状态回到 offset = 1000 时的样子
→ 队列里 offset > 1000 的数据还在(因为没被 ack)
→ 从 1001 重新消费 → 状态继续往前推
→ 结果正确注意"source 的 offset 也是状态的一部分"。 因为它必须和算子状态在同一个 checkpoint 里被保存——否则就会出现"算子状态回到了 1000,但 source 以为自己在 2000"。
端到端"恰好一次"的三个条件
这条链能不能成立,取决于三个条件,缺一个就退化成至少一次:
| 条件 | 谁提供 | 缺了会怎样 |
|---|---|---|
| 队列支持按 offset 重放(且不自动删除) | 消息队列 | 只能 at-most-once |
| 状态支持一致性快照 + 恢复 | checkpoint 机制 | 状态回退但数据已 ack → 丢数据 |
| Sink 是幂等的,或者支持两阶段提交 | 外部存储 | 结果重复写入 |
第三项是最容易被忽略的。 状态可以回退重算,但**"写出去的结果"没法回退**:
// 如果 sink 是"追加",重放会写入重复数据
sink.append(record)?;
// 所以 sink 要么是 upsert(按 key 覆盖)
sink.upsert(key, record)?;
// 要么支持事务(checkpoint 完成时才提交)
let txn = sink.begin_transaction()?;
txn.write(record)?;
// 等 checkpoint 完成
txn.commit()?;"恰好一次"从来不是某个组件的性质,而是"可重放 + 可快照 + 可幂等"三个性质组合出来的结果。 所以当有人问"你这个系统是不是恰好一次",正确的回答是反问:"从哪到哪?两端的存储各是什么?" ——没有限定范围的"恰好一次"是没有意义的。
第七步:反压——它是可观测性的第一信号
前面提到对齐会阻塞、阻塞会传导。反压的机制本身很简单,但它的观测价值被严重低估了。
pub struct Channel {
/// ★ 有界队列:这是反压能被表达的前提
inner: mpsc::Sender<Record>,
capacity: usize,
}
impl Channel {
pub fn send(&self, record: Record) -> Result<(), Backpressure> {
// 非阻塞发送:满了就明确返回"我承受不住了"
self.inner.try_send(record).map_err(|_| Backpressure::Full)
}
/// 水位:当前占用 / 容量 —— 这个数字必须被上报
pub fn usage(&self) -> f64 {
self.inner.len() as f64 / self.capacity as f64
}
}为什么"有界"是必须的? 因为无界队列会把"下游跟不上"这个事实推迟到一个不可观测的时刻——队列一直涨,直到 OOM。而 OOM 的时候,你已经看不到"是谁慢了"。
反压链的诊断价值在于:每个环节的队列水位,直接指出瓶颈在哪。
Source 队列 算子 A 队列 算子 B 队列 算子 C 队列
100% ────→ 100% ────→ 100% ────→ 20%
↑ ↑
源头在拼命生产 这里消费得动
结论:瓶颈在算子 C 的下游(Sink),而不是 C 自己。
因为 C 的输入队列满、输出队列空 —— 说明 C 在处理,但下游接不住。四种水位的组合,对应四种完全不同的结论:
| Source 队列 | 中间队列 | Sink 队列 | 结论 |
|---|---|---|---|
| 满 | 满 | 满 | Sink 或外部存储是瓶颈 |
| 空 | 满 | 满 | 源头供不上(或 Source 在等 checkpoint) |
| 满 | 空 | 空 | 某个算子卡住了(死锁、或者对齐阻塞) |
| 满 | 满 | 空 | Sink 很快,中间算子是瓶颈 |
最后一种最容易误判成"Sink 没问题"——而实际上 Sink 队列空、上游队列满,说明 Sink 一直在满速工作,是它前面的那个算子算不过来。
反压不是错误状态,它是系统在说话。 一个"没有反压"的流处理作业通常意味着两件事之一:要么它在空转(没数据),要么它的队列是无界的(马上就要 OOM)。 所以"队列水位"应该是这类系统最先被接入监控的指标。
第八步:把它跑起来——一条完整的链路
把前面所有部件连起来,做一个真实的作业:
从消息队列读点击事件
→ 按 (site_id, 5 分钟滚动窗口) 计数
→ 水位线 +3 分钟容忍乱序
→ 写入时序库(按 key upsert)
配置:
checkpoint 间隔 30s
allowed_lateness 3min
状态后端 LSM(增量 checkpoint 到对象存储)
Sink 幂等 按 (site_id, window_start) upsert
队列 ack 时机 checkpoint 完成后pub fn build_job(queue: Queue, tsdb: TimeSeriesDb) -> Result<JobGraph> {
let source = Source::new(queue)
// checkpoint 完成才 ack —— 第六步的规则
.with_ack_mode(AckMode::OnCheckpointComplete);
let windowed = source
// 事件时间从报文里取,不是收到的时间
.assign_timestamps(|record| record.event_time)
// 水位线:最大已见时间 - 3 分钟,且要求单调
.with_watermark(WatermarkStrategy::bounded_out_of_orderness(
Duration::from_secs(180),
))
// 5 分钟滚动窗口
.window(TumblingWindow::new(Duration::from_secs(300)))
// 触发后允许迟到数据继续更新(第三步的 AllowLate)
.with_allowed_lateness(Duration::from_secs(180))
// 状态放 LSM,支持增量快照
.with_state_backend(LsmStateBackend::new("/var/lib/state")?)
// upsert 到时序库
.sink(TimeSeriesSink::new(tsdb));
Ok(JobGraph::new(windowed))
}这条链上每个参数都有明确的理由,而且它们互相约束:
| 参数 | 值 | 为什么是这个值 | 和谁耦合 |
|---|---|---|---|
| checkpoint 间隔 | 30s | 崩溃后最多重放 30 秒数据 | 重放成本、快照开销 |
| 乱序容忍 | 3min | 覆盖 99% 的正常延迟 | 输出延迟(水位线 = 最大时间 - 3min) |
| 窗口大小 | 5min | 业务要的统计粒度 | 状态量(窗口越多状态越大) |
| allowed_lateness | 3min | 窗口关闭后再等一个乱序窗口 | 状态持有时间、输出更新次数 |
| ack 时机 | checkpoint 后 | 恰好一次的必要条件 | 队列的保留策略 |
注意"输出延迟"这一栏:因为水位线 = 最大已见事件时间 - 乱序容忍,所以一个 5 分钟的窗口,实际输出时间大约是"窗口结束 + 3 分钟"。
窗口 [10:00, 10:05)
↓
最晚在 10:08 左右输出(= 窗口结束 + 乱序容忍,前提是有新数据持续到来)这个"延迟"不是实现问题,而是"正确性换来的必然代价"。 想让它更快,只能减小乱序容忍——而减小容忍就意味着一部分乱序数据会被算作迟到,结果会不准。
流处理作业的每一个参数,最终都在调同一个天平:结果的准确性 vs 结果的及时性。 而这个天平的两端都可以被量化:"容忍 3 分钟"意味着"延迟 3 分钟","精确到 99.9% 的数据"意味着"多余的部分会被丢弃"。 把这些数字写进配置的人,才真正理解这个作业在做什么。
结论
把消息队列、状态后端、checkpoint 拼起来之后,这个系统的形状是这样的:
┌─ 事件时间:唯一可重现的坐标
时间从哪来 ─────────┴─ 水位线:单调的、必然是错的进度估计
(多分区取最小值 + 空闲检测)
┌─ Output:可以多次
窗口的四个时刻 ─────┼─ AllowLate:继续接受迟到数据
├─ Evict:最后一次更新
└─ Purge:删状态,之后的数据直接丢
┌─ 状态在 LSM:能增量快照(不可变 SST 文件)
容错的三件套 ───────┼─ 屏障对齐:让所有算子停在同一逻辑时刻
└─ 提交点:元数据持久化之后才算有效
┌─ 队列可重放
恰好一次的三个条件 ──┼─ 状态可快照
└─ Sink 幂等或事务四条最值得记住的判断:
- 水位线只能前进。 一旦回退,已经输出的窗口会被重复触发,而状态可能已经被清理。
Output和Purge是两个不同的时刻。 合并它们,迟到的数据就无处可归——表现是概率性的数据丢失。- ack 必须在 checkpoint 完成之后。 这是"恰好一次"里唯一由你自己控制的那个环节。
- 有界队列是反压能被看见的前提。 无界队列把问题推迟到 OOM,而那时已经查不出原因。
这四条有一个共同的形状:它们都是"把某个模糊的意图变成一个有明确边界的状态"。 水位线把"数据到齐了吗"变成"一个单调的整数",checkpoint 把"状态一致吗"变成"一个提交点",有界队列把"下游跟得上吗"变成"一个水位百分比"。
下一篇换到"内容的标识"这个问题(版本控制系统),会看到另一种把模糊意图变清晰的方式:把"这份数据变了吗"变成"一个哈希"。