把轮子装成车:决定系统能否跑起来的,是接口不是轮子
前面用内存 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每一次"接起来",都会暴露出一个单看零件时看不见的约束。
这也是这个系列从上一段("怎么造轮子")推进到这一段("怎么把轮子装成车")的意义:
轮子的价值在于它能被复用; 而系统的价值在于它的接口能否让复用不发生冲突。
造轮子教的是"这个数据结构怎么实现"。 把它们装成车之后想说的是"它的边界在哪里,以及当它和别的东西接起来时,那个边界会怎么变。"
如果只记一句话,我希望是这一句:
系统设计的大部分工作量,不是"选一个更好的算法",而是"定义一个更准确的接口"。
而一个接口是否准确,唯一的判据是:它有没有把"现实中真的会发生的那些情况"都表达出来——离线的操作、乱序的事件、失败的重试、满掉的队列、残缺的采样、回退的时间。
这些情况都不会在演示里出现。它们只在真实环境里出现。而系统的质量,就是在它们出现的时候被决定的。