返回文章列表

把轮子装成车:决定系统能否跑起来的,是接口不是轮子

879 字·6 分钟阅读
Rust从零造轮子系统设计

前面用内存 SQL 引擎收尾的那篇,结论是"轮子是算法,是各种交换的集合"。

但把轮子装成车,做的事情完全不一样。 这个阶段没有引入任何新算法,全部工作量都花在"把零件拼起来时,接口必须重新定义"这件事上。

而写完回头看,真正反复出现的判断只有七条,而且一条都不是关于算法的。

一、先回顾:这些系统各自在回答什么

系统 组装了哪些轮子 那一道边界题
时序数据库 列存、WAL、向量化执行、位图 写入时编码 vs 查询时解码
向量检索服务 HNSW、布隆、LRU、对象池 标量过滤放在图搜索的哪一步
DNS 服务器 双数组 Trie、LRU、零拷贝 TTL 是"上限"还是"时长"
IM 系统 WebSocket、LSM、定时器 会话序号的分配权归谁
协同编辑服务 CRDT、WAL、一致性哈希 收敛 vs 顺序
流处理引擎 消息队列、LSM 状态后端、向量化 水位线决定"什么时候能出结果"
版本控制系统 Merkle Tree、哈希表、mmap 内容寻址为什么消灭失效逻辑
集群调度器 Raft、状态机、工作窃取 期望状态和实际状态之间隔着什么
对象存储服务 S3 签名、Merkle、一致性哈希 分块上传和校验和是同一件事
CDN 边缘节点 TinyLFU、一致性哈希、sendfile 缓存失效比缓存命中难
可观测后端 时序库、倒排索引、宽事件 三种信号为什么需要三种存储

这些系统的共同点是: 每一个都用到了三到四个前面写过的轮子,但没有一个能"直接把轮子搬过来用"。 每个轮子在换一个场景之后,接口都变了:

列存在 SQL 引擎里是"列的编码"
       在时序库 里变成"段的格式"          ← 因为它成了写入和查询之间的契约
 
CRDT 作为一个数据结构是"合并算法"
     在协同编辑服务里变成"幂等应用 + 版本向量"  ← 因为它要面对离线操作
 
LSM 作为一个存储引擎是"读写的 KV"
    在流处理里变成"可增量快照的状态后端"     ← 因为 checkpoint 是刚需

"接口变了"就是系统设计真正的工作量。 而下面七条,是这些系统里反复用到的判断。

二、把"不可变"推到最底层

这条原则出现了四次,每次的形式不同,效果一样:

系统 什么被做成不可变 消掉了什么
版本控制系统 所有对象(blob/tree/commit) 整个系统的并发问题收敛到一个 40 字节的引用上
对象存储 数据块 + 对象 副本冲突、"哪个副本是对的"这个问题不存在
时序数据库 落盘的段 写入路径无锁;保留期 = 删文件
协同编辑 每个操作(不可变的事件) 合并结果与顺序无关

它消掉的是同一类问题:

可变的共享数据 → 必须回答这些问题:
  ① 谁先写的?(顺序)
  ② 我读到的是最新的吗?(可见性)
  ③ 两个副本冲突时听谁的?(冲突解决)
  ④ 缓存里的还对吗?(失效)
  ⑤ 重试会重复吗?(幂等)
 
不可变数据 → 这些问题全部不存在,或者退化成"比较两个哈希"

而代价也非常一致:

① 永远不能原地修改 —— 改一个字节就是一个新对象
② 旧对象必须留着(否则历史断了)→ 需要 GC
③ 必须有额外的"命名层"给人用(ref、路径、文件名)→ 而这一层是可变的
④ 需要能负担"重算哈希"的成本

所以第三个代价暴露了这条原则的真正含义:

不可变不是"消灭了可变状态",而是"把可变状态压缩到一个尽可能小的边界里"。

