一次结算任务,A 拿到锁之后发生了 5 秒的 GC 停顿。锁的过期时间设成 3 秒,第 3 秒时 B 抢到了锁,开始处理同一批数据。第 4 秒 A 从停顿中恢复,它并不知道自己手里的锁已经过期,继续按原计划写入。两边都认为自己持有锁,同一批数据被结算了两遍。

事后最容易被误判的点是「Redis 锁不可靠」。其实问题不在 Redis,而在设计:锁过期了,A 却还能继续写,没有任何机制拦住它。锁本身只管「谁能拿到」,管不了「拿到之后还作不作数」。

这篇讲清楚三件事:为什么锁一定要有过期时间,过期之后为什么会同时出现两个持有者,以及 fencing token 和 etcd 租约各自怎么补这个洞。关于真实 etcd、Redis Cluster 集群的部分未在本机实测,只讲机制和配置。

锁要解决的三件事

先把锁失效时的典型现象列出来。多数「锁不生效」的故障,追下去都不是 Redis 或 etcd 坏了,而是锁的边界没设计对。

现象真实原因第一步查什么
两个消费者同时处理同一订单锁过期后 A 仍在写,B 已经拿到新锁对比锁过期时间与业务最长执行时间
加了锁仍然重复扣款锁只保证互斥,不保证操作幂等查业务幂等键和去重表是否生效
Redis 主从切换后锁凭空消失锁只写在主节点,还没同步到从节点查 Redis 部署形态与主从同步延迟
锁提前释放,任务被抢走续租线程被 GC 或网络问题卡住查续租间隔、进程停顿和网络错误
解锁时删掉了别人的锁释放前没有校验锁值里的持有者标识查解锁是否用 compare-and-delete
压测时锁竞争严重、RT 飙升临界区太大,锁粒度过粗统计临界区耗时和加锁 QPS
etcd 租约过期后任务被接管心跳超时,租约没续上查 etcd 集群健康与续租间隔
跨机房加锁延迟明显升高锁服务在远端机房,每次加锁都要跨城查锁服务部署位置与单次请求加锁次数

分布式锁最常被理解成「同一时刻只有一个人能进」。这只说对了第一层。完整的锁要同时回答三个问题:谁能进来,怎么证明进来的人还是它,失效之后怎么收场。

互斥同一时刻只有一个持有者。靠一个所有参与者都认的共享存储来做仲裁。
身份释放时只能由持有者释放,不能把别人刚拿到的锁删掉。靠锁值里存一个唯一标识。
失效持有者崩了、卡了、网络断了,锁要能自动释放,否则整个业务永久卡死。靠过期时间或租约。

第三层是分布式锁和单机锁最大的区别。单机锁跟着进程生死走,进程没了锁自然没了;分布式锁的持有者可能只是「暂时联系不上」,共享存储没法立刻判断它死没死,只能靠超时来猜。超时这个「猜」,正是后面所有麻烦的来源。

这三层里任何一层没做扎实,锁都只是半个锁,平时看不出问题,一到故障就会同时冒出两个持有者。

还要先分清两种用途。一种是「效率锁」:重复执行最多浪费一点资源,比如缓存重建、定时任务防重。另一种是「正确性锁」:重复执行会导致资损或数据错乱,比如扣款、结算。效率锁用 Redis 足够;正确性锁必须再加一层存储层校验,否则过期那一刻就可能出错。

Redis 锁:SET NX PX 和「过期是必须的」

Redis 做锁最常用的写法是一条命令:SET key value NX PX milliseconds。NX 表示 key 不存在时才设置,保证互斥;PX 表示多少毫秒后自动过期,保证持有者崩了锁能释放;value 放一个只有持有者知道的随机串,保证释放时能认出自己。

过期时间不是可选项。如果不设过期,A 拿到锁后进程崩溃,锁永远留在 Redis 里,所有后来者都进不来,业务彻底停摆。所以哪怕过期会带来「锁提前失效」的风险,也必须设,因为「永久卡死」比「偶尔并发」更不可接受。

