《Kubernetes 分布式系统原理深入解析》12.2 乐观并发:CAS、Txn 与 fencing token

乐观并发不提前加锁,冲突在提交时检测:etcd 事务用 mod_revision 比较实现 K8s 的 resourceVersion 乐观锁,租约续约时的 checkpoint token 作为 fencing token 拦住陈旧写者。lab 验证事务原子 If/Then、并发写 409 冲突与陈旧 token 失效。

12.2 乐观并发:CAS、Txn 与 fencing token

12.1 节建立了 revision 与版本树的模型:每次写推进全局主 revision,每个 key 的版本链可回溯。本节在这个模型上做并发控制——不提前加锁,而是在写入时校验版本,冲突则失败。这就是乐观并发(optimistic concurrency)的核心:把「冲突检测」从入口挪到提交点。K8s 的 resourceVersion 乐观锁、etcd 的 If/Then 事务、以及防「死去的领导」的 fencing token,都建立在这一个模型上。

乐观并发 vs 悲观锁

先看两种并发控制策略的分工:

策略加锁时机冲突检测时机典型实现
悲观锁进入临界区前入口,冲突者等待数据库行锁、分布式锁
乐观并发不加锁提交时,冲突者失败重试etcd Txn、CAS、K8s Update

悲观锁的优点是提交时几乎没有冲突:谁能进临界区在入口已经裁定。代价是锁等待、死锁、锁粒度难以权衡,以及持锁进程故障时锁的释放难题。乐观并发反过来:不加锁、无等待、无死锁,冲突在提交那一刻一次性暴露,代价是冲突率高时重试放大。

K8s 为什么选乐观并发而不是给每个对象加锁?三个原因:

  1. apiserver 无状态:多个 apiserver 实例同时服务,任何实例都可能收到同一对象的写,分布式加锁会把「写」串成一个全局瓶颈;
  2. 冲突率天然低:不同对象之间互不干扰,同一对象的高频并发写集中在少量热点(如 Deployment status),多数更新互不冲突;
  3. 重试成本低且机制成熟:控制器本就是周期调谐,冲突后重读重试一次即可收敛,比加锁的排队等待更简单。

悲观锁在 K8s 里并非没有位置——选主就是它的变体:用 Lease 对象互斥「谁当 leader」,同一时刻只有一个持有者。但对象数据的日常更新走的是乐观路径。

一个直观的冲突率估算能说明这个选择是否划算。假设 5 个控制器共同调谐同一批 Deployment,每次调谐对同一对象更新的频率是每秒 1 次、对象总数 1000,那么任意两次更新撞上同一对象同一版本的概率极低——乐观锁在绝大多数提交上一次成功,只有极端热点(单个对象被两个控制器疯狂交替改)才会频繁 409。反观悲观锁,为了覆盖那一点点冲突率,每个写都要先竞争一把锁,正常路径反而更慢。乐观并发的本质是「把罕见的冲突留给罕见的路径」。

这个选择还有一个隐性的架构红利:乐观锁让 apiserver 不必维护任何「锁状态」。锁若放在 apiserver 内存里,实例间需要同步;放在 etcd 里,每个写都要额外一次加锁事务。乐观锁把状态收敛到「对象自己的版本号」,写路径上没有任何全局锁——这是 K8s 控制面能横向扩展 apiserver 的底层原因之一。

etcd 事务模型:If/Then/Else

etcd 的写事务是 If/Then/Else 三段式,对应 gRPC 的 TxnRequest:

段字段内容作用
Ifcompare若干前置条件全部满足才继续
Thensuccess若干写操作条件满足时执行
Elsefailure若干写操作条件不满足时执行

If 里的每条 compare 是一个断言,两种常见类型:value(key)(当前值等于什么)与 mod(key)(当前 mod_revision 等于什么)。lab 的 Cmp 结构正是这两个类型:CmpModRev 比较 mod_revision,CmpValue 比较字面值。

原子性是怎么保证的?compare 与 apply 之间没有窗口——etcd 把 If 检查与 Then 写入放在同一个 mvcc 事务里提交,要么全部生效、要么整体跳过。lab 的 Txn 用一把互斥锁模拟这个原子区:所有 Cmp 通过后才逐条执行 ops,任何一条不满足就返回 succeeded=false 且不产生任何写,主 revision 保持不变。

举一个多条件组合的例子:Txn(if: [cfg 的 mod = 5, pod 存在], then: [更新 cfg, 更新 pod])——只有两个条件同时成立才提交,否则整体跳过。这种「跨 key 的条件写」是悲观锁很难优雅表达的场景:锁两个 key 的顺序、锁的覆盖范围都要额外设计,而 If/Then 天然就是原子描述。

