Appearance
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)。分层要点:
- 数据结构:锁 key 是一个 Redis Hash,field 为
UUID:threadId(客户端唯一标识 + 线程),value 为重入次数。加锁时如果 key 不存在或 field 是自己,就HINCRBY 1并PEXPIRE;否则返回剩余 TTL。释放时HINCRBY -1,减到 0 才DEL并发布解锁消息。重入与互斥都靠这一个 Hash 表达。 - 原子性:加锁、释放、续期全部是 Lua 脚本,在 Redis 单线程内原子执行。这解决了三个经典问题:
SETNX + EXPIRE两步非原子、释放时“先 GET 再 DEL”误删别人的锁、重入计数与过期时间不一致。 - 等待机制:
tryLock(waitTime, ...)先在剩余时间内自旋尝试,失败后订阅解锁频道(redisson_lock__channel:{name}),收到 unlock 消息再抢;超时返回 false。它不是纯自旋(浪费 CPU),也不是严格队列(非公平,被唤醒的线程重新竞争,可能插队);需要公平性用getFairLock()。 - 看门狗(watchdog):
lock()不传leaseTime时,默认租期是lockWatchdogTimeout(30s),后台任务每 10s(1/3 租期) 续期一次,直到unlock();续期记录在EXPIRATION_RENEWAL_MAP,按“锁名 + 线程”索引,释放时取消。显式传leaseTime就不启用看门狗——到点必过期,适合“我确定能在 TTL 内跑完”的场景。 - 可重入的边界:同一个线程可以重复
lock(),计数递增;不同线程/不同客户端不能(field 不同)。unlock()必须由持有线程调用,否则抛IllegalMonitorStateException。异步 API(lockAsync)与响应式 API 也遵循同样语义。 - 读写锁:
RReadWriteLock用同一 Hash 的不同 field 记录读/写持有者与计数:读锁可多个线程同时持有(读读共享),写锁独占(读写、写写互斥);写锁可重入、读锁可重入,但不支持锁升级(读锁未释放时申请写锁会死锁),降级需先释放读锁。看门狗同样生效。 - 其他锁形态:
getFairLock()公平锁(按申请顺序排队,底层用 list + timeout zset);getMultiLock(l1, l2)同时持有多个锁(全部成功才算成功);getRedLock(...)(3.12+ 取代RedissonRedLock)对应 Redlock 算法;此外还有RSemaphore、RCountDownLatch、RRateLimiter,都基于 Lua + Pub/Sub。 - 能力边界:Redisson 解决的是易用性与续期,不解决正确性:主节点宕机、异步复制未同步时锁会丢;Full GC/容器冻结时看门狗停摆、锁过期;网络分区下客户端可能“自以为持锁”。所以资金/库存类场景仍要 fencing token + 下游校验,或改用 etcd/ZK,并配合幂等(6.1-4)与对账(6.5-13)。
- 数据结构:锁 key 是一个 Redis Hash,field 为
图/流程:
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 channeltext
看门狗时间线(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 | 多个锁全部持有 | 多资源同时锁定 |
| RedLock | getRedLock | 多独立 Redis 多数派 | 跨集群(仍有争议) |
- 看门狗参数:
| 项 | 默认 | 说明 |
|---|---|---|
lockWatchdogTimeout | 30000ms | 未指定 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 个):
- Redisson 怎么实现可重入:Hash 的 field 是
UUID:threadId,value 是计数。同一线程再次加锁时,HEXISTS命中自己 →HINCRBY 1,不会阻塞;释放时递减,减到 0 才真正DEL。关键是加锁与释放都在 Lua 里完成,计数、过期时间、删除三步不会被其他命令打断;如果用多条命令,重入与过期就会出现竞态。 - 看门狗什么时候生效:只有不传
leaseTime(或传-1)时才启用,默认租期 30s、每 10s 续一次;一旦显式传了leaseTime,Redisson 认为你“确定业务时长”,不续期。所以线上常见事故是“tryLock(3, 5, SECONDS)业务跑了 8 秒,锁 5 秒就过期”。看门狗也不是万能的:续期线程与业务共用线程池、进程被冻结、Full GC 超过 30s,锁照样过期。 - 等待者是怎么被唤醒的:
tryLock失败后订阅redisson_lock__channel:{name},unlock时PUBLISH一条消息,所有等待者被唤醒后重新竞争(Lua 抢锁),抢不到继续订阅。这比纯自旋省 CPU,但不是 FIFO,高并发下可能有人一直抢不到(饥饿);公平锁用 list + 超时 zset 记录排队顺序,代价是更多 Redis 操作与复杂度。 - 读写锁怎么做到读读共享:读锁在 Hash 里用
read:UUID:threadId计数,多个线程各自HINCRBY互不冲突;写锁要求 Hash 中没有任何读/写 field,否则返回剩余 TTL 等待。释放读锁递减自己的计数;写锁同理。不支持升级(读锁持有期间申请写锁会等自己释放,形成死锁),降级也要先释放读锁再拿读锁,按业务需要设计。 - Redisson 锁在 Redis 故障时安全吗:不安全。主从异步复制下,主节点加锁后未同步就宕机,从节点升主后锁不存在;哨兵/集群切换同理。Redisson 不提供 fencing,下游无法识别旧持有者。缓解手段:
WAIT命令(有限增强)、单点 Redis + 业务幂等、或换 etcd/ZK;资金类必须加 fencing + 唯一约束 + 对账(6.1-7)。 - Redisson 还适合哪些场景:除了互斥锁,
RSemaphore(限流/资源池)、RCountDownLatch(并行任务汇总)、RRateLimiter(令牌桶限流)、RMapCache(带过期的分布式 Map)、延迟队列(RDelayedQueue)。它们都基于 Lua 保证原子、Pub/Sub 做通知;但都继承 Redis 的 AP 特性,强一致场景要评估。
- Redisson 怎么实现可重入:Hash 的 field 是
追问链:
- Redisson 锁是什么结构? → Hash。
- field/value 是什么? →
UUID:threadId/ 重入次数。 - 怎么实现可重入? → 同 field 递增计数。
- 原子性怎么保证? → Lua。
- 释放逻辑? → 递减,0 则删除并发布。
- 不是持有者释放? → 报错。
- 看门狗是什么? → 自动续期。
- 默认租期? → 30s。
- 多久续一次? → 10s。
- 什么时候生效? → 不传 leaseTime。
- 传了 leaseTime? → 不续期。
- 续期失败? → 锁会过期。
- GC 停顿会怎样? → 续期停摆。
- 等待怎么实现? → 自旋 + Pub/Sub。
- 公平吗? → 默认非公平。
- 公平锁怎么开? →
getFairLock。 - 公平锁代价? → 额外结构、性能低。
- 读写锁怎么实现? → 同 Hash 分 read/write field。
- 读读能并发吗? → 能。
- 读写呢? → 互斥。
- 写写呢? → 互斥。
- 能升级吗? → 不能,会死锁。
- 降级呢? → 先释放。
- MultiLock 是什么? → 多锁同时持有。
- RedLock 呢? → 多数派。
- RedLock 可靠吗? → 有争议。
- 主从切换会丢锁吗? → 会。
- 怎么兜底? → fencing/幂等/唯一约束。
- 锁 key 怎么设计? → 业务前缀 + 主键。
- 锁粒度? → 尽量小。
- 等待多久合适? → 有限超时。
- 拿不到锁? → 快速失败/降级。
- 锁内能放 RPC 吗? → 不建议。
- 锁和事务? → 锁内别放长事务。
- 看门狗线程池? → 独立配置。
- 怎么监控? → 等待时间、持有时间、续期失败。
- Redisson 还有哪些工具? → Semaphore/Latch/RateLimiter。
- 延迟队列? →
RDelayedQueue。 - 集群下注意? → key slot/跨节点。
- 为什么不用 SETNX? → 不可重入、无续期。
- 为什么不用 ZK? → 性能/运维取舍。
- 锁过期但业务未完成? → 看门狗 + fencing。
- 看门狗能保证不双持吗? → 不能。
- Redisson 和 Jedis 区别? → 客户端能力封装。
- 异步 API? →
lockAsync。 - 响应式? →
RedissonRxClient。 - 版本差异? → 3.12 起
getRedLock。 - 锁名称冲突? → 前缀隔离。
- 能不能跨机房? → 不建议。
- 面试怎么总结? → 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 锁可随意替换。
- 认为 Redisson 锁就是
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、幂等)→ 监控指标与案例。