释放锁也不能直接 DEL。直接删会把「别人刚拿到的锁」删掉,比如 A 过期后 B 拿到,A 恢复后一删,B 就失去了锁。正确做法是先比较 value 是不是自己的,是才删,比较和删除要在一个原子操作里完成,通常用一段 Lua 脚本。

# 加锁:NX 保证互斥,PX 保证能自动释放
SET lock:settle <token> NX PX 3000

# 释放:只删自己的锁,比较和删除原子完成
if redis.call("GET", KEYS[1]) == ARGV[1] then
  return redis.call("DEL", KEYS[1])
else
  return 0
end

这两段只能保证「同一时刻一个持有者」和「不误删别人的锁」,保证不了「过期后旧持有者不再写」。因为旧持有者根本不需要碰 Redis,它直接去写数据库了。锁的过期对它没有任何约束力,过期时间定得再准,也快不过一次停顿。

单实例 Redis 宕机也会让锁出问题,这一点未在本机实测。单实例挂了,锁数据可能跟着丢,所有等待者会同时拿到锁;主从切换时,如果锁还没同步到新主,新主上根本没有这把锁,也会出现两个持有者。业界有过把多个独立实例投票组合起来的方案,但它对网络分区和时钟的假设仍然很强,正确性锁不能只依赖它。

过期之后:两个持有者同时存在

锁过期不是「锁坏了」,而是「锁的租期到了」。租期到了之后,共享存储允许别人拿锁,但旧持有者可能还在干活,它手里的锁凭证并没有失效,只是不再被承认。这个时间差就是并发窗口。

只有锁:
  t=0 A 拿锁 token=1
  t=3000 锁过期,B 拿锁 token=2
  t=4000 A 写入成功,B 也已写入,双方都认为自己持有锁
  最终写入: A 写入(锁已过期但无人拦截) / B 写入
锁 + fencing token:
  t=0 A 拿锁 token=1
  t=3000 锁过期,B 拿锁 token=2
  t=4000 A 持 token=1,小于当前 token=2,写被存储层拒绝
  最终写入: B 写入

第一段是「只有锁」的结局。A 在第 4 秒写入成功,B 也已经写入,双方都认为自己持有锁,最终两份写入都落了库。注意括号里那句「锁已过期但无人拦截」,说的就是锁只负责发凭证,不负责拦写入。

第二段是加了 fencing token 的结局。每次成功拿锁,都会得到一个单调递增的编号,A 拿到 1,B 拿到 2。写入时把编号一起带给存储层,存储层记住「这个资源当前接受的最大编号」,发现 A 的 1 小于 2,直接拒绝。A 的写入被挡在门外,最终只有 B 写入成功。

这个编号就是 fencing token,中文常叫「围栏令牌」。它的关键不在锁服务,而在存储层:真正写数据的那一层必须校验编号,并且校验和写入要原子完成。只在应用层比较一下、再发写请求,中间仍有窗口,等于没做。

并发窗口不只有 GC 停顿。网络抖动让续租请求晚到、宿主机被挂起、容器被暂停、时钟回拨让过期判断提前,都能让锁在业务还没结束时失效。这些原因在监控上往往表现为「锁续租失败率上升」或者「同一资源的并发写入增加」,而不是某一行报错。

fencing token 必须由锁服务单调发放,不能由客户端自己生成。客户端生成的编号在时钟回拨或重启后会重复,存储层就无法判断谁更新。编号的「单调」是这套机制成立的前提。

fencing token 怎么落到存储层

落地方式比概念简单。给被保护的数据加一列「接受的最大令牌号」,每次写入带一个候选令牌,存储层在一个事务里做两件事:比较候选令牌是否大于当前值,大于就更新数据和令牌,否则拒绝。整个过程和业务写入在同一个事务里,不留窗口。

# 存储层校验(伪代码,和业务写入同一事务)
fn guarded_write(resource, value, token):
  begin transaction
  current = select max_token from resource_state
            where id = resource for update
  if token <= current:
    rollback; return REJECTED      # 旧持有者被挡
  update resource_state set max_token = token, value = value
  commit
  return OK