真实 etcd 的 Txn 还有一个属性值得注意:它把「读、比较、写」压缩成一个往返。在没有 If/Then 的 KV 上实现「仅当条件满足才写」,需要先读、再判、再写,三步之间天然有窗口;If/Then 把这个窗口关掉了。K8s 里很多「比较并设置」的原子操作(例如 LeaderElectionRecord 的过渡、Quota 的消耗检查)都依赖这种「一读一判一写」的原子性。

命令行侧也能看到同样的三段式。etcdctl txn 交互时先输入 If 的 compare(value(k) = v 或 mod(k) = n),再输入 Then 的 put,最后输入 Else 的操作,以空行分隔。这个交互式流程把「If/Then/Else」暴露得最直白,适合手写验证事务行为。

lab 的 Txn 返回 (succeeded, rev) 二元组:succeeded 表示 If 是否全部满足,rev 表示事务执行后的主 revision。失败时 rev 就是事务开始时的当前 revision——因为没有发生任何写,主 revision 不前进。这个返回设计刻意保留了「失败不影响全局序号」的语义,与 12.1 的「只有写推进 revision」互相印证。

mod_revision 比较:resourceVersion 乐观锁的底层

第 12.1 节讲过,Get 返回的值附带 mod_revision。把这个 mod_revision 暴露到 API 表面,就是 K8s 对象的 resourceVersion。乐观锁的完整闭环:

  1. 客户端 Get 对象,读到 metadata.resourceVersion(底层就是 mod_revision);
  2. 客户端修改对象后 Update,把读到的 resourceVersion 一并带回;
  3. apiserver 落到底层就是一次 mod_revision 比较:key 当前 mod_revision 与客户端带来的一致 → 写入成功;不一致 → 返回 409 Conflict。

lab 的 TestTxnAtomicIfThen 把这段流程压缩成最小用例:先 Put("k", "v1")(rev1),基于 rev1 的 Txn(If k 的 mod = 1)更新为 v2 成功、k 到 rev2;随后另一个客户端仍基于过期的 rev1 发起 Txn(If mod = 1),条件不满足,整体跳过,k 保持 v2 不变。

为什么用 mod_revision 而不是值比较?因为 mod_revision 对任何写都递增,包括「写但值相同」的写。两个客户端先后把同一对象写成相同的内容,值比较发现不了并发(值一样),但 mod_revision 能发现——第二次写的版本已经前进,第一次的版本作废。用版本号做乐观锁,检测的是「是否有人在我读取之后写过」,与写的结果是否相同无关。

把 TestTxnAtomicIfThen 的两次事务展开成时序表,乐观锁的「成功一次、失败一次」看得最清楚:

时序客户端If(mod 期望)当前 mod结果k 的值
1Ak 的 mod = 11成功,写入 v2v2@2
2Bk 的 mod = 12(A 已写)失败,整体跳过v2(不变)

B 失败的原因不是值不对,而是版本号过期——它读到的是 A 写入前的世界。这正是 K8s 里 kubectl 收到 409 Conflict 时的内部景象:apiserver 用 mod_revision 比较发现了版本漂移。注意 B 的失败没有产生任何写,revision 也没有变化,这个「干净失败」是乐观锁区别于「部分写」的关键。

客户端收到 409 后的正确处理不是盲目重放同一份修改,而是重读最新版本、在最新版本上重新计算修改。盲目重放会放大冲突:两个客户端反复基于同一旧版本竞争,每次都以 409 结束。控制器的调谐循环天然符合「重读重算」——它每次循环都基于 informer 缓存的最新状态算 diff,再把 diff 应用到最新版本上。这也是为什么 K8s 把「冲突」设计成可重试的错误:重试路径与正常调谐路径是同一条。

CAS:字面值比较的语义

Compare-And-Swap(CAS)是乐观并发最原始的形式:只有当前值等于期望值才交换。lab 的 CAS(key, expect, value) 就做这件事——期望值不匹配则失败且不写。

CAS 的一个精妙点在于「创建」语义:key 不存在时当前值视为空串,所以 CAS("k", "", "v1") 表示「仅当 k 不存在时创建为 v1」。这对应 K8s 的 Create:对象不存在才允许创建,已存在则返回 AlreadyExists。而 K8s 的 Update 用的是另一个变体 CASModRev(key, expectRev, value)——期望的是 mod_revision 而不是值。lab 里 expectRev=0 表示「key 不存在」(mod_revision 视为 0),对应「仅当不存在才创建」的另一种写法。

