Skip to content

6.1-7 分布式锁:Redis / ZK / DB、续期、Redlock、fencing token ​

所属:06 分布式与架构 / 6.1 分布式理论 分级:A 状态:◐ 初稿 关联:4.2-1、4.2-4、5.1-2、6.1-3、6.1-10、6.5-13、6.7-5

  • 题型:对比 / 场景 / 原理

  • 一句话结论:分布式锁要同时满足互斥、防死锁、可释放,实现上 Redis 快但“过期即释放”会带来锁失效窗口,ZK/etcd 用临时节点 + 会话更接近 CP,DB 用唯一索引/行锁最简单但性能最差。续期(看门狗)只能降低失效概率,不能保证正确性;真正兜底的是 fencing token(单调递增的锁版本)+ 下游校验,或者干脆用唯一键/状态机/串行队列替代锁。面试先问“是否真的需要锁”,再谈实现。

  • 分层要点:

    1. 先问要不要锁:很多“并发问题”用唯一索引(防重复插入)、状态机(update ... where status=旧值)、乐观锁版本号、串行队列/分区消费就能解决,且没有锁的可用性风险。分布式锁适合临界区无法用数据约束表达的场景(如“检查后再执行”的复合操作、定时任务选主、资源调度)。
    2. 锁的三个基本要求:① 互斥——同一时刻只有一个持有者;② 防死锁——持有者崩溃后锁能自动释放(TTL 或临时节点);③ 安全释放——只能释放自己持有的锁。工程上还要考虑可重入、公平性、等待超时、续期、监控。
    3. Redis 实现:加锁用一条原子命令 SET key owner NX PX ttl(value 存 UUID + 线程ID);释放必须用 Lua 脚本“比较 value 再删除”,否则可能误删别人的锁(自己超时后别人已加锁)。Redis 锁是 AP:主从异步复制,主节点加锁后宕机、从节点升主时锁可能丢失。
    4. 续期 / 看门狗:业务执行时间不确定时,用后台线程在 TTL 到期前续期(Redisson lockWatchdogTimeout 默认 30s,每 10s 续一次)。续期解决“业务没跑完锁就过期”,但解决不了 GC 停顿、网络分区、进程假死——这些场景下旧持有者可能“以为自己还持锁”,实际锁已被别人拿走。
    5. ZK / etcd:在锁路径下创建临时顺序节点,序号最小者获得锁,其余节点 Watch 自己的前一个节点(避免羊群效应);会话断开后临时节点自动删除。基于 ZAB/Raft 多数派,是 CP:分区时宁可不可用也不双写。代价是性能低于 Redis、需要维护会话与连接。
    6. DB 锁:① 唯一索引:insert into lock_table(lock_key, owner, expire_at),插入成功即持锁,靠唯一约束保证互斥,需定时清理过期记录;② 行锁:select ... for update,事务结束释放,必须同一连接、注意 innodb_lock_wait_timeout(默认 50s)。简单、可审计,但DB 压力大、长事务会拖垮连接池,只适合低频场景。
    7. Redlock 与争议:Redlock 向 N(通常 5)个独立 Redis 实例加锁,多数派成功且总耗时小于 TTL 才算持有。Martin Kleppmann 的批评是:它依赖时钟与最大停顿假设,GC 停顿或网络分区下可能出现两个客户端同时持锁,而且没有 fencing;antirez 认为在合理时钟漂移下可用。结论:Redlock 不是强一致锁,跨机房、长临界区、资金类场景不要用它,改用 etcd/ZK + fencing 或数据库约束。
    8. fencing token 是正确性的关键:锁服务每次发放单调递增的 token(ZK 的 zxid/版本、Redis INCR、DB 自增),持有者带 token 访问下游;下游存储记录“见过的最大 token”,拒绝更小的 token(如 update ... where version < ?)。这样即使旧持有者在停顿后“复活”写入,也会被下游拒绝。锁只负责“尽量串行”,正确性由下游的 token 校验兜底。
  • 图/流程:

text
Redis 加锁 / 释放:
  加锁:SET lock:order:123 <uuid:thread> NX PX 30000
  释放(Lua 原子):
    if redis.call('get', KEYS[1]) == ARGV[1]
    then return redis.call('del', KEYS[1])
    else return 0 end
  错误做法:GET 判断后再 DEL(非原子,可能删掉别人的锁)
text
看门狗续期:
  t=0    加锁,TTL=30s
  t=10s  后台线程续期 → TTL 回到 30s
  t=20s  再续期
  ...
  业务结束 → 主动释放(取消续期任务)
  续期线程挂掉 / 进程长时间 GC → TTL 到期 → 锁被释放(别人可拿)
text
ZK 临时顺序节点:
  /locks/order-123/0000000001  ← 客户端 A(最小,持锁)
  /locks/order-123/0000000002  ← 客户端 B(Watch 0001)
  /locks/order-123/0000000003  ← 客户端 C(Watch 0002)
  A 会话断开 → 0001 删除 → B 收到通知 → 检查自己是否最小 → 持锁
text
fencing token:
  客户端 A 取锁 → token=33,GC 停顿
  TTL 到期,锁释放
  客户端 B 取锁 → token=34,写入存储(记录 lastToken=34)
  A 恢复,带 token=33 写入 → 存储拒绝(33 < 34)
  → 即使锁失效,也不会破坏数据
  • 版本/源码锚点:

    • Redis:SET key value NX PX(2.6.12+),释放用 Lua;Redisson 3.x:RLock.tryLock(waitTime, leaseTime, unit)、lockWatchdogTimeout(默认 30000ms)、续期周期为 1/3、getFairLock()、RReadWriteLock、getRedLock()、getMultiLock()。
    • ZK:create(path, data, CreateMode.EPHEMERAL_SEQUENTIAL)、getChildren、exists + watch;Curator 5.x InterProcessMutex;会话超时由 sessionTimeout 协商(受 minSessionTimeout/maxSessionTimeout 约束)。
    • etcd:lease + txn 比较版本,clientv3/concurrency 的 Mutex。
    • DB:MySQL 8.0 唯一索引、SELECT ... FOR UPDATE、innodb_lock_wait_timeout(默认 50s)。
    • 相关:幂等与去重见 5.1-2;对账见 6.5-13;Redisson 细节见 6.1-10。
  • 三方案对比:

维度RedisZooKeeper / etcdDB
一致性模型AP(主从异步)CP(多数派)单点/主从
加锁性能最高(万级 QPS)中(千级)低
防死锁TTL 过期临时节点 + 会话过期字段 / 事务
锁丢失风险主从切换、TTL 到期会话超时误判连接断开/超时
可重入需自己实现(Hash 计数)需自己实现需自己实现
公平性需额外实现(队列)天然顺序无
运维成本低中(需维护集群)低
适用高并发短临界区选主、配置、强一致低频、已有 DB
  • 关键参数:
参数默认/建议说明
Redis TTL按业务 P99 × 2–3太短易失效,太长故障恢复慢
Redisson watchdog30s / 10s 续期leaseTime=-1 时启用
waitTime有限值(如 3s)不要无限等待,防线程池耗尽
ZK sessionTimeout10–30s太长故障切换慢,太短易误判
Curator 重试有界退避避免重试风暴
innodb_lock_wait_timeout50s行锁等待上限
锁 key 粒度按业务主键粒度过大 RT 高,过小失去意义
  • 锁的替代方案:
场景替代原因
防重复插入唯一索引数据库天然互斥,无锁失效
状态流转update ... where status=旧值原子 CAS,无需锁
防超卖update stock set n=n-1 where n>0单语句原子
任务只跑一次队列 + 分区消费 / 选主串行化更彻底
读多写少乐观锁版本号冲突少时性能更好
跨服务编排Saga/状态机 + 幂等锁不适合长流程
  • 失效场景与定位:
现象根因处理
两个线程同时持锁TTL 到期/主从切换/GC 停顿fencing token + 缩短临界区
误删别人的锁GET+DEL 非原子Lua 比较 value
锁永久不释放无 TTL/续期线程死必须设 TTL + 监控
业务没跑完锁没了TTL 太短续期 + 评估 P99
大量请求等待超时粒度过大/临界区长缩小粒度、异步化
线程池被打满无限等待锁tryLock 带超时 + 降级
ZK 客户端频繁重连会话超时太短/网络抖动调大会话、就近部署
DB 连接池耗尽行锁长事务缩短事务、改用 Redis
定时任务重复执行锁丢失/无锁选主 + 幂等 + 对账
旧持有者写入脏数据无 fencing下游校验 token
  • 深挖点(面试官常追的 6 个):

    1. 为什么释放锁要用 Lua:如果先 GET 判断 value 是自己、再 DEL,这两步之间锁可能正好过期、被别人加上,DEL 就删掉了别人的锁。Lua 在 Redis 单线程里原子执行“比较 + 删除”,才能保证只删自己的。加锁本身也必须用一条 SET NX PX,不能用 SETNX + EXPIRE 两步。
    2. 锁过期了业务还没跑完怎么办:三种手段叠加——① 续期(看门狗)降低概率;② fencing token 让旧持有者的写入被下游拒绝;③ 业务幂等/状态机 让重复执行无害。只靠续期是不够的:进程长时间 Full GC、网络分区、容器被冻结时,续期线程根本没机会跑,锁照样过期。所以正确性不能建立在“续期一定成功”上。
    3. Redlock 到底能不能用:Redlock 的设计目标是“不依赖单点 Redis”,但它仍然假设各节点时钟漂移有界、客户端停顿有界。Kleppmann 指出:GC 停顿超过 TTL 时,客户端 A 以为还持锁,实际锁已过期被 B 拿走,A 恢复后写入 → 数据错乱;而 Redlock 没有 fencing,下游无法识别旧持有者。结论:短临界区、可容忍极小概率冲突可以用;资金、库存等强正确性场景不要用,改用 etcd/ZK 或数据库约束。
    4. ZK 为什么能避免羊群效应:所有等待者不 Watch 父节点,而是 Watch 自己的前一个顺序节点;锁释放时只有下一个节点被唤醒,而不是全部客户端同时抢。临时节点随会话消失,天然防死锁;但会话超时是“猜”的——客户端可能只是 GC 停顿,ZK 已判定会话失效并删节点,于是出现“两个客户端都以为自己持锁”,这同样需要 fencing 兜底。
    5. 可重入锁怎么实现:Redis 用 Hash 存 {owner: count},加锁时 HINCRBY,释放时递减,减到 0 才删除 key,并配套续期;ZK 用本地计数 + 同一个临时节点;Redisson 的 RLock 就是这套。可重入必须与 TTL 配合:重入次数不清零、TTL 不重置,否则内层释放会把外层锁删掉。
    6. 什么时候不该用分布式锁:能用唯一索引/状态机/乐观锁表达约束时,优先用数据层;能用队列串行化时,优先队列;临界区很长(跨 RPC、跨 DB 事务)时,锁的持有时间会放大所有风险,应该改成异步 + 补偿。锁是最后手段:它引入了一个新的单点(Redis/ZK),并让系统在锁服务故障时整体不可用。
  • 追问链:

    1. 什么是分布式锁? → 跨进程互斥访问临界区。
    2. 为什么本地锁不够? → 多实例、多 JVM。
    3. 锁要满足什么? → 互斥、防死锁、安全释放。
    4. Redis 怎么加锁? → SET key value NX PX。
    5. 为什么不用 SETNX+EXPIRE? → 两步非原子。
    6. value 存什么? → UUID+线程 ID。
    7. 释放怎么做? → Lua 比较后删除。
    8. 为什么用 Lua? → 防误删别人的锁。
    9. 锁过期了? → 别人可以拿。
    10. 业务没跑完怎么办? → 续期/看门狗。
    11. Redisson 默认多久? → 30s,10s 续一次。
    12. 续期一定可靠吗? → 不,GC/分区会失效。
    13. 那怎么保证正确? → fencing token + 下游校验。
    14. fencing 是什么? → 单调递增的锁版本。
    15. 下游怎么用? → 拒绝更小的 token。
    16. Redis 锁是 CP 吗? → 不是,是 AP。
    17. 主从切换会怎样? → 锁可能丢。
    18. Redlock 是什么? → 多独立 Redis 多数派加锁。
    19. Redlock 可靠吗? → 有争议,不是强一致。
    20. 争议点? → 时钟、GC、无 fencing。
    21. ZK 怎么实现锁? → 临时顺序节点。
    22. 谁拿到锁? → 序号最小者。
    23. 其他人等什么? → Watch 前一个节点。
    24. 为什么 Watch 前一个? → 避免羊群效应。
    25. 会话断开呢? → 临时节点删除,自动释放。
    26. ZK 是 CP 吗? → 是,多数派。
    27. ZK 锁的问题? → 性能、会话超时误判。
    28. DB 怎么做锁? → 唯一索引/行锁。
    29. 唯一索引锁怎么释放? → 删除记录/过期清理。
    30. 行锁怎么释放? → 事务提交/回滚。
    31. DB 锁缺点? → 性能差、连接占用。
    32. 可重入怎么做? → Hash 计数/本地计数。
    33. 公平锁? → 队列/顺序节点。
    34. 读写锁? → Redisson RReadWriteLock。
    35. 锁粒度怎么定? → 按业务主键,尽量小。
    36. 等待多久? → 有限超时 + 降级。
    37. 拿不到锁怎么办? → 快速失败/重试/排队。
    38. 锁和事务边界? → 锁内不要长事务。
    39. 锁能跨服务吗? → 能,但临界区越长越危险。
    40. 锁服务挂了? → 降级/本地限流/拒绝服务。
    41. 怎么监控? → 等待时间、持有时间、续期失败。
    42. 定时任务怎么防重? → 选主/锁 + 幂等。
    43. 库存扣减用锁吗? → 优先单语句/乐观锁。
    44. 什么时候不用锁? → 唯一索引/状态机/队列能解决时。
    45. 锁和幂等关系? → 锁防并发,幂等防重复。
    46. 锁和分布式事务关系? → 锁不保证原子性。
    47. etcd 锁呢? → lease + txn,CP。
    48. 跨机房怎么选? → etcd/ZK + fencing,或避免跨机房锁。
    49. 最常见的坑? → 以为续期能保证不双持。
    50. 面试怎么总结? → 先问要不要锁 → Redis/ZK/DB → 续期 → fencing → 替代方案。
  • 生产案例/取舍(示例,替换成你的项目):

    • 定时对账任务用 Redis 锁,主从切换时锁丢失,两个实例同时跑导致重复打款;改用 ZK 选主 + 幂等 + 对账。
    • 库存扣减用 Redis 锁,TTL 设 5s、业务偶尔 8s,出现超卖;改成 update stock set n=n-1 where n>0 单语句,去掉锁。
    • 释放锁用 GET + DEL,超时后误删别人的锁;改 Lua 后消失。
    • Redisson 看门狗线程与业务共用线程池,池满后续期失败;续期用独立线程池 + 监控。
    • 一次 Full GC 停顿 40s,锁过期被抢,旧实例恢复后写脏数据;引入 fencing token,存储拒绝旧版本写入。
    • Redlock 跨三个机房部署,网络抖动时加锁失败率高;评估后改为单机房 Redis + 业务幂等,跨机房不做强锁。
    • ZK 会话超时 5s,机房网络抖动频繁误判,锁反复释放;调到 30s + 就近部署。
    • 行锁实现任务互斥,长事务占满连接池;改短事务 + 唯一索引。
    • 锁粒度为“整个订单表”,所有请求串行;改为按 orderId 加锁,RT 下降 90%。
    • 拿不到锁无限自旋,线程池被打满;改 tryLock(3s) + 返回“处理中”。
    • 用锁保护“查余额再扣款”,锁过期后仍并发;改成 CAS 扣减 + 流水对账。
    • 取舍:Redis 换性能,代价是锁可能丢;ZK 换一致,代价是性能与运维;DB 换简单,代价是吞吐;续期换时长,代价是仍有失效窗口;fencing 换正确,代价是下游改造;不用锁换可用性,代价是业务模型要能表达约束。
  • 易错点:

    • 认为 Redis 锁一定可靠。
    • 认为 Redisson 看门狗能保证不双持。
    • 认为续期线程不会被 GC 影响。
    • 认为 Redlock 是强一致锁。
    • 认为 Redlock 不需要 fencing。
    • 认为 Redis 主从切换不影响锁。
    • 认为 SETNX + EXPIRE 和 SET NX PX 等价。
    • 认为释放锁可以先 GET 再 DEL。
    • 认为 value 随便存什么都行。
    • 认为锁不需要 TTL。
    • 认为有 TTL 就不会死锁。
    • 认为 ZK 锁不会出现双持。
    • 认为会话超时是精确的。
    • 认为 ZK 比 Redis 快。
    • 认为 DB 行锁适合高并发。
    • 认为唯一索引不能当锁。
    • 认为可重入不需要计数。
    • 认为可重入释放会重置 TTL 无所谓。
    • 认为公平锁是默认行为。
    • 认为等待锁可以无限自旋。
    • 认为锁内可以放长事务/RPC。
    • 认为锁能保证数据一致性。
    • 认为锁能替代幂等。
    • 认为拿不到锁就该一直等。
    • 认为锁服务挂了业务还能正常。
    • 认为跨机房锁和单机房一样。
    • 认为分布式锁没有性能成本。
    • 认为所有并发问题都该用锁解决。
  • 30 秒口述稿:

