《Kubernetes 分布式系统原理深入解析》2.2 一致性模型谱系:线性、顺序、因果与最终

一致性模型是对「读到什么」的一组承诺,从强到弱排成一条谱系:线性一致、顺序一致、因果一致、读己之写/单调读、最终一致。本节逐个给出定义与读写时序例子,再把每一档落到 K8s 的真实路径上——etcd 的线性一致读与可串行化读、apiserver 的 resourceVersion 与 list-watch 事件流、informer 缓存与 kubelet 期望状态。lab 用 consistency 包的 Simulator 验证线性一致读必见最新、最终一致有读旧窗口且随后收敛。

2.2 一致性模型谱系:线性、顺序、因果与最终

2.1 节用 CAP 拆掉了「既要一致又要可用」的幻觉,但「一致」这个词本身还太粗。etcd 说自己是分布式 KV,K8s 文档说 informer 缓存「最终一致」,而 apiserver 的写又必须严格有序——它们承诺的强度根本不是一回事。本节把一致性模型展开成一条从强到弱的谱系:逐个给出定义、读写时序例子、K8s 落点,最后给一个选档的判断框架。

一句话结论:一致性模型是对「读到什么」的一组承诺。承诺越强,实现越贵;承诺越弱,客户端越需要自己做功课。理解这条谱系,你才能看懂为什么 etcd 要分两种读、为什么 apiserver 敢让 informer 缓存滞后、为什么 kubelet 可以按自己的节奏收敛。

先约定记号,后面所有例子都复用:W(x, v1) 表示写键 x 为值 v1,R(x) → v1 表示读 x 得到 v1,t=3 表示墙钟时刻,‖ 表示两个操作并发。

谱系全景:从强到弱的五档

一致性模型通常按「读的可见性保证」从强到弱排成五档:

档位一句话承诺关键性质放松了上一档的什么
线性一致(linearizability)全局实时串行,读写在它上面像单机写完成后任意副本的后续读必见最新—(最强)
顺序一致(sequential consistency)存在一个全局串行,但不承诺实时序可读旧,但仍可解释为某个合法串行放松「实时」
因果一致(causal consistency)happens-before 保持;并发可乱序因果依赖不颠倒;无关写可任意顺序放松「全局单一串行」
读己之写 / 单调读写者见自己写;读不回退只约束「我」与单点的可见性放松「对所有进程生效」
最终一致(eventual consistency)无实时保证;副本异步传播、最终收敛有读旧窗口;窗口由传播延迟决定放松「收敛之前的约束」

注意两个事实。第一,这五档不是五种孤立模型,而是一条连续谱,每一档都放松上一档的某个约束,逐级退让。第二,越强的档位越靠「给全局一个单一解释」:线性一致与顺序一致都要求全体进程看到一个共同的串行历史,只是前者多了「必须尊重实时序」;因果一致往下就不再要求全局单一串行,只要求因果不颠倒。下面逐个拆开。

线性一致:全局实时串行

定义。linearizability 要求所有读写操作可以按某个顺序排列,且这个顺序同时满足两点:

  1. 与实时序一致——如果一个操作在实时时间上完成后,另一个操作才开始,前者必须排在后者之前;
  2. 每个读返回它前面最后一次写的值。

等价地说,读写在任意副本上表现得如同在一台单机上按某种顺序瞬间执行。Herlihy 与 Wing 在 1990 年给出这个定义时用了一个更形象的说法:每个操作在「调用」与「返回」之间的某个时刻看起来瞬间生效(linearization point)。

直观例子。两个客户端交替操作:

t=1  A: W(x, v1) 返回成功
t=2  B: R(x) → v1        ✔ 允许
t=3  A: W(x, v2) 返回成功
t=4  B: R(x) → v2        ✔ 允许
t=5  B: R(x) → v1        ✘ 违反线性一致

最后一行的反例是关键:v2 在 t=3 已经提交并返回,t=5 的读发生在它之后,必须见到 v2。即使 v2 尚未传播到 B 所在的副本,线性一致也拒绝让你读到 v1。这就是它与其他模型的分水岭:拒绝读旧。

再强调一次「实时」二字的分量。它要求读写的顺序尊重物理时间上的先后,而分布式系统里恰好拿不到可信的物理时间(第 3 章会展开墙钟漂移问题)。因此线性一致实现不能靠时间戳排序,必须靠协议:在 Raft 里就是「读也要过 quorum」。

K8s 落点。etcd 的线性一致读(linearizable read)就是这一档的工程实现。它不直接返回节点本地状态,而是先通过 Raft 拿到一个「不小于任何已提交写」的读索引(read index),再在多数节点确认后才能读,确保返回值不落后于已提交状态。K8s 把全部集群状态押在 etcd 上,凡是需要「绝对最新」的路径——例如 apiserver 建立 watch 时确定起始 revision、控制器在关键决策前读状态——都必须走线性一致读。代价是每次读也要一次 quorum 往返,这正是 2.3 节讨论的成本。

顺序一致:全局串行但可违背实时序