TestCASAndCASModRev 展示了两个客户端基于同一版本竞争的完整时序:

客户端读到操作结果
Arev1CASModRev("k", 1, "client-a")成功,k 到 rev2
Brev1CASModRev("k", 1, "client-b")失败(409 语义),k 仍为 client-a

第二个客户端的写被整体拒绝且不产生任何 revision——这正是 K8s Update 冲突时 apiserver 返回 409、客户端重读重试的底层机制。注意失败写「不产生任何写」这一点很重要:乐观锁的失败不是写了一半,而是完全没有写,状态机不会因此污染。

CAS 有一个经典陷阱值得记录:ABA 问题。如果期望值是字面值(CmpValue),那么「值 A → 变成 B → 又变回 A」会让一个迟到的 CAS 误以为没人动过,因为当前值又等于期望值了。mod_revision 比较天然免疫 ABA——revision 单调递增,变回原值也会带着新的版本号,旧版本永远匹配不上。这是 K8s 选 mod_revision 而非值比较的又一个理由。

还要区分 CAS 与「无条件 Put」的语义差异。无条件 Put 覆盖一切、不检查旧值,对应 K8s 里不带 resourceVersion 的 Update——apiserver 对这类请求通常直接拒绝或要求显式说明(resourceVersion 缺失在多数资源上是校验错误)。带条件的写才是可控的:CAS 说「仅在预期值下改」,CASModRev 说「仅在预期版本下改」,两者的共同点是把「覆盖」变成「有条件覆盖」。

把三种写操作在 lab 与 K8s 之间的对应关系整理成表,便于查对:

lab 操作条件K8s 对应失败表现
Put无条件内部直接写路径(非 API Update)覆盖
CAS(key, expect, value)当前值 == expect值比较类条件写不写
CASModRev(key, rev, value)当前 mod_revision == revUpdate 带 resourceVersion409
Txn(ifs, ops)全部 compare 通过多条件原子操作整体跳过

这张表的最后一行「多条件原子操作」是 K8s 里很多自定义控制器落地「跨资源一致性」的抓手——单资源乐观锁只能覆盖一个 key,跨 key 的原子性必须靠 If/Then。

fencing token:租约、续约与陈旧写者

乐观锁防得住「两个活着的进程并发写同一版本」,但防不住「一个已失去授权进程的陈旧写」——它可能基于自己最后一次读到的版本写,而那个版本恰好还没被谁动过。这类写者常见于「死去的领导」:进程 A 曾持有领导权,因网络分区或 GC 停顿被误判死亡,新领导 B 接管;A 恢复后以为自己仍是领导,继续写数据。A 的写没有并发冲突(B 未必写了同一个键),但 A 已经不再被授权——这种问题乐观锁检测不到。

解法是 fencing token:授权方在每次续约(KeepAlive)时签发一个单调递增的 token;写者每次写都必须携带最新 token;存储侧校验 token 仍是当前最新才接受。陈旧写者携带的是旧 token,校验失败——无论它的版本号多新。

lab 的 lease 包把这个模型做了最小实现:Grant 时 token 初始化为租约 ID,每次 KeepAlive 让 token +1,Checkpoint 返回当前 token,ValidToken 校验一个 token 是否仍是最新。TestRevokeImmediateAndFencingToken 的时序:

步骤tokenValidToken 结果
Grant,取 tok01—
KeepAlive 两次,取 tok23tok2 = tok0 + 2
校验旧 token tok0—失败(fencing)
校验当前 token tok2—通过
Revoke 撤销—tok2 也失败

续约两次 token 前进 2,旧 token 无法通过校验;撤销后所有 token 一并失效。这防止了「已失去租约的领导」继续写入——它要么没有最新 token,要么租约已被撤销。

为什么 token 必须单调递增而不是用随机值?因为「陈旧」的判断需要大小关系:新授权的 token 必然大于旧授权的 token,校验时只要「当前 token 等于我拿到的」就隐含了「我仍是最新授权」。如果 token 是随机的,无法建立「哪个更新」的顺序,陈旧与当前就无法区分。lab 里 token 从租约 ID 起步、每次 KeepAlive +1,正是把这个单调性最简化地表达出来。

还有一个边界要说明:fencing token 保护的是「存储接受哪笔写」,它不能阻止陈旧写者发起请求,只能让存储拒绝它。换句话说,它是拒绝侧防护,不是阻止侧防护。设计上这已经足够——只要存储只接受携带最新 token 的写,陈旧写者的所有写都会被 Txn 条件挡住,数据不会损坏。K8s 控制器把「续约」与「写」绑在一起:每次写前确认自己的租约仍有效、token 仍最新,才允许执行写路径。

