Essay 016 · 软件工程

并发互斥与锁方案的拆解框架

从并发写冲突与异步任务争抢出发,依次推导出入口串行路由、写时原子校验与事前抢锁三条路线,并串联排他锁、租约与围栏令牌的演进逻辑。

本次修订:从具体冲突出发,按问题演进重组排他控制、租约与围栏令牌的推导顺序

Version 1.1

一句话结论:多个执行者修改同一对象或争抢同一任务时,优先考虑绕开抢锁——要么在入口把请求排成单列(入口串行路由),要么放开并发计算、只在落库那一刻核对版本或前置状态(写时原子校验)。只有当执行过程包含不可重入的外部调用时,才需要事前抢锁;而一旦锁引入了超时重派(租约),单靠锁本身就挡不住旧执行的延迟回写,必须由存储层校验递增的围栏令牌(Fencing Token)。

为什么写这篇

两个请求同时修改同一笔订单,或者两个后台 Worker 同时扫到同一条待分析的工单任务,如果不做排他控制,就会触发重复调用外部接口、状态流转错乱,或者慢一步完成的旧请求覆盖新结果。

工程上应对这类冲突的手段很多:消息队列单分区消费、数据库乐观锁、状态机条件更新,以及基于 Redis、ZooKeeper、etcd 或关系型数据库的排他锁。实际选型最容易卡在两个交界处:什么时候根本不需要引入锁?加了带过期时间的锁之后,为什么数据还是会被旧执行覆盖?

本文聚焦多个执行者修改同一对象或争抢同一任务时的排他控制(写—写冲突与独占执行);多版本并发控制(MVCC)处理的读—写快照隔离不在讨论范围内。

先试着不加锁:入口排队与落库拦截

引入排他锁意味着要维护加锁、续期、异常释放和故障恢复。在动用锁之前,系统有两个位置可以直接消解写冲突,一个赶在业务逻辑开始前,一个守在数据落盘那一刻。

1. 入口串行路由:事前消掉并发

多个执行者改同一笔订单之所以冲突,是因为请求落到了不同线程或不同节点上。如果在接入层或消息队列入口按业务 Key 哈希取模,把订单 1001 的所有变更请求固定发往同一个 Kafka 分区,或者路由到同一个单线程执行器(如 Actor 模型)依次处理,那么同一笔订单从头到尾只有一条线程顺序执行,既不用抢锁,也不会发生写冲突。

这条路线的约束在于入口必须收拢:凡是会修改该对象的请求,都得走同一套分片路由规则,不能有其他服务绕过队列直接改库。

2. 写时原子校验:事后拦截冲突

如果多个服务或接口都要直接读写同一张数据库表,入口无法收拢成单线程,就可以放开并发读取和内存计算,把冲突检测推迟到最后写入存储的那一刻,利用数据库行级更新本身的原子性做条件拦截:

  • CAS 乐观锁:读取数据时记下当前的 version = 1,计算完成后写回时带上原版本号:

    UPDATE account
    SET balance = 80, version = 2
    WHERE id = 1 AND version = 1;

    同时到达的多个请求中,只有一个能匹配 version = 1 并写入成功(影响行数为 1);慢一步的请求看到影响行数为 0,就知道期间数据已被改过,可以选择重试或直接放弃。

  • 状态机条件更新:如果业务状态本身单向推进(例如 PENDING -> PAID -> SHIPPED),前置状态就能直接充当版本号,省掉独立的 version 列:

    UPDATE orders
    SET status = 'PAID'
    WHERE id = 1001 AND status = 'PENDING';

    第一个请求把状态推进到 PAID 后,后续并发请求因为不满足 status = 'PENDING' 直接返回 0 行。

撞上外部副作用:什么时候必须事前抢锁

写时原子校验成立的前提,是落库之前的读取和计算过程没有不可重入的外部副作用——就算最后写库时发现冲突白算了一次,丢弃结果或重算一遍即可。