定义。sequential consistency 只要求:所有进程看到的操作存在一个共同的全局串行顺序,但不要求这个顺序与实时时间一致。Lamport(1979)的定义是:执行结果等于「所有进程按某个顺序依次执行」的结果,且每个进程内部的操作顺序保持不变。

直观例子。副本 A 已经应用了 W(x, v2),副本 B 尚未收到:

t=1  A: W(x, v1) 返回(副本1 已应用)
t=2  A: W(x, v2) 返回(副本1 已应用)
t=3  B(副本2): R(x) → v1   ✔ 顺序一致允许

从实时看,B 的读发生在 v2 提交之后;但存在一个合法全局串行解释「B 的读排在 v2 之前」,所以顺序一致认为它没问题。线性一致则会判它违规。

两种模型的分界就一句话:顺序一致只要求「存在」一个全体一致的串行顺序;线性一致额外要求这个顺序尊重实时序。前者是后者的真子集——凡是线性一致的历史也必然是顺序一致的,反之不成立。

K8s 落点。etcd 的可串行化读(serializable read)是这一档的工程实现:读直接命中任意节点内存中的状态机快照,不做 quorum 确认,因此快很多,但可能读到稍旧的值。etcd 客户端对「读旧几毫秒」不敏感的路径会走它。apiserver 的对象版本机制也体现同一思想:resourceVersion 是一个随 etcd mvcc revision 全局单调的整数,读到的对象版本可能不是最新,但版本号来自唯一序列、不会乱,因此下游可以安全地按版本比较新旧。

因果一致:happens-before 保持,并发可乱序

定义。causal consistency 用 happens-before 关系约束可见性:如果操作 a 因果先于 b(a happens-before b,记为 a → b),那么任何看到 b 的进程也必须已经看到 a;而互不相关的并发操作,允许在不同进程上以不同顺序出现。直观说:因果相关的写不能颠倒,因果无关的写随意。

happens-before 的严格定义来自 Lamport(1978):若 a、b 是同一进程内的先后事件,或 b 依赖 a 发送的消息,则 a → b;→ 关系可传递。它与墙钟无关,只与「谁看到了谁」有关——这一点到第 3 章会反复使用。

直观例子。动态流场景:

A: W(帖子 P) 发布
B: 看到 P 后 W(评论 C)         C 因果依赖 P
任何看到 C 的进程必须也能看到 P     ✔ 否则出现「没有帖子的评论」
D: W(独立帖子 Q) ‖ E: W(独立帖子 R)  → 二者并发,可任意顺序

两个互不相关的用户各自发帖,不同用户看到两者的顺序可以不同——这无关紧要,因为不存在因果依赖。而「评论依赖帖子」这类因果链一旦颠倒,用户就会看到语义上不可能出现的内容。

K8s 落点。apiserver 的 list-watch 事件流天然是因果的:同一个对象的事件带递增的 resourceVersion,watch 客户端先收到版本 5 的事件,绝不会在之后收到同一对象的版本 3 事件——这是 K8s 里因果性的骨架。控制器的因果依赖也靠这一档兜底:例如 ReplicaSet 控制器必须先观察到 Deployment 的 spec 更新,才创建新的 ReplicaSet 与 Pod;若顺序颠倒,控制器会基于过期的期望状态做决策。informer 缓存读旧时,「看到了新 Pod 却还没看到它的 owner ReplicaSet」就是一个因果窗口,靠下一轮调谐收敛。

读己之写与单调读:最常用的弱承诺

再往弱走,约束对象从「所有进程」缩小到「我自己」。这一档是实践中最常见、也最容易被忽视的承诺。

  • 读己之写(read-your-writes):客户端在写入成功后,一定能在后续读到自己的写入。
  • 单调读(monotonic reads):客户端一旦读到某个值,后续读不会回退到更旧的值。

直观例子。用户在留言板发评论,提交后刷新页面必须看到自己的评论(读己之写);用户看到了某条记录的版本 2,刷新后不能变回版本 1(单调读)。这两个承诺都不约束「别的用户」看到什么,也不约束两个不同客户端之间的可见性——正是这种「只对我生效」的弱性质,让实现可以非常廉价。

K8s 落点。三个具体体现:

  • apiserver 的 create 响应直接返回创建出的对象(带新 resourceVersion),客户端无需再读一遍就能拿到自己刚写的东西——读己之写的便利实现。
  • kubelet 写回 status后,本地缓存必须能看到这次写入,否则会出现「自己写的 status 自己读不到」的荒谬状态。
  • informer 的分页 relist通过 resourceVersion 续传,保证缓存版本不倒退——单调读。如果 relist 从旧版本重新开始,等于把缓存回退了,下游控制器会基于过期数据重复工作。

最终一致:副本收敛,读旧窗口

定义。eventual consistency 不给任何实时承诺:写由各副本异步传播,一段时间内读到旧值完全正常;系统只保证「如果停止写入,所有副本最终收敛到相同状态」。收敛速度由传播延迟决定——这正是 lab 里 SetPropagation 参数的含义:传播延迟越大,读旧窗口越大。

