Skip to content

6.1-10 Redisson 可重入锁、读写锁、看门狗 ​

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

  • 题型:原理 / 场景 / 源码

  • 一句话结论:Redisson 的 RLock 不是简单 SETNX,而是用 Hash 存「持有者 + 重入次数」、用 Lua 保证原子、用 Pub/Sub 唤醒等待者、用看门狗(默认 30s TTL、每 10s 续期)解决业务超时;tryLock 带 leaseTime 时关闭看门狗,lock() 不带租期时才启用。读写锁在同一套 Hash 上按模式(read/write)计数,实现读读共享、读写互斥、写写互斥。它把易用性做到了极致,但主从切换丢锁、GC 停顿、锁过期这些本质问题仍在,正确性仍要靠 fencing/幂等兜底(6.1-7)。

  • 分层要点:

    1. 数据结构:锁 key 是一个 Redis Hash,field 为 UUID:threadId(客户端唯一标识 + 线程),value 为重入次数。加锁时如果 key 不存在或 field 是自己,就 HINCRBY 1 并 PEXPIRE;否则返回剩余 TTL。释放时 HINCRBY -1,减到 0 才 DEL 并发布解锁消息。重入与互斥都靠这一个 Hash 表达。
    2. 原子性:加锁、释放、续期全部是 Lua 脚本,在 Redis 单线程内原子执行。这解决了三个经典问题:SETNX + EXPIRE 两步非原子、释放时“先 GET 再 DEL”误删别人的锁、重入计数与过期时间不一致。
    3. 等待机制:tryLock(waitTime, ...) 先在剩余时间内自旋尝试,失败后订阅解锁频道(redisson_lock__channel:{name}),收到 unlock 消息再抢;超时返回 false。它不是纯自旋(浪费 CPU),也不是严格队列(非公平,被唤醒的线程重新竞争,可能插队);需要公平性用 getFairLock()。
    4. 看门狗(watchdog):lock() 不传 leaseTime 时,默认租期是 lockWatchdogTimeout(30s),后台任务每 10s(1/3 租期) 续期一次,直到 unlock();续期记录在 EXPIRATION_RENEWAL_MAP,按“锁名 + 线程”索引,释放时取消。显式传 leaseTime 就不启用看门狗——到点必过期,适合“我确定能在 TTL 内跑完”的场景。
    5. 可重入的边界:同一个线程可以重复 lock(),计数递增;不同线程/不同客户端不能(field 不同)。unlock() 必须由持有线程调用,否则抛 IllegalMonitorStateException。异步 API(lockAsync)与响应式 API 也遵循同样语义。
    6. 读写锁:RReadWriteLock 用同一 Hash 的不同 field 记录读/写持有者与计数:读锁可多个线程同时持有(读读共享),写锁独占(读写、写写互斥);写锁可重入、读锁可重入,但不支持锁升级(读锁未释放时申请写锁会死锁),降级需先释放读锁。看门狗同样生效。
    7. 其他锁形态:getFairLock() 公平锁(按申请顺序排队,底层用 list + timeout zset);getMultiLock(l1, l2) 同时持有多个锁(全部成功才算成功);getRedLock(...)(3.12+ 取代 RedissonRedLock)对应 Redlock 算法;此外还有 RSemaphore、RCountDownLatch、RRateLimiter,都基于 Lua + Pub/Sub。
    8. 能力边界:Redisson 解决的是易用性与续期,不解决正确性:主节点宕机、异步复制未同步时锁会丢;Full GC/容器冻结时看门狗停摆、锁过期;网络分区下客户端可能“自以为持锁”。所以资金/库存类场景仍要 fencing token + 下游校验,或改用 etcd/ZK,并配合幂等(6.1-4)与对账(6.5-13)。
  • 图/流程:

text
加锁(Lua 原子):
  if key 不存在:
      HINCRBY key UUID:threadId 1
      PEXPIRE key 30000
      return nil
  if HEXISTS key UUID:threadId:
      HINCRBY key UUID:threadId 1
      PEXPIRE key 30000
      return nil
  return PTTL key        ← 失败,返回剩余租期
text
释放(Lua 原子):
  if not HEXISTS key UUID:threadId: return nil(不是自己的锁)
  count = HINCRBY key UUID:threadId -1
  if count > 0: PEXPIRE key 30000      ← 还有重入,续租
  else: DEL key; PUBLISH unlock channel