一旦执行过程夹杂着调用第三方支付接口扣款、向外部设备下发指令,或者触发一次耗时数分钟且计费的工单分析工作流,就不能等外部调用已经发出去,到最后写库时才发现另一个节点早就跑过了。这类场景必须在发起外部动作之前先拿到排他执行权,也就是回到事前抢锁。

按消除冲突的位置,三条路线的分工与代价可以归结如下:

序号 路线分类 消除冲突的位置 核心做法 典型代表 代价与约束
1 入口串行路由 请求进入系统时 按业务 Key 固定分发到唯一队列分区或单线程执行器,顺序执行 Kafka 同分区单消费者、按 Key 取模分片路由、Actor 模型 所有相关写入入口都必须收敛到同一分片路由
2 写时原子校验 写入存储时 读取和计算阶段允许并发,落库时用原子条件核对版本号或前置状态 CAS 乐观锁(version 字段)、状态机条件更新 执行过程不能含不可重入的外部副作用;需处理更新 0 行后的重试或拒绝
3 事前抢锁 执行业务逻辑前 先向锁协调者申请排他执行权,拿到才执行,拿不到就等待或放弃 Redis 锁、ZooKeeper/etcd 锁、数据库排他锁或任务表 需处理锁释放、超时接手与过期回写问题,持锁期间阻塞并发

抢锁之后的连环问题:从排他锁、租约到围栏令牌

一旦走上事前抢锁路线,一把锁必须经历三步演进,才能同时保住安全性(Safety,同一时刻不出现并发破坏)和活性(Liveness,系统不会永久卡死):

第一步:普通排他锁——保住安全性,但怕持有者崩溃

最直接的做法是由锁协调者(Coordinator)发放排他锁:执行者 A 抢到锁后去调外部接口,执行完主动释放。问题在于,如果 A 持锁期间进程崩溃或机器断电,解锁指令永远发不出来,后续所有执行者就只能无限等待。系统保住了安全性,却失去了活性。

第二步:引入租约(Lease)——救回活性,但漏出暂停窗口

要让系统在持有者崩溃后自动恢复,锁就必须带有效期,变成租约(例如每次认领限时 5 分钟)。A 崩溃后,5 分钟一到租约自动失效,执行者 B 就能接手同一任务继续推进。

但租约引入了一个隐蔽的缺口:租约到期只说明超时,不说明原持有者已经终止。

如果 A 并没有崩溃,只是遇到了垃圾回收(GC)长停顿、网络抖动,或者调用的外部 HTTP 接口卡了 6 分钟才返回:第 5 分钟租约到期时,锁协调者允许 B 接手任务,B 在第 6 分钟跑完并把新结果写进了数据库;第 7 分钟 A 从阻塞中恢复,它并不知道自己的租约早已过期,照常往下走完剩余的落库代码,就会用旧结果把 B 刚写好的新结果覆盖掉(即脑裂或过期回写)。

这个漏洞并不是多机分布式环境独有的现象,只要同时满足两个条件就会触发:

  1. 允许超时重派:任务超过规定时间未完成时,系统允许启动新一轮执行接手同一任务。
  2. 旧执行无法即时强杀:运行时很难安全、立即地强行终止一个正阻塞在网络 I/O 或暂停中的线程;一旦阻塞解除,旧线程仍会继续执行后续代码。

哪怕整个服务只部署在单台机器、单个 JVM 进程里,只要后台线程池允许任务超时重派,线程 A 卡在慢接口 6 分钟后醒来,照样会覆盖同进程线程 B 在第 6 分钟写入的结果。平时使用 synchronized 或 ReentrantLock 等进程内内存锁之所以不操心这件事,只是因为内存临界区极短且锁与进程同生共死,工程上会让其他线程一直等持锁线程跑完,不会设计“5 分钟没跑完就把锁强拆给另一个线程”的机制。

第三步:引入围栏令牌(Fencing Token)——由存储层守住最后防线