版本控制系统:几百 GB 的对象是不可变的,可变的是 refs/heads/*
对象存储:    几百 PB 的块是不可变的,可变的是元数据里的索引
时序库:      所有段是不可变的,可变的是"段目录"和"内存表"
协同编辑:    所有操作是不可变的,可变的是"已见集合"和"房间的日志位置"

而这个"小边界"恰好就是你应该加锁、加 CAS、加事务的那一小块。 这就是为什么版本控制系统的整个并发设计可以浓缩成"怎么原子地更新一个引用"。

什么时候不能不可变

有四种情况,它们不是例外,而是有明确原因的:

情况 例子 原因
状态本身就是"当前位置" IM 的已读游标、调度器的期望状态 它的语义就是"现在是什么",做一个历史版本没有意义
高频变化 + 需要即时可见 CDN 的缓存条目 每次"修改"都产出一个新对象,成本高得没有收益
数据必须被聚合 指标的累加器 累加器是"多个输入合成一个输出",它本身没有身份
资源是稀缺且必须被占用的 对象存储的引用计数 计数减少不是"新建一个更小的计数",而是"改变一个状态"

判断标准可以写成一句话:

如果"修改这份数据"可以被表达成"新建一份 + 替换一个引用",就把它做成不可变。 如果不行(因为它的语义就是"当前位置",或者替换成本过高),就承认它是可变的,并且把它放到一个尽可能小的边界里。

三、位置必须用标识符,不能用序号

这条原则在协同编辑那篇里最明显,但它在好几个系统里都出现了:

✗ 用序号(下标): "在第 5 个字符处插入"
✓ 用标识符:       "在 id 为 X 的字符之后插入"

为什么?因为并发让序号失去意义:

初始:  "abc"
A 在位置 1 插入 'X'  →  "aXbc"
B 在位置 1 插入 'Y'  →  "aYbc"
 
位置 1 在两个操作产生的时候都指向 'a' 之后,
但合并的时候,"位置 1"到底指哪里,取决于你先应用了谁。
→ 序号在并发下是"过了期的坐标"

而其他系统里的同一件事:

系统 序号方案(错) 标识符方案(对)
协同编辑 第 5 个字符 字符的稳定 id
版本控制 第 3 个文件 内容哈希
IM 第 5 个会话 会话 id
对象存储 第 2 个副本 节点 id + 块哈希
日志 第 100 行 trace_id

这两者的区别可以用一句话说清:

序号是"某个时刻的一份快照",标识符是"一个持续的指称"。 并发场景需要后者,因为它不依赖"你什么时候看"。

推论:凡是"位置"会被并发引用的地方,都必须给被引用的东西一个稳定的身份。

// 这个结构在协同编辑里是"字符",
// 在版本控制里是"对象",在 IM 里是"会话"
struct Entity {
    /// ★ 稳定的身份 —— 由创建者分配,永不改变
    id: EntityId,
    /// 可能变化的内容 / 位置
    content: Content,
}

注意 id 是"由创建者分配"的。 这一点很关键——如果 id 由中心分配,那么"离线创建的实体"就没有 id,而它可能在离线期间就被其他操作引用了。这就是下一条原则的入口。

四、物理顺序和因果身份是两个不同的东西

这是我在这些系统里见过的、最容易合并、也最不能合并的一对概念。

协同编辑:  room_seq(服务端分配的物理位置)  vs  dot(客户端生成的因果身份)
IM:        会话序号(消息的位置)           vs  消息内容
流处理:    水位线(物理进度估计)            vs  事件时间(数据自己带的坐标)
可观测:    时间戳(物理到达/记录时间)       vs  trace_id(因果关联)
版本控制:  日志序号(物理追加顺序)          vs  对象哈希(内容身份)
流处理:    checkpoint 序号(物理)           vs  version vector(因果已见集合)

为什么它们不能合并?因为"事件产生的那一刻"和"事件被系统处理的那一刻"是两个不同的时刻,而前者往往发生在后者之前很久:

用户在飞机上编辑文档(离线 3 小时)
  → 操作产生的时刻:10:00(在这台设备本地)
  → 操作被服务端处理:13:00
 
在 10:00 那一刻,这个操作需要:
  ✓ 一个身份(否则本地无法判断"这两个操作是不是同一个")
  ✓ 一个因果位置(否则无法和别人的离线操作正确合并)
  ✗ 一个全局的物理序号 —— 因为它还没有到达任何中心
 
而在 13:00,它需要一个物理序号:
  ✓ 才能被持久化到日志、才能被补发给别人、才能被快照截断

所以分工是清晰的:

因果身份(dot / trace_id / version vector) 物理顺序(room_seq / 日志位置 / 水位线)
谁分配 事件产生者(客户端 / 各个服务) 中心(服务端 / coordinator)
何时有值 产生的那一刻就有 到达中心之后才有
唯一性范围 全局(靠 replica_id 等前缀保证) 单点内(单个房间 / 单个 coordinator)
用途 去重、因果判断、幂等 日志位置、补发、快照截断
能否离线获得 能 不能

而把所有"因果身份"和"物理顺序"混为一谈的系统,一定会在引入离线、异步或并发之后出问题。 而问题形式总是一样的:去重失效、或者补发漏数据。

这一条还有一个更尖锐的推论:

如果某个身份必须在"事件产生的那一刻"就确定,它就不能依赖任何中心化的分配。

// ✗ 依赖中心:离线时无法工作
let seq = server.allocate_seq()?;   // 离线的时候这一行就是死的
 
// ✓ 本地生成:离线时也能确定
let dot = Dot { replica: my_replica_id, counter: self.next_counter() };

这也是为什么"客户端生成的 uuid"在分布式系统里如此常见——它不是在"偷懒避免协调",而是在满足"身份必须在本地产生"这个硬约束。

五、快照必须能回答"我不包含什么"

这一条在所有需要"恢复"的系统里都出现过。

版本控制:  索引是"冻结的视图" —— 它明确知道自己包含哪些对象
对象存储:  multipart complete 的块列表 —— 明确知道包含哪些块、什么顺序
流处理:    checkpoint 的 barrier + 提交点 —— 屏障之前的都包含
协同编辑:  快照的 version vector —— 明确知道"我见过哪些 dot"
IM:        contiguous_until + gaps —— 明确知道"我连续收到了哪里、缺哪些"
时序库:    段的 min_time/max_time + 标签取值集合 —— 明确知道"我不覆盖哪段时间"

形式不同,但都被同一个问题逼出来的:

"恢复到某个状态"这个动作,需要一个起点。
而这个起点必须能回答两个问题:
  ① 我包含到哪了?
  ② 我不包含什么?
 
只回答第一个问题的"进度",是不安全的。

一个具体的例子(协同编辑那篇里最关键的判断):

✗ 用物理序号做快照边界:
  快照说"包含 seq 1..50"
  → 但 seq 30 因为因果依赖没满足,被放进了待定区,没被应用
  → 恢复时,你从 51 开始重放,seq 30 永远丢了
 
✓ 用版本向量做快照边界:
  快照说"我见过 replica A 的 1..20、replica B 的 1..15"
  → 恢复时,把没见过的都重放一遍
  → seq 30(属于 A 的第 21 个)会被重放 → 正确

核心区别在于: "我读到第 50 条日志"和"我处理完了前 50 条能处理的东西"是两件不同的事。

而这个区分有一个通用的形式:

一个进度如果能表达成"一个连续前缀 + 若干孤立集合",它就能安全地用作恢复起点。 如果它只能表达成一个数字,那么任何"跳过的、暂存的、失败的"部分都会永久丢失。

/// 这个形状在好几个系统里重复出现
pub struct Progress {
    /// 连续处理完的部分
    contiguous_until: u64,
    /// 已经见过但还没能处理的部分(因果未满足 / 依赖缺失 / 暂存区)
    pending: BTreeSet<u64>,
}

IM 的客户端状态、协同编辑的待定区、流处理的"因果未满足就绪队列"、Raft 的日志匹配位置——都是这个形状。

六、所有跨重试的动作必须幂等

"重试一定会发生"这句话在这个系列里出现了十几次。 而它推出的要求很硬:每个动作重复执行的结果必须和执行一次一样。

各个系统里"实现幂等"的手法不同,但可以归成三类:

手法 用在哪 关键点
天生幂等(写一个确定的值) 调度器改期望状态、DNS 写缓存 结果只依赖输入,不依赖历史
确定性的名字去重 调度器的 AlreadyExists、对象存储的内容寻址 名字由内容/位置算出,不随机
让"做过了"和"动作"在同一个原子操作里 对象存储的引用计数、IP 分配 把复合操作下沉到支持原子的那一层

而"确定性名字"那一条有一个非常漂亮的实例:

// ✗ 随机名字 → 永远不幂等
let name = format!("pod-{}", uuid::new_v4());
 
// ✓ 确定性名字 → 创建变成"确保存在"
let name = format!("{}-{}", deploy.name, index);
// 结果:AlreadyExists 不是错误,而是"已经做过了"的信号

把"创建"变成"确保存在",是幂等设计里最常用的一个转身。 因为这个转身之后,动作的语义从"做一件新事"变成了"确认一个状态"。

更重要的反面:什么情况下做不到幂等

有些动作天然不是幂等的,因为它们消耗了稀缺资源:

✗ 分配一个 IP
✗ 分配一个端口
✗ 发送一条通知
✗ 写入一个自增的序号

这些动作的幂等必须靠"把消耗和记录绑在一起"来实现:

// ✗ 错误:先算一个 IP,再写进去 —— 中间有窗口
let ip = pool.allocate()?;
store.set_ip(pod, ip)?;
// 崩在中间 → IP 泄漏,而且重启后会再分配一个
 
// ✓ 正确:让"选择"和"记录"在同一个原子操作里
store.compare_and_swap(key, NoIpAssigned, AssignNextIp)?;
// 存储自己选一个 IP 并写进去 —— 一次原子操作,没有窗口

这里有一条通用的接口设计原则:

如果两个动作必须一起发生,那就不要把它们暴露成两个接口。 把"需要原子性的复合操作"下沉到"支持原子的那一层"。

而这条原则在好几个系统里都出现过:

对象存储:   "写块" 和 "增加引用" 合成一个 apply(BlockChange)
协同编辑:   "分配 room_seq" 和 "写日志" 合成一个 append
IM:         "分配会话序号" 和 "写消息" 合成一个 WriteBatch
流处理:     "记录 source offset" 和 "快照状态" 在同一个 checkpoint 里

它们的共同点是:一旦两个动作分开,就必须发明一套机制来保证"要么都做要么都不做"——而把接口合并掉,这套机制就不需要了。

七、慢的算子要能被"提前退出"和"下推"

这条原则在这个系列里跨越了七篇,而且每次的形式都一样:让不需要的数据从来不被读取。

SQL 引擎:    列裁剪(不读 50 列里的 48 列)
              谓词下推(过滤在扫描时就做)
              TopN 堆(不排序全量,只维护 N 个)
 
时序库:      时间范围剪枝(不读不相交的段)
              标签取值剪枝(不读没有该标签值的段)
              位图过滤(不解码不满足条件的行)
 
日志/可观测: 时间分段(不扫描无关的时间段)
              倒排索引(先算候选位图,再取原文)
              Limit 下推(够了就停)
 
向量检索:    段级布隆排除
              Range 请求只读涉及的块
              两阶段检索(压缩空间粗排,只对候选精排)
 
对象存储:    按 offset 二分定位到块(O(log 块数))
              Range 读取不打整个对象
 
CDN:         命中就终止(不回源)
              内存层命中就不读磁盘
 
流处理:      状态按 key 前缀布局(范围扫描天然有序)
              增量 checkpoint(只记新增的 SST 文件)

这张表里所有优化的收益都可以用一句话概括:

如果一个优化减少的是"被读取的字节数 / 被访问的内存位置数",它的收益是量级的(10 倍、100 倍)。 如果它减少的只是"计算量",收益通常是常数倍(2 倍、3 倍)。

这就是为什么"下推"和"剪枝"比"把循环写得更快"重要得多。 前者改变的是 IO 和内存访问量,后者只改变算术指令数——而现代的 CPU,算术从来不是瓶颈。

而这条原则的推论是:元数据必须"写的时候顺手记上",因为剪枝完全依赖它。

时序库的段要记 min_time / max_time / 标签取值集合
日志的段要记时间范围
对象存储的 part 要记 offset / len
倒排索引要记 term → 位图
checkpoint 要记"包含哪些 SST 文件"
 
这些都是"写的时候多花一点",换来"读的时候少扫一大片"。

代价在于:元数据本身也必须被维护。 段合并时要重算、对象移动时要保持一致、索引字段改了要重建。而"元数据和数据不同步"是这类系统里最常见的正确性问题——因为元数据错了不会崩,只会返回错误的结果或者漏掉数据。

八、反压必须能被表达,而且"丢什么"必须显式设计

这条原则的入口是"队列必须有界",但真正的问题在后面:满了之后丢什么。

IM:      队列满 → 断开这个连接(不丢消息)
          理由:丢消息没有恢复路径,断连有(重连后按 seq 补齐)
 
调度器:  队列满 → 丢弃事件
          理由:事件只是触发信号,下次观察会重新发现同一个差距
 
可观测:  队列满 → 丢弃日志(但错误日志永不丢)
          理由:日志是可采样的,而错误日志的价值最高
 
流处理:  队列满 → 阻塞上游(反压)
          理由:数据不能丢,宁可慢也不能错
 
CDN:     缓存失效瞬间 → 合并回源请求
          理由:把"同时到达的相同请求"聚成一个

同一个问题(队列满了),五个系统给出了五个不同的答案。 而每个答案的依据都是同一个问题:

这份数据丢了之后,有没有一条路径能把它找回来?

系统 丢了能找回来吗 所以
IM 的消息 ✗ 不能 绝不能丢 → 断连
调度器的事件 ✓ 能(重新观察) 可以丢 → 队列满就丢
可观测的日志 ✗ 不能(但它可以一开始就不采集) 分级丢 → 错误不丢
流处理的数据 ✗ 不能(但可以回退重放) 阻塞 → 反压
CDN 的请求 ✓ 能(客户端会重试) 合并 + 让它等

"能不能找回来"这个判据,决定了整个限流/降级/丢弃策略的形状。

而反压的第二个价值是"它是系统在说话":

Source 队列    算子 A 队列    算子 B 队列    Sink 队列
  100%  ────→   100%  ────→    100%  ────→   20%
                                                ↑
                                    瓶颈在这里的下游
 
  满    ────→   满    ────→    空    ────→   空
                              ↑
                    这个算子卡住了(不是它慢,是它前面的对齐在等)

队列水位是这类系统最先该接入监控的指标,因为它把"谁慢了"这个问题变成一个可以看图回答的问题。

而无界队列的后果必须说清楚:它把"下游跟不上"这个事实推迟到一个不可观测的时刻——直到 OOM。而 OOM 的时候,你已经看不到是谁慢了。

九、诚实一点:哪些轮子其实没怎么用上

前面写过的那些轮子里,有几个装成系统之后几乎没出现。

轮子 装成系统时用到了吗
无锁队列 几乎没用 —— IM 的连接写队列用 mpsc 就够了
手写 SIMD 没用 —— 编译器自动向量化在批处理循环上够用
迷你 tokio / 协程调度 完全没用 —— 全部构建在 tokio 之上
分配器 / 对象池 只在"每请求分配"的热路径上用过一次
布隆过滤器 只在两处用上,而且都是"段级粗排"
跳表 只在我需要"有序 + 并发读"的地方提过,实际用了 BTreeMap
工作窃取 调度器里用到了,但只是"分片 + 窃取"这一小块

这个观察比前面七条原则更有价值:

会写一个轮子,和知道"什么时候不该用这个轮子",是两种不同的能力。 而后者才是真正决定系统能不能跑起来的那个。

无锁队列是最典型的例子:

写无锁队列的时候,你在解决:
  "多个线程高频竞争同一段内存,怎么避免锁的开销"
 
而在一个 IM 连接写队列的场景里:
  每个连接一个队列 → 竞争极低(一个生产者任务)
  瓶颈在网络 IO → 队列本身的开销可以忽略
  → 用 mpsc 更简单、更好调试、还自带背压语义
 
引入无锁队列的唯一理由是"测出来锁是瓶颈"。
没测出来就引入,等于用"更高的调试成本"换"想象出来的性能"。

同样地,"迷你 tokio"那篇的价值在于理解 Reactor / Waker 在干什么,而不在于"你的项目应该自己写一个运行时"。 理解机制和替换实现是两回事。

十、一份可以拿去用的检查清单

把前面七条原则翻译成问题,就是设计一个新系统时该问的:

【不可变性】
① 这个系统里,哪些数据可以是不可变的?
   可变的那些在哪里?边界能不能再小一点?
② 如果我把"修改"表达成"新建 + 替换引用",成本可以接受吗?
 
【身份与位置】
③ 有没有会被并发引用的"位置"?
   它用的是序号还是标识符?
④ 有没有一个身份必须在"事件产生的那一刻"就确定?
   如果它依赖中心分配,那离线/异步时会怎样?
 
【物理与因果】
⑤ 有哪些"物理顺序"(日志位置、水位线、时间戳)?
   有哪些"因果身份"(内容哈希、dot、trace_id、版本向量)?
   如果它们被合并成了一个量,会不会在离线/并发下失效?
 
【恢复边界】
⑥ 恢复的起点是什么?它能回答"我不包含什么"吗?
   还是只能回答"我读到哪了"?
 
【幂等】
⑦ 每个跨网络的动作,重复执行安全吗?
   如果两个动作必须一起发生,它们的接口是不是分开的?
 
【读取效率】
⑧ 慢路径上有没有"完全不需要读的数据"?
   有没有元数据(写时记的)能让它被剪掉?
 
【背压与丢弃】
⑨ 队列满了、下游挂了,丢的是什么?
   丢了之后,有没有一条路径能把它找回来?
 
【可观测】
⑩ 出事的时候,能从一个指标点跳到一条具体的链路、再跳到它的日志吗?
   这个跳转依赖的 id,是在写入时就被记录下来的吗?

十个问题里,只有第 ⑧ 条是关于性能的,剩下九条全部是关于"状态、身份、边界、顺序"。

这个比例本身就是这个系列的结论。

结论

这个阶段里没有出现任何一个新算法。

没有新的排序算法
没有新的图算法
没有新的压缩算法
没有新的共识算法

所有的难度都来自同一件事:把两个本来独立的东西接起来的时候,接口要重新定义。

把列存接到查询上     → 段格式成了契约(编码必须在写入时决定)
把 CRDT 接到服务上   → 需要版本向量(快照必须能说"我不含什么")
把 LSM 接到流处理上  → 需要增量快照(不可变文件才是关键)
把缓存接到源站上     → 需要回源合并(否则失效瞬间打垮源站)
把链路接到日志上     → 需要写入时就留下 trace_id

每一次"接起来",都会暴露出一个单看零件时看不见的约束。

这也是这个系列从上一段("怎么造轮子")推进到这一段("怎么把轮子装成车")的意义:

轮子的价值在于它能被复用; 而系统的价值在于它的接口能否让复用不发生冲突。

造轮子教的是"这个数据结构怎么实现"。 把它们装成车之后想说的是"它的边界在哪里,以及当它和别的东西接起来时,那个边界会怎么变。"

如果只记一句话,我希望是这一句:

系统设计的大部分工作量,不是"选一个更好的算法",而是"定义一个更准确的接口"。

而一个接口是否准确,唯一的判据是:它有没有把"现实中真的会发生的那些情况"都表达出来——离线的操作、乱序的事件、失败的重试、满掉的队列、残缺的采样、回退的时间。

这些情况都不会在演示里出现。它们只在真实环境里出现。而系统的质量,就是在它们出现的时候被决定的。