text
看门狗时间线(lock(),无 leaseTime):
  t=0     加锁,TTL=30s,注册续期任务
  t=10s   续期 → TTL=30s
  t=20s   续期 → TTL=30s
  ...
  unlock() → 取消任务 → DEL
  若进程 GC/冻结 > 30s → 无人续期 → 锁过期
text
读写锁状态:
  读锁:field = read:UUID:threadId,计数 N(多线程可同时持有)
  写锁:field = write:UUID:threadId,独占
  规则:读读兼容;读写互斥;写写互斥;不支持读→写升级
  • 版本/源码锚点:

    • 入口:RedissonClient.getLock(name)、getFairLock、getReadWriteLock、getMultiLock、getRedLock。
    • 实现:RedissonLock、RedissonFairLock、RedissonReadWriteLock、RedissonMultiLock、RedissonRedLock(3.12 起标记废弃,改用 getRedLock)。
    • 关键字段/结构:EXPIRATION_RENEWAL_MAP、ExpirationEntry、internalLockLeaseTime、lockWatchdogTimeout(默认 30000ms)、解锁频道 redisson_lock__channel:{name}。
    • Lua:tryLockInnerAsync、unlockInnerAsync、renewExpirationAsync。
    • 配置:Config.lockWatchdogTimeout;tryLock(waitTime, leaseTime, unit) 中 leaseTime=-1 表示启用看门狗。
    • 相关:分布式锁的选型与 fencing 见 6.1-7;Redis 持久化与主从见 4.2-4。
  • 锁形态对比:

形态API语义典型场景
普通互斥锁getLock独占、可重入、非公平通用互斥
公平锁getFairLock按申请顺序获得防饥饿、顺序敏感
读写锁getReadWriteLock读读共享、读写/写写互斥缓存刷新、配置读写
联锁getMultiLock多个锁全部持有多资源同时锁定
RedLockgetRedLock多独立 Redis 多数派跨集群(仍有争议)
  • 看门狗参数:
项默认说明
lockWatchdogTimeout30000ms未指定 leaseTime 时的租期
续期周期租期 / 3 = 10s由 RenewalTask 调度
触发条件leaseTime = -1传了 leaseTime 则不续期
取消时机unlock() / 线程结束从 EXPIRATION_RENEWAL_MAP 移除
续期失败抛异常/日志需监控,否则锁会静默过期
  • API 语义对比:
调用租期看门狗等待
lock()30s 起,自动续是无限等待
lock(leaseTime, unit)固定否无限等待
tryLock()30s 起,自动续是立即返回
tryLock(wait, unit)30s 起,自动续是最多 wait
tryLock(wait, lease, unit)固定否最多 wait
  • 失效场景与定位:
现象根因处理
锁提前失效用了 leaseTime 且业务超时改 lock() 或调大 leaseTime
锁不释放忘记 unlock/线程异常try-finally + 监控
IllegalMonitorStateException非持有线程释放修正调用线程
等待线程大量超时临界区过长/非公平插队缩小临界区、公平锁
主从切换后双持异步复制丢锁fencing + 唯一约束
看门狗没续期线程池满/进程冻结独立线程池 + 告警
读锁升级写锁死锁不支持升级先释放读锁再申请写锁
写锁阻塞所有读写锁持有时间长缩短写临界区
集群下 MultiLock 失败跨 slot/节点不可用评估是否真需要联锁
锁 key 被误删运维/其他业务同名key 前缀隔离
  • 深挖点(面试官常追的 6 个):

    1. Redisson 怎么实现可重入:Hash 的 field 是 UUID:threadId,value 是计数。同一线程再次加锁时,HEXISTS 命中自己 → HINCRBY 1,不会阻塞;释放时递减,减到 0 才真正 DEL。关键是加锁与释放都在 Lua 里完成,计数、过期时间、删除三步不会被其他命令打断;如果用多条命令,重入与过期就会出现竞态。
    2. 看门狗什么时候生效:只有不传 leaseTime(或传 -1)时才启用,默认租期 30s、每 10s 续一次;一旦显式传了 leaseTime,Redisson 认为你“确定业务时长”,不续期。所以线上常见事故是“tryLock(3, 5, SECONDS) 业务跑了 8 秒,锁 5 秒就过期”。看门狗也不是万能的:续期线程与业务共用线程池、进程被冻结、Full GC 超过 30s,锁照样过期。
    3. 等待者是怎么被唤醒的:tryLock 失败后订阅 redisson_lock__channel:{name},unlock 时 PUBLISH 一条消息,所有等待者被唤醒后重新竞争(Lua 抢锁),抢不到继续订阅。这比纯自旋省 CPU,但不是 FIFO,高并发下可能有人一直抢不到(饥饿);公平锁用 list + 超时 zset 记录排队顺序,代价是更多 Redis 操作与复杂度。
    4. 读写锁怎么做到读读共享:读锁在 Hash 里用 read:UUID:threadId 计数,多个线程各自 HINCRBY 互不冲突;写锁要求 Hash 中没有任何读/写 field,否则返回剩余 TTL 等待。释放读锁递减自己的计数;写锁同理。不支持升级(读锁持有期间申请写锁会等自己释放,形成死锁),降级也要先释放读锁再拿读锁,按业务需要设计。
    5. Redisson 锁在 Redis 故障时安全吗:不安全。主从异步复制下,主节点加锁后未同步就宕机,从节点升主后锁不存在;哨兵/集群切换同理。Redisson 不提供 fencing,下游无法识别旧持有者。缓解手段:WAIT 命令(有限增强)、单点 Redis + 业务幂等、或换 etcd/ZK;资金类必须加 fencing + 唯一约束 + 对账(6.1-7)。
    6. Redisson 还适合哪些场景:除了互斥锁,RSemaphore(限流/资源池)、RCountDownLatch(并行任务汇总)、RRateLimiter(令牌桶限流)、RMapCache(带过期的分布式 Map)、延迟队列(RDelayedQueue)。它们都基于 Lua 保证原子、Pub/Sub 做通知;但都继承 Redis 的 AP 特性,强一致场景要评估。
  • 追问链:

    1. Redisson 锁是什么结构? → Hash。
    2. field/value 是什么? → UUID:threadId / 重入次数。
    3. 怎么实现可重入? → 同 field 递增计数。
    4. 原子性怎么保证? → Lua。
    5. 释放逻辑? → 递减,0 则删除并发布。
    6. 不是持有者释放? → 报错。
    7. 看门狗是什么? → 自动续期。
    8. 默认租期? → 30s。
    9. 多久续一次? → 10s。
    10. 什么时候生效? → 不传 leaseTime。
    11. 传了 leaseTime? → 不续期。
    12. 续期失败? → 锁会过期。
    13. GC 停顿会怎样? → 续期停摆。
    14. 等待怎么实现? → 自旋 + Pub/Sub。
    15. 公平吗? → 默认非公平。
    16. 公平锁怎么开? → getFairLock。
    17. 公平锁代价? → 额外结构、性能低。
    18. 读写锁怎么实现? → 同 Hash 分 read/write field。
    19. 读读能并发吗? → 能。
    20. 读写呢? → 互斥。
    21. 写写呢? → 互斥。
    22. 能升级吗? → 不能,会死锁。
    23. 降级呢? → 先释放。
    24. MultiLock 是什么? → 多锁同时持有。
    25. RedLock 呢? → 多数派。
    26. RedLock 可靠吗? → 有争议。
    27. 主从切换会丢锁吗? → 会。
    28. 怎么兜底? → fencing/幂等/唯一约束。
    29. 锁 key 怎么设计? → 业务前缀 + 主键。
    30. 锁粒度? → 尽量小。
    31. 等待多久合适? → 有限超时。
    32. 拿不到锁? → 快速失败/降级。
    33. 锁内能放 RPC 吗? → 不建议。
    34. 锁和事务? → 锁内别放长事务。
    35. 看门狗线程池? → 独立配置。
    36. 怎么监控? → 等待时间、持有时间、续期失败。
    37. Redisson 还有哪些工具? → Semaphore/Latch/RateLimiter。
    38. 延迟队列? → RDelayedQueue。
    39. 集群下注意? → key slot/跨节点。
    40. 为什么不用 SETNX? → 不可重入、无续期。
    41. 为什么不用 ZK? → 性能/运维取舍。
    42. 锁过期但业务未完成? → 看门狗 + fencing。
    43. 看门狗能保证不双持吗? → 不能。
    44. Redisson 和 Jedis 区别? → 客户端能力封装。
    45. 异步 API? → lockAsync。
    46. 响应式? → RedissonRxClient。
    47. 版本差异? → 3.12 起 getRedLock。
    48. 锁名称冲突? → 前缀隔离。
    49. 能不能跨机房? → 不建议。
    50. 面试怎么总结? → Hash 可重入 → Lua 原子 → 看门狗续期 → Pub/Sub 等待 → 读写锁 → 边界靠 fencing。
  • 生产案例/取舍(示例,替换成你的项目):

    • 用 tryLock(3, 5, SECONDS) 做订单处理,业务偶发 8s,锁提前释放导致重复发货;改 lock() + 看门狗。
    • 看门狗与业务共用线程池,池满后续期失败、锁静默过期;拆独立线程池 + 续期失败告警。
    • Redis 主从切换,锁丢失,两个实例同时跑对账;加唯一约束 + 对账去重。
    • 读锁未释放就申请写锁,线程永久阻塞;改为先释放读锁再升级。
    • 默认非公平锁,高并发下某线程一直抢不到;改公平锁,吞吐略降但延迟稳定。
    • unlock() 写在 finally,但线程池切换导致非持有线程释放报错;固定执行线程。
    • 锁 key 用业务名,两个业务撞 key 互相阻塞;加业务前缀。
    • 集群模式下 MultiLock 跨 slot 操作失败;改为单 key 设计。
    • Full GC 40s,锁过期被抢,旧实例恢复后写脏数据;引入 fencing token。
    • 锁持有时间监控缺失,RT 升高才发现临界区里有慢 SQL;加持有时间指标 + 缩小临界区。
    • 用 Redisson 做限流(RRateLimiter)替代手写令牌桶,代码量下降;但强一致限流仍要评估。
    • 取舍:看门狗换“业务不超时”,代价是续期线程与 GC 风险;leaseTime 换“确定过期”,代价是业务超时丢锁;公平锁换“不饥饿”,代价是吞吐;读写锁换“读并发”,代价是写饥饿;Redis 换性能,代价是主从切换丢锁。
  • 易错点:

    • 认为 Redisson 锁就是 SETNX。
    • 认为锁 value 是随机字符串。
    • 认为可重入靠本地计数。
    • 认为释放不需要校验持有者。
    • 认为看门狗一直生效。
    • 认为传了 leaseTime 还会续期。
    • 认为看门狗能防 GC 停顿。
    • 认为看门狗线程不会挂。
    • 认为锁过期后业务一定安全。
    • 认为等待是 FIFO。
    • 认为公平锁是默认。
    • 认为 Pub/Sub 能保证顺序。
    • 认为读写锁支持升级。
    • 认为读锁会阻塞读锁。
    • 认为写锁不阻塞读锁。
    • 认为 MultiLock 没有额外失败面。
    • 认为 RedLock 是强一致。
    • 认为 Redisson 能防主从切换丢锁。
    • 认为有锁就不需要幂等。
    • 认为锁内可以放 RPC/长事务。
    • 认为锁 key 不需要前缀。
    • 认为锁粒度越大越好。
    • 认为等待可以无限。
    • 认为锁不会饥饿。
    • 认为 Redisson 只有锁。
    • 认为 lockAsync 语义不同。
    • 认为 3.12 前后 RedLock API 一样。
    • 认为 Redis 锁和 ZK 锁可随意替换。
  • 30 秒口述稿:

Redisson 的锁不是简单 SETNX。它用 Hash 存锁,field 是客户端 UUID 加线程 ID,value 是重入次数,加锁、释放、续期都是 Lua,保证原子。同一线程重复加锁就递增计数,减到 0 才真正删除并发布解锁消息,等待者通过 Pub/Sub 被唤醒后重新竞争,所以默认是非公平的,要公平用 getFairLock。看门狗只在没传 leaseTime 时生效,默认 30 秒租期、每 10 秒续一次,unlock 时取消;传了 leaseTime 就不续期,业务超时锁会提前释放,这是线上常见事故。读写锁在同一个 Hash 上分 read/write 计数,读读共享、读写和写写互斥,不支持读锁升级写锁。最后要强调,Redisson 只解决易用性,不解决主从切换丢锁和 GC 停顿,资金类还是要 fencing 加唯一约束兜底。

  • 3 分钟展开顺序:结论(Hash + Lua + 看门狗 + Pub/Sub)→ 数据结构与可重入原理 → 加锁/释放的 Lua 逻辑 → 等待机制与非公平性 → 看门狗的生效条件、时间线与失效场景 → leaseTime 与看门狗的取舍 → 读写锁的共享/互斥/升级限制 → 公平锁、MultiLock、RedLock 的定位 → 与 6.1-7 的边界(主从切换、fencing、幂等)→ 监控指标与案例。