既然锁协调者无法阻止超时醒来的旧线程继续发出写请求,拦截旧写入的职责就必须落到最终接收数据的存储层上。

做法是让锁协调者每次发放租约时,顺带签发一个严格递增的整数——围栏令牌(Fencing Token)。执行者 A 认领时拿到 token = 1,超时后执行者 B 重新认领拿到 token = 2。存储层在写入时核对令牌大小:B 带着 token = 2 写入成功后,存储层记下当前最大令牌为 2;迟到的 A 再带着 token = 1 来写时,存储层发现令牌落后,直接拒绝。

执行者 A 认领 (token = 1) ──→ 发生暂停 (超过租约期) ─────────────────→ 携带 token = 1 写入 (被存储层拒绝)
                                      │
                              租约到期,换人接手
                                      ↓
                              执行者 B 认领 (token = 2) ──→ 携带 token = 2 写入成功 (存储层记录最大令牌 = 2)

把整条链路放在一起看,业务系统里常见的三个标识其实各管一段:

  • 业务对象 ID / 幂等键:识别“是不是同一件事”,用来合并重复请求或定位同一任务。
  • 租约有效期:决定“当前执行者失联多久后,允许换新执行者接手”,解决活性问题。
  • 围栏令牌:识别“是不是最新一轮派工”,在存储层拦住超时恢复的旧执行者,补齐安全性。

怎么选锁协调者:四个必答题与效率、正确性之分

Redis、ZooKeeper/etcd 和关系型数据库的接口形态相差很大,但只要拿它们充当锁协调者,底层都在回答刚才推导出的四个问题:

序号 锁协调者必须回答的问题 Redis 分布式锁 ZooKeeper / etcd 数据库排他锁 / 任务表
1 如何原子抢占?
(防止两人同时拿到锁)
SET key unique_val NX PX 单线程原子写入 创建临时顺序节点(ZK),或经 Raft 提交键值事务(etcd) 唯一索引插入冲突、SELECT ... FOR UPDATE,或带状态的原子 UPDATE
2 持有者崩溃后如何释放?
(租约机制)
靠 Key 的毫秒级过期时间 PX;长任务由客户端后台线程(如 Redisson Watchdog)定时续期 锁绑定在客户端会话(Session)或租约心跳上,断连后自动清理 事务悲观锁随连接断开回滚释放;持久化任务表则记录 lease_until 过期时间
3 持有者暂停恢复后如何防误删、防覆盖?
(身份校验与围栏令牌)
释放锁时用 Lua 脚本核对 unique_val 防止误删他人锁;但 Redis 本身不生成递增围栏令牌 每次状态变更都会产生全局递增序号(ZK 的 zxid、etcd 的 revision),可直接作为围栏令牌传给存储层 释放或写回时在 WHERE 条件中核对持有者标识与递增 token
4 锁协调者自身故障时怎么取舍?
(性能与强一致)
偏向性能(异步主从复制):主节点发锁后若未同步到从节点就宕机,从节点升主后会把同一把锁再发给别的客户端 偏向强一致(多数派共识):加锁需经 ZAB/Raft 多数派节点确认,切主不丢锁,但吞吐低于 Redis 取决于数据库主备复制方式;高频抢锁容易占满连接池并放大行锁争用

围绕第 3 问和第 4 问,Martin Kleppmann 在分析分布式锁时提出过一个很实用的分界线:选锁之前,先想清楚加锁是为了效率(Efficiency)还是为了正确性(Correctness)。

  • 为了效率:加锁只是为了少做一次昂贵的重复计算,或者避免同一刻向外部系统发两次请求。锁偶尔因主从切换或超时穿透失效,顶多多算一次或触发下游幂等拦截,不会写坏核心状态。这类场景用 Redis 的 SET NX PX 配合唯一值 Lua 释放脚本就够了,不必背负分布式共识的开销。
  • 为了正确性:并发写入一旦发生,就会造成账目错乱、状态倒退或结果互相覆盖。这时就算把锁协调者换成强一致的 ZooKeeper 或 etcd,单靠锁服务本身依然挡不住旧写入,因为客户端拿到锁之后的 GC 停顿或慢 I/O 发生在锁服务之外。要守住正确性,必须把锁协调者签发的围栏令牌一路传给最终落库的存储层做校验。