分布式锁先问“要不要锁”:唯一索引、状态机、乐观锁、队列串行能解决的,就别引入锁。真要锁,Redis 用 SET key owner NX PX 加锁、Lua 比较后删除释放,性能最好,但它是 AP,主从切换可能丢锁,TTL 到期也可能在业务没跑完时释放;Redisson 看门狗每 10 秒续一次 30 秒的 TTL,只能降低概率。ZK 用临时顺序节点,序号最小的持锁、其他人 Watch 前一个节点,会话断开自动释放,是 CP,但性能和运维成本更高;DB 用唯一索引或行锁,最简单但吞吐差。Redlock 跨多个 Redis 多数派加锁,有争议,它没有 fencing,GC 停顿或分区时仍可能双持,所以我不把它当强一致锁。真正兜底是 fencing token:锁服务发单调递增的版本号,下游拒绝更小的 token,旧持有者恢复也写不进去。最后,锁只保证尽量串行,正确性还要靠幂等和对账。

  • 3 分钟展开顺序:结论(三方案 + 续期不够 + fencing 兜底)→ 先问要不要锁与四个替代方案 → 锁的三个基本要求 → Redis 的 SET NX PX / Lua 释放 / AP 与主从切换 → 看门狗续期的时间线与失效场景 → ZK 临时顺序节点、Watch 前驱、CP 与会话超时 → DB 唯一索引与行锁的边界 → Redlock 算法与 Kleppmann 争议 → fencing token 的时序与下游校验 → 可重入/公平/读写锁 → 参数、监控与降级 → 案例与选型。