《Kubernetes 分布式系统原理深入解析》2.2 乐观锁冲突与 409

K8s 的并发控制选乐观锁而非悲观锁:读取时携带 resourceVersion,写入时校验它仍是最新,冲突返回 409。这由底层 etcd 的 mod_revision CAS 天然支持,也契合控制器『读-算-写』的异步模型。本节拆解 409 的生命周期、客户端如何处理(重读-重算-重写)、以及为什么这比锁更适合分布式控制面。lab 用 api/store.go 验证过期 RV 更新的冲突语义。

2.2 乐观锁冲突与 409

控制器和应用都在并发地写同一个对象。K8s 怎么防止「最后写的人赢」(last-writer-wins)把别人的修改盖掉?答案是乐观锁:不锁资源,靠版本校验。本节拆解机制、冲突处理和为什么这个选择对分布式控制面是合理的。

乐观锁 vs 悲观锁

两种并发控制策略:

乐观锁悲观锁
做法不占资源,写时校验版本写前获取锁,别人必须等
冲突概率低时高效锁开销大
冲突概率高时频繁重试排队等待
需要锁服务?不需要需要

K8s 选乐观锁有三个原因:

  1. 底层就是 CAS:etcd 的事务支持 mod_revision == 期望值 的比较,apiserver 直接映射成 RV 校验。加悲观锁反而要在 etcd 之上再造一层锁服务。
  2. 控制器是异步的:控制器「读到对象 → 计算差异 → 写回」之间隔着一个缓存与 workqueue,锁的持有时间无法精确控制;版本校验则无此问题。
  3. 冲突概率低:大多数写是控制器对自己负责的字段(status),多个控制器写不同子资源,实际冲突远少于「共享写一个字段」。

409 的生命周期

一次携带过期 RV 的更新,完整过程:

  1. 读:客户端 GET 对象,得到 RV=10。
  2. 算:客户端计算新 spec(基于 RV=10 的版本)。
  3. 写:客户端 PUT,携带 RV=10。
  4. 校验:apiserver 读 etcd,发现对象当前 RV=12(别人已写两次)。
  5. 冲突:apiserver 返回 409 Conflict,并附上对象的当前版本。

注意第 5 步的关键:409 响应会带上服务器当前的对象(含最新 RV)。客户端拿到 409 后应该:

  • 从响应里提取最新 RV(或重新 GET)。
  • 基于最新状态重新计算期望。
  • 再次提交。

如果客户端只是「原样重试」(继续带旧 RV),会再次 409,陷入死循环。正确处理是把「读-算-写」整个循环重跑一遍——这正是控制器 workqueue 的「重试」语义:key 重新入队,控制器重新读取、重新计算。

CAS 的底层:mod_revision 比较

在 etcd 层面,一次带版本的更新就是事务:

If:  /registry/deployments/default/nginx 的 mod_revision == 10
Then: 写入新值(分配 revision 13)
Else: 返回 compare failed
  • mod_revision:对象最后一次被修改的 revision。
  • RV=10 对应 mod_revision=10。
  • 若当前 mod_revision ≠ 10,事务整体失败,不产生任何写。

这就是卷二第 1.1 节说「写成功 = 已提交」的原因:成功意味着「在我读取之后没人改过」,我的更新是建立在我看到的状态之上的。而不是「覆盖了别人的修改」。

控制器视角:重试就是重新调谐

控制器(如 Deployment 控制器)写 status 时也可能 409——比如另一个控制器刚写了 observedGeneration。处理方式是:

  1. 收到 409,把对象重新入队(workqueue.AddRateLimited)。
  2. 指数退避后重新 reconcile。
  3. 重新读取对象(拿到最新 RV 与状态),重新计算差异,重新写。

注意:控制器从来不会「重放旧写」,只会「基于新状态重新计算」。这是控制器幂等的关键——它每次 reconcile 都从「当前现实」出发,而不是从「上次的意图」出发。卷二第 6 章会展开 workqueue 的重试语义。

冲突率如何被设计压低

除了乐观锁本身,K8s 还用几个设计压低冲突率:

  • 子资源拆分(status/scale):控制器写 status、HPA 写 scale,互不争抢主对象。
  • 字段所有权:server-side apply 记录每个字段的属主,只冲突时 409,不冲突时各改各的(卷二 2.3 节)。
  • RV 粒度:冲突只发生在「同一对象被并发写」时,跨对象不冲突。

当冲突确实发生时(比如用户频繁改 spec 同时控制器写 status),409 是正确行为而非错误行为——它防止了静默覆盖。能接受 409 的客户端,其写入是正确的;消灭 409 反而意味着丢弃了并发保护。

