返回文章列表

用 Rust 从零搭一个流处理引擎:水位线决定"什么时候能出结果"

1076 字·8 分钟阅读
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 幂等或事务

四条最值得记住的判断:

  1. 水位线只能前进。 一旦回退,已经输出的窗口会被重复触发,而状态可能已经被清理。
  2. Output 和 Purge 是两个不同的时刻。 合并它们,迟到的数据就无处可归——表现是概率性的数据丢失。
  3. ack 必须在 checkpoint 完成之后。 这是"恰好一次"里唯一由你自己控制的那个环节。
  4. 有界队列是反压能被看见的前提。 无界队列把问题推迟到 OOM,而那时已经查不出原因。

这四条有一个共同的形状:它们都是"把某个模糊的意图变成一个有明确边界的状态"。 水位线把"数据到齐了吗"变成"一个单调的整数",checkpoint 把"状态一致吗"变成"一个提交点",有界队列把"下游跟得上吗"变成"一个水位百分比"。

下一篇换到"内容的标识"这个问题(版本控制系统),会看到另一种把模糊意图变清晰的方式:把"这份数据变了吗"变成"一个哈希"。