这套机制的代价是每次写都要多一次比较和更新,而且要求存储层支持事务或至少支持原子比较更新。如果底层是对象存储、日志文件这类不支持事务的地方,fencing token 就很难做严格,只能退而求其次,做「写完再校验」并接受短暂的不一致。

另一个细节是令牌的初始值。资源第一次被保护时,最大令牌号应该设成一个很小的值,比如 0,这样第一个合法令牌一定能通过。如果设成很大的值,第一次写入就会被误拒。初始化脚本要和锁服务的起始编号对齐,不能各写各的。

fencing token 也不是万能的。它要求所有写入路径都走同一道校验,一旦有旁路直接改库、或者有批量脚本绕过应用层,令牌就形同虚设。它还会让「只读多、写入少」的资源多出一列状态,增加一点存储和迁移成本。对纯效率锁,这些投入通常不值得。

etcd 租约:把「过期」做成一等公民

etcd 是专门做协调服务的存储,它把「过期」做成了核心概念,叫租约。客户端先申请一个租约,拿到一个租约编号和有效期;然后在有效期内不断续租;一旦停止续租,租约到期,挂在租约上的 key 会自动删除。

用 etcd 做锁,通常是创建一个 key,把它绑定到租约,并用「只有 key 不存在时才创建」的语义保证互斥。谁创建成功,谁就持有锁。释放时删除 key 或撤销租约。和 Redis 相比,它有几个结构性的差别。

Redis 锁

单条命令快,实现简单,适合效率锁。过期时间是客户端自己设的,锁服务和业务数据是两套系统,需要 fencing token 兜底。集群模式下主从切换的极端情况,锁的归属可能出现争议,相关行为未在本机实测。

etcd 租约

租约由服务端统一管理,续租、过期、撤销都有明确语义,配合 revision 能做「比较版本再写」的原子操作。代价是每次操作要多次往返,延迟比 Redis 高,运维也多一套组件。集群行为未在本机实测。

etcd 还有一个 Redis 锁没有的东西:revision。整个 etcd 的每次修改都会让全局 revision 增加,这个编号天然单调,可以直接当 fencing token 用。创建锁 key 时拿到的 revision,就是这次持有的凭证;写入时让存储层比较 revision,逻辑和前面一样,只是令牌来源更可靠。

实际使用时,客户端通常还要开一个 watch 监听锁 key。自己的 key 被删除或者被改动,能第一时间知道锁已经不属于自己,从而停止业务。这个监听只能作为辅助,不能替代数据层校验,因为它依赖网络把事件送达,而网络恰好是可能出问题的那一环。etcd 集群的部署、选主和故障切换细节未在本机实测。

不过 etcd 也不是「用了就绝对安全」。租约到期同样会释放锁,旧持有者同样可能还在写;网络分区时,客户端可能以为自己还持有租约,服务端却已经判定过期。所以即使换 etcd,只要涉及正确性,仍然要在数据层做校验,不能只靠锁,也不能把租约的有效期当成事实。

锁服务能保证的是「谁被承认为持有者」,保证不了「旧持有者停止动作」。凡是有资损风险的写入,最后一道防线都应该在数据层,而不是在锁上。

参数怎么定:过期、续租、重试

过期时间要大于「一次业务执行的最长耗时」,而不是平均值。业务平均 100ms,偶尔因为 GC 或慢查询到 2 秒,过期时间就该设在 3 秒以上,而不是 200ms。设得太紧,等于主动制造「锁提前失效」。

但过期时间也不能无限大。设成 10 分钟,持有者崩了之后,业务要等 10 分钟才能恢复,这期间所有请求都卡着。比较稳的做法是「较短过期加自动续租」:过期设成 3 秒,后台每 1 秒续一次,只要进程活着锁就一直有效,进程一停最多 3 秒释放。

# 锁参数(示意)
lock:
  ttl: 3000ms              # 必须大于业务 p99 耗时
  renew_interval: 1000ms   # 约为 ttl 的三分之一
  renew_on: background      # 独立线程续租,不能用业务线程
  acquire_timeout: 2000ms   # 等锁上限,超时快速失败
  retry_backoff: 50..200ms  # 带抖动,避免同时抢
  token_source: lock_service # 单调递增,客户端不得自行生成