直观例子。DNS 是每个人每天都在用的最终一致:一条记录更新后,全球解析器需要几分钟到几小时才全部看到新值,期间读到旧 IP 完全正常。读旧不是 bug,而是这一档一致性的定价。

K8s 落点。informer 的本地缓存与 etcd 之间的滞后就是最终一致:控制器读到的对象可能比 etcd 里旧几百毫秒甚至几秒(取决于 watch 断线重连的退避与 relist 周期)。K8s 的设计哲学是用「声明式期望 + 负反馈调谐」吸收这个窗口——读到旧状态就多调谐一轮,写回时以最新状态为准,系统最终收敛。kubelet 的本地期望状态同理:它把 spec 缓存下来,按自己的节奏向实际状态收敛,而不是每读必新。

谱系在 K8s 中的落点总览

把前面每一档的落点收拢成一张表,你可以把它当作整卷书的「一致性地图」:

K8s 路径实际档位一句话解释
etcd 写(Raft 提交)线性一致集群状态唯一权威,冲突必须全局定序
etcd 线性一致读(默认读索引)线性一致需要绝对最新,读也过 quorum
etcd 可串行化读顺序一致直接读状态机快照,低延迟、可读旧
apiserver resourceVersion逻辑序(因果骨架)版本号全局单调,为下游提供比较基准
list-watch 事件流因果一致同对象事件版本递增,因果不颠倒
informer 缓存 → 控制器最终一致本地缓存加速,声明式调谐收敛
kubelet 本地期望状态读己之写 + 最终一致本地缓存,主动 relist 修正

注意一个反直觉但极其重要的事实:同一套 K8s 里同时存在线性一致与最终一致,它们服务于不同路径,互不冲突。etcd 的写严格线性一致,保证谁都不会把状态搞乱;读取路径大量走缓存,把「读旧」当作性能换来的成本。分层选档,正是 2.3 节的主题。

如何选择:判断框架

选哪一档,本质是回答四个问题。K8s 自己的选择就是这套框架的最好样板:

问题强一致倾向弱一致倾向
冲突写入多吗?冲突的代价高吗?线性一致(全局定序)最终一致 + 合并语义
读旧值的后果严重吗?强(写后读必须最新)弱(展示型数据可旧)
网络分区时必须继续服务吗?弱(保一致则牺牲可用)强(AP,各自可用)
操作可复算 / 可幂等重放吗?不需要,写必须一次定序可以,读旧靠重试收敛

落到 K8s 的分层选档是三步:

  1. 写路径永远线性一致。状态不能乱,任何两笔写都必须有全局唯一顺序——这是 etcd 存在的理由。
  2. 读路径按容忍度降档。能接受读旧就走缓存(informer、kubelet),不能接受就走线性一致读(watch 初始化、关键读)。
  3. 失败路径用幂等重放吸收。控制器收到旧状态不 panic,而是再调谐一轮;kubelet 收到旧 spec 就再比对一次实际状态。读旧不是错误,是收敛的起点。

本节 lab

lab 在 private/labs/k8s-etcd-lab/consistency/,请先读 models_test.go 再运行。两个用例正好钉住谱系的两端:

  • TestLinearizableReadLatest:用 3 副本 Linearizable 仿真器,t=1 写 x=v1、t=2 写 x=v2;随后任意未分区副本在 t=2 读 x 都必须返回 v2(线性一致读必见最新),并且另一个副本也读到同一值(全局单一历史)。
  • TestEventualStaleReadWindow:用 3 副本 Eventual 仿真器,给副本 0 设传播延迟 5 tick;t=2 写 x=v2 后,t=3 读仍可能得到旧值(读旧窗口),t=100 传播完成后收敛到 v2。

实现上,可见性由 models.go 的 visibleUpper 决定:Linearizable 模型直接取整个写历史的上界(写立即全局可见);其他模型按「本地写立即可见、远程写需等 propagation 延迟」逐条回溯历史。读旧窗口的宽度恰好等于 propagation 的值——这个参数是理解 2.3 节成本模型的关键:读越靠近写时刻越可能命中旧值,越远离越可能命中新值,SetPropagation 就是给这个窗口定价的旋钮。

运行(只跑这两个用例):

cd private/labs/k8s-etcd-lab
go test ./consistency -run 'TestLinearizableReadLatest|TestEventualStaleReadWindow' -v

预期 ok。两个用例的对比就是本节谱系两端的浓缩:线性一致没有读旧窗口,最终一致的读旧窗口由传播延迟决定——2.3 节会把这段「延迟」换算成可复算的毫秒成本。

继续阅读

探索更多技术文章

浏览归档,发现更多关于系统设计、工具链和工程实践的内容。

全部文章 返回首页

「books」更多文章

  1. 《大规模分布式计算深入解析》15.3 落地:从 Neo4j 到自研图引擎
  2. 《大规模分布式计算深入解析·图计算与图数据库内核》 · 目录与学习路径(45 篇)
  3. 《大规模分布式计算深入解析》15.2 十一卷主线:从切分到图