落地实例:在一张数据库表里串起租约与围栏令牌

如果业务并发量处于常规范围,而数据本来就保存在 PostgreSQL 等关系型数据库里,就不必为了派发异步任务额外引入 Redis 或 ZooKeeper。

以定时扫描执行的异步工单分析任务为例,把事前抢锁(任务表租约认领)与写时原子校验(状态机条件更新 + 围栏令牌)叠在同一张表上,两条 UPDATE 语句就能闭环前面的全部问题:

  1. 原子抢占并签发围栏令牌:Worker 认领任务时只发一条 UPDATE,限定只接手待处理(PENDING)或运行中但租约已过期(lease_until < now())的任务,同时顺延 5 分钟租约并把 token 加一:

    UPDATE analysis_task
    SET status = 'RUNNING',
        lease_until = now() + interval '5 minutes',
        token = token + 1
    WHERE id = :taskId
      AND (status = 'PENDING' OR (status = 'RUNNING' AND lease_until < now()))
    RETURNING token;
  2. 把长耗时调用移出数据库事务:认领语句执行完立即提交事务、归还数据库连接,避免后续几分钟的外部调用拖住行锁和连接池。Worker 拿着刚返回的 token 去调用工单分析接口。

  3. 写回时同时核对状态与围栏令牌:外部调用返回后,Worker 落库时在 WHERE 条件中校验运行状态和本次持有的 token:

    UPDATE analysis_task
    SET status = 'COMPLETED',
        result_json = :result,
        updated_at = now()
    WHERE id = :taskId
      AND status = 'RUNNING'
      AND token = :myToken;

在这套组合里,lease_until 负责在 Worker 崩溃后恢复活性,超时即可换人接手;自增 token 与 status = 'RUNNING' 负责在旧 Worker 暂停恢复或任务已被取消时守住安全性,落后的 myToken 只能更新 0 行,绝不会覆盖新结果;协调与落库又都在同一套数据库内完成,省去了跨组件状态同步和外部锁服务的运维成本。

结论与行动

遇到并发互斥与独占执行需求时,可以按从轻到重的顺序依次排查:

  1. 先看能不能在入口排成单列:只要请求能按业务 Key 固定路由到单一队列分区或单线程执行器,优先走入口串行路由,从源头消掉并发冲突。
  2. 再看能不能推迟到写库时拦截:如果计算过程没有不可重入的外部副作用、冲突也不频繁,优先用写时原子校验(CAS 乐观锁或状态机条件更新),省掉持锁、续期和释放流程。
  3. 必须事前抢锁时,先分清效率锁还是正确性锁:
    • 只防重复计算、能接受极小概率并发穿透时,用 Redis SET NX PX 配合唯一值 Lua 释放脚本;
    • 涉及集群选主或跨系统强一致协调时,用 ZooKeeper 或 etcd;
    • 并发量不高且已有关系型数据库时,直接用数据库任务表加租约字段。
  4. 只要允许超时重派,存储端就要校验围栏令牌:不管单机多线程还是分布式多节点,只要旧执行超时后允许新执行者接手,最终写库或改状态的接口就必须核对认领时递增的围栏令牌(如任务表的自增 token、ZooKeeper 的 zxid 或 etcd 的 revision),不能只靠锁或租约本身保证数据安全。

参考资料

查看本文修订记录(2)
  1. v1.1 · 2026.11.12 从并发写冲突与异步任务争抢出发,依次推导三条排他控制路线、租约与围栏令牌,并以数据库任务表收束。
  2. v1.0 · 2026.11.12 首次发布。