# 续租失败处理
if renew_failed:
  stop_business()          # 主动停止,不要带着过期锁继续写

续租必须放在独立线程或独立协程里。如果放在业务线程里,业务一旦卡住,续租也跟着停,锁就会在「业务还在跑」的时候过期,正好制造最危险的并发窗口。续租失败时也不能装作没事,应该主动停止业务,并把这次执行标记为「可能未完成」,交给对账去处理。

抢锁的重试要带退避和抖动。所有进程在同一毫秒醒来抢同一把锁,会给锁服务制造尖峰,也会让抢到的概率变得很不公平。等锁的总时长要有上限,超过就快速失败,让上层决定是稍后重试还是走降级,而不是无限排队把线程占满。

监控至少要盯四个指标:等锁时长、续租失败次数、锁过期时业务是否还在执行、同一资源的并发写入数。第四个指标最能说明问题,因为它是「两个持有者同时写」的直接证据。只监控锁服务本身的 QPS 和延迟,发现不了这类事故。

边界与代价

能用数据库行锁就别上分布式锁。如果所有写操作都落在同一个数据库,用一条带条件的更新语句就能实现互斥,比如「库存大于零才扣减」,既原子又不用额外组件。分布式锁适合跨多个数据源、跨服务、或者需要长时间占用的场景,不该拿它替代数据库本就提供的原子性。

锁会掩盖设计问题。很多「需要分布式锁」的场景,其实是因为数据模型没有唯一约束、或者业务没有幂等。加一把锁能让问题暂时不出现,但锁一旦过期、服务一旦扩容,问题会以更难看的形式回来。先问「不加锁能不能靠唯一键或幂等解决」,往往能省掉一整套复杂度。

锁的粒度要克制。一把大锁保护整个业务,实现简单,但吞吐被锁死,一个慢任务拖住所有人。按业务号或资源号拆成小锁,吞吐上去了,代价是锁的数量变多、监控和清理更复杂。粒度应该按「冲突范围」来定,而不是按「代码好写」来定。

正确性锁的最终防线在数据层。无论用 Redis 还是 etcd,只要锁会过期,就存在旧持有者继续写的窗口。fencing token、版本号、唯一约束、条件更新,这些数据层手段才是最后一道闸。把全部希望押在「锁不会过期」上,等于把正确性交给一个超时猜测。

多引入一个组件就是多一个故障点。为了锁专门部署一套 etcd,意味着要多维护一个集群、多一套备份、多一份值班责任。如果业务只有零星几处需要互斥,用数据库条件更新或唯一约束更划算。先算清楚「这把锁保护的是什么价值」,再决定值不值得为它上一个新组件。

锁的等待也会传递。一个请求等锁 2 秒,占着线程和连接,上游看它就是慢请求;上游再重试,又会多一个等锁的请求。等锁时间必须算进整条链路的超时预算,否则锁会成为最隐蔽的尾延迟来源。等锁超时后快速失败,比一直排队更健康。

一个务实的判断:如果重复执行只是浪费一点 CPU,用 Redis 锁就够;如果重复执行会扣两次钱,锁之外必须再加一层数据层校验。先分清是哪一种,再决定投入多少。

当天可以自验的五件事

  1. 找出系统里所有分布式锁的调用点,标注它是「效率锁」还是「正确性锁」。
  2. 检查加锁命令是否同时带了 NX 和过期时间,缺一个都记下来。
  3. 检查释放锁是否比较了持有者标识,是否存在直接 DEL 的写法。
  4. 把锁的过期时间和业务 p99 耗时对比,确认过期时间是否大于真实执行时间。
  5. 对一把正确性锁,尝试在数据层加一个令牌或版本校验,用旧令牌发一次写,确认会被拒绝。

锁解决了「同一时刻谁能改」,但一次业务往往要改好几个地方,而且要求它们一起成功或一起失败。这就是分布式事务要处理的问题。下一篇《分布式事务:两阶段提交、TCC、消息最终一致》会从一次 prepare 之后协调者失联、参与者行锁一直不释放的故障讲起。