悲观锁为什么不可行:控制器持有锁的时序问题

「为什么不用锁?」在控制器的场景里有个具体的技术原因:锁的持有时间无法与控制器的工作循环对齐。

控制器的工作是「读-算-写」,其中「读」读的是缓存(可能滞后),「写」带乐观锁。如果给控制器一把悲观锁:

lock.acquire()
读缓存(旧状态)          ← 锁白拿了,因为读的不是实时状态
算差异
写 etcd(乐观锁照旧)     ← 写还是要带 RV,锁没帮上忙
lock.release()

问题在于:控制器的「读」与「写」之间隔着缓存滞后,锁无法保证「写建立在最新读之上」。而乐观锁直接在写时校验「我读的版本还是不是最新」,语义上正好匹配控制器的异步模型。悲观锁适合「读实时 → 改 → 写实时」的同步事务场景;控制器是异步的,乐观锁才是正确工具。

409 的响应结构:冲突时给你什么

一个真实的 409 响应不只是「出错」,它携带恢复所需的信息:

HTTP/1.1 409 Conflict
Content-Type: application/json

{
  "kind": "Status",
  "code": 409,
  "reason": "Conflict",
  "message": "Operation cannot be fulfilled on deployments.apps \"nginx\": the object has been modified; please apply your changes to the latest version and try again",
  "details": {
    "name": "nginx",
    "group": "apps",
    "kind": "deployments"
  }
}

注意 message 里的关键词:please apply your changes to the latest version——这是协议对客户端的明确指引:别重试旧版本,去拿最新版本再改。健康的客户端(client-go、控制器)据此重新 GET、重新计算、重新提交。这也是控制器 409 重试不同于普通网络重试的原因:网络重试可以原样重发,409 重试必须重新读取。

乐观锁的代价与适用边界

乐观锁不是免费的。它的代价集中在冲突发生后:

  • 重读:每次 409 都要重新 GET 最新版本,多一次读放大。
  • 重算:控制器要基于新状态重新计算期望,可能触发更多级联写入。
  • 抖动:两个写者互相 409 会形成「乒乓」,靠指数退避缓解(卷二第 6 章)。

所以乐观锁的适用边界是「冲突概率低」。K8s 通过三个设计把冲突压到低:

设计作用
子资源拆分(status/scale)不同控制器写不同视图
字段所有权(SSA)同一字段只有一个属主
控制器分片不同对象归不同控制器实例

如果冲突率真的高(一个对象每秒被多个客户端写),乐观锁会退化为「频繁重试 + 读放大」。此时工程上的选择不是改回悲观锁,而是重新设计写路径(合并写入方、缩小字段集、用 apply 而非 update)。悲观锁在高冲突下排队更稳定,但 K8s 的场景(控制器写 status、用户偶尔改 spec)天然冲突低,乐观锁的收益远大于代价。

三个常见误解

  • 「409 是 bug,要修掉」——错误。409 是并发保护在起作用;合理设计让冲突变少,但冲突不该被掩盖。
  • 「收到 409 就原样重试」——错误。必须重读最新版本再重算,否则无限 409。
  • 「乐观锁 = 没有锁 = 没并发控制」——错误。它把「互斥」换成「校验」,保护效力仍在,只是冲突方不等待而是重试。

客户端对 409 的两种处理:立即重读与退避重读

收到 409 后「重读-重算-重写」是对的,但节奏上有讲究:

  • 立即重读:适合单发请求(kubectl、CI)。拿最新版本改完立刻重试,通常一次成功。
  • 退避重读:适合控制器循环。若两个控制器互相 409(你写 status、我写 status),立即重试会「乒乓」;指数退避给双方错开时间。

两者的共同前提:绝不带旧 RV 原样重发。409 的正确响应是「重新开始一次读-算-写」,而不是「把上次的写再发一遍」。这个区分是客户端设计正确性的分水岭——也是卷二第 6 章 workqueue 把「409」当作普通失败入队重试的原因。

本节 lab

本节验证过期 RV 更新的冲突语义:

cd private/labs/k8s-ctrl-lab
go test ./api -run 'TestOptimisticConflict' -v

TestOptimisticConflict 模拟两个并发写者:A 与 B 都读到 RV=1,B 先写成功(RV=2),A 用过期 RV=1 再写 → 必须返回 ErrConflict(对应 409),且对象保持 B 的写入不被 A 覆盖。这正是「最后写的人赢」被版本校验阻止的演示。

继续阅读

探索更多技术文章

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

全部文章 返回首页

「books」更多文章

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