fencing token 对应的经典故障场景是「分布式锁 + GC 停顿」。进程持锁后发生一次长时间 GC pause(几秒到几十秒),锁在 pause 期间因未续约而失效、被另一进程抢走;pause 结束,原进程恢复执行,带着「我持锁」的旧认知继续写。此时锁服务即使发现它已失锁,也无法让它停手——唯一可靠的是存储侧的 token 校验:它手里是旧 token,新持有者已拿到更大的 token,写入被拒。这个场景说明,fencing 的价值不在锁本身,而在「授权事实」被单调地固化下来。

fencing 与 K8s 选主的关系

K8s 的选主用 Lease 对象实现:holderIdentity 标记持有者,renewTime 每周期续约,过期后其他候选可接管。这套机制本身不是 fencing token 语义——它靠「时间戳 + 持有者标识」判断谁活着,存在两个 leader 的脑裂窗口(旧 leader 尚未感知租约过期)。

Lease 续约在 etcd 底层就是第 11.2 节的租约语义:控制器持有 coordination.k8s.io/Lease,通过 clientv3 的 KeepAlive 或 lease.Grant 定期续约。续约动作本身会刷新 renewTime,同时让 etcd 租约的剩余时间重置。若要在续约的同时拿到单调递增的 checkpoint token,就需要在选主实现里显式使用——标准 K8s 的 leader election 库默认不签发 token,这是社区方案(如结合外部存储做 fencing)的扩展点。

要真正拦住陈旧写者,需要「存储侧校验 token」这一环。K8s 里常见的组合是:领导者续约时从 etcd 拿一个递增的 token(checkpoint),每次写对象时用 Txn 的 compare 断言「当前 token 仍等于自己持有的」,不满足则放弃写。这样即使脑裂窗口内旧 leader 还在写,它的 token 已过期,Txn 失败,数据不会被陈旧写者污染。

注意两者的分工:乐观锁(mod_revision)管「并发」,fencing token 管「授权」。并发冲突是同时存在的两个活进程抢同一个版本;授权失效是一个进程已失去资格但仍尝试写。前者靠版本号检测,后者靠 token 校验。K8s 的控制器通常两者都要——Update 带 resourceVersion(防并发),租约保护的选择性写入带 token(防陈旧)。第 15 章讲运维时还会回到「选主 + fencing」的组合。

用一个脑裂场景把两层防护叠起来看。旧 leader A 与新 leader B 同时存在:

写入者携带 resourceVersion携带 token存储判定
新 leader B最新对象的 RV最新 token通过
旧 leader A(并发写同一对象)旧的 RV过期 tokenRV 或 token 至少一项不符,拒绝

即使 A 的 RV 恰好没冲突(它读的版本还没被别人写过),token 校验仍会拒绝它;即使 A 的 token 因某种巧合仍有效(租约未过期),RV 校验也会拦截并发。两层各自独立、互为兜底——这正是分布式系统里「多层防护」的标准形态。K8s 的协调器在强一致读写路径上同时启用两者,是因为任何一层单独都可能存在盲区。

本节 lab

本节验证两个包的三条语义,实现分别在 private/labs/k8s-etcd-lab/store/txn.go 与 private/labs/k8s-etcd-lab/lease/lease.go:

cd private/labs/k8s-etcd-lab
go test ./store -run 'TestTxnAtomicIfThen|TestCASAndCASModRev' -v
go test ./lease -run TestRevokeImmediateAndFencingToken -v

预期断言:

  • TestTxnAtomicIfThen:基于 mod_revision=1 的 Txn 成功把 k 更新为 v2(到 rev2);基于过期 rev1 的第二个 Txn 整体跳过,k 保持 v2——证明 If 全部通过才执行 Then、失败不产生任何写;
  • TestCASAndCASModRev:CAS("k", "", "v1") 实现「不存在才创建」,两个客户端基于同一 rev1 并发写,第一个成功(k=client-a),第二个失败(409 语义),最终值保持 client-a——证明冲突写整体被拒;
  • TestRevokeImmediateAndFencingToken:续约两次 token 前进 2,旧 token 无法通过 ValidToken 校验,撤销后所有 token 失效——证明 fencing token 随续约前进、陈旧 token 被拦。

三条断言分别对应「事务原子性」「乐观锁冲突检测」「fencing 授权校验」,覆盖本节全部核心语义。运行命令全部通过即满足 12.2 的并发控制要求。

继续阅读

探索更多技术文章

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

全部文章 返回首页

「books」更多文章

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