Appearance
2.4-4 读写锁、StampedLock 与适用场景
所属:02 Java 运行时 / 2.4 并发 分级:B(按 A 类模板展开) 状态:◐ 初稿 关联:2.4-3、2.4-5、2.4-9、2.4-10
题型:原理 / 对比 / 场景
一句话结论:ReentrantReadWriteLock 用 AQS 的 state 高低 16 位分离读计数和写计数,读锁共享、写锁独占,支持重入、公平和写锁降级,但读锁升级写锁会死锁;StampedLock 用 long stamp + 版本号做乐观读,读多写少吞吐更高,但不可重入、没有 Condition、必须
validate失败重试,适合短读且无副作用的场景。分层要点:
- 为什么需要读写锁:互斥锁把读读也串行化,但很多场景是“读多写少”,读操作之间不改变数据,可以并发。读写锁把锁分成共享的读锁和排他的写锁:读读不互斥,读写、写写互斥。
ReentrantReadWriteLock是 JDK 基于 AQS 的实现;StampedLock是 JDK 8 引入的另一条路线,用版本戳和乐观读进一步降低读路径开销。 - ReentrantReadWriteLock 的结构:内部
Sync extends AQS,把 32 位 state 拆成高 16 位读计数、低 16 位写计数,各自上限 65535。ReadLock.lock()走acquireShared(1),WriteLock.lock()走acquire(1);读锁是共享模式,写锁是独占模式。读锁用HoldCounter+ThreadLocal记录每个线程的重入次数,并用firstReader/firstReaderHoldCount优化“只有一个读线程”的常见情况;写锁直接用 state 低 16 位和exclusiveOwnerThread记录重入。 - 获取、释放与公平性:写锁
tryAcquire在 state 为 0 时 CAS,当前线程已是写锁持有者就增加低 16 位;读锁tryAcquireShared先检查是否有其他线程持有写锁,没有且readerShouldBlock()为 false 时 CAS 增加SHARED_UNIT。非公平模式的readerShouldBlock不是无条件插队:如果等待队列第一个是写线程,新读者会阻塞,避免写线程饥饿;公平模式用hasQueuedPredecessors。释放时写计数减到 0 就清 owner(降级时 state 里还可能有本线程持有的读计数),读计数减到 0 才真正释放共享状态。 - 锁降级与升级:写锁可以降级为读锁:先持有写锁,再获取读锁,最后释放写锁,读锁仍然持有;这样在释放写锁后仍能保持数据一致性,同时允许其他读者进入。读锁不能升级为写锁:当前线程持有读锁再去
writeLock().lock(),写锁会等待读计数归零,而读计数又被自己持有,直接死锁;多个读者时更不可能升级。tryLock失败也不能绕过这个语义。 - StampedLock 的乐观读:
StampedLock用long stamp表示一次锁状态,内部 state 的低 7 位是读计数、紧接着的 1 位是写标志、高位是版本号。写锁writeLock()返回 stamp,释放必须unlockWrite(stamp);读锁类似。tryOptimisticRead()不加锁,只返回当前版本戳;读完字段后validate(stamp)检查期间有没有写锁进入,失败就退化为普通读锁重读。它适合“读操作短、无副作用、可重试”的场景;乐观读期间数据可能不一致,不能直接拿去做业务副作用。 - StampedLock 的边界:它不是可重入锁,同一线程重复
writeLock()或持有写锁再readLock()会死锁;没有Condition,不能await/signal;不保证公平;unlock必须传对应的 stamp,传错会破坏状态。它提供tryConvertToWriteLock/ReadLock/OptimisticRead做有限转换,但不能当成通用的“读升级写”。读多写少、读临界区很短时它通常比 RRWL 吞吐高;需要重入、Condition、公平或复杂临界区时用 RRWL。
- 为什么需要读写锁:互斥锁把读读也串行化,但很多场景是“读多写少”,读操作之间不改变数据,可以并发。读写锁把锁分成共享的读锁和排他的写锁:读读不互斥,读写、写写互斥。
图/流程:
text
ReentrantReadWriteLock 的 state(32 位)
┌──────────────────────┬──────────────────────┐
│ 高 16 位:读计数 │ 低 16 位:写计数 │
└──────────────────────┴──────────────────────┘
读锁:acquireShared(1) → tryAcquireShared → 读计数 + 1
写锁:acquire(1) → tryAcquire → 写计数 + 1
写锁降级:
writeLock.lock()
readLock.lock() // 先拿读锁
writeLock.unlock() // 再释放写锁,读锁仍持有
...
readLock.unlock()text
StampedLock 的 state(long)
┌───────────────┬──────┬─────────────┐
│ 高位:版本号 │ 写位 │ 低 7 位读计数│
└───────────────┴──────┴─────────────┘
乐观读:
long stamp = lock.tryOptimisticRead();
int x = p.x; int y = p.y;
if (!lock.validate(stamp)) {
stamp = lock.readLock();
try { x = p.x; y = p.y; }
finally { lock.unlockRead(stamp); }
}版本/源码锚点:
- JDK 5+:
ReentrantReadWriteLock基于 AQS;state 高低 16 位拆分。 - JDK 8+:
StampedLock引入,stamp/version/optimistic read。 StampedLock不是 AQS 子类,内部是 stamp + 等待队列。- JDK 21:两者都基于
LockSupport.park,虚拟线程下通常比 synchronized 更友好。
- JDK 5+:
RRWL vs StampedLock 对比:
| 维度 | ReentrantReadWriteLock | StampedLock |
|---|---|---|
| 实现 | AQS,state 高低 16 位 | long state + stamp/version,非 AQS |
| 可重入 | 是 | 否 |
| 读锁 | 共享 | 共享 |
| 写锁 | 独占 | 独占 |
| 乐观读 | 不支持 | tryOptimisticRead + validate |
| Condition | 写锁支持,读锁不支持 | 不支持 |
| 公平性 | 可选公平/非公平 | 不保证公平 |
| 锁降级 | 写→读支持 | 有限转换 API |
| 读升级写 | 不支持,会死锁 | 不能通用升级 |
| 适用 | 需要重入/Condition/公平 | 读多写少、短读、可重试 |
- 选型表:
| 场景 | 建议 |
|---|---|
| 简单互斥 | synchronized |
| 需要 tryLock、超时、可中断、Condition | ReentrantLock |
| 读多写少,且需要重入/Condition/公平 | ReentrantReadWriteLock |
| 读多写少,读临界区短、无副作用、可重试 | StampedLock 乐观读 |
| 读操作里有 RPC/DB/大文件 IO | 不要持读锁做 IO,先取快照 |
追问链:
- RRWL 的 state 怎么表示读写? → 高 16 位读计数、低 16 位写计数;读锁 shared,写锁 exclusive;各自上限 65535。
- 读锁为什么能共享? →
ReadLock.lock()走 AQS 共享模式acquireShared;tryAcquireShared在没有其他线程持有写锁时增加读计数,多个读者可以同时成功。 - 写锁怎么实现重入? → state 低 16 位记录写重入次数,
exclusiveOwnerThread记录持有者;同一线程再次获取就加一,释放减到 0 才真正释放。 - 读锁的重入次数存在哪? →
HoldCounter+ThreadLocal,每个线程一份;firstReader/firstReaderHoldCount优化第一个读者,减少 ThreadLocal 访问。 - 什么是锁降级?为什么需要? → 持有写锁时再获取读锁,然后释放写锁,读锁仍持有;用于更新后继续以读锁保护数据,同时允许其他读者进入。
- 读锁为什么不能升级为写锁? → 写锁要等读计数归零,而当前线程自己持有读锁,无法释放,形成自等待死锁;多个读者时更无法升级。
- 非公平 RRWL 会不会让写线程饥饿? → 普通读锁可能插队,但
readerShouldBlock在队列第一个是写线程时会阻止新读者,给写线程让路;公平模式则完全按队列顺序。 - StampedLock 的乐观读是什么? →
tryOptimisticRead只取版本戳不加锁;读完后validate检查期间是否有写锁进入;失败就用普通读锁重读。 - 乐观读为什么必须重试? → 读的过程中可能被写线程修改,读到的字段可能来自不同版本;
validate失败说明快照无效,必须在读锁下重读。 - StampedLock 可重入吗? → 不可重入;同一线程重复加写锁,或持有写锁再加读锁,都会死锁;也不能用 Condition。
- StampedLock 的 stamp 是什么? → 一次锁状态的凭证;解锁必须传对应 stamp,失败获取通常返回 0,
validate(0)为 false。 - StampedLock 的转换 API 能替代锁升级吗? → 不能通用替代;
tryConvertToWriteLock只在特定状态下成功,失败返回 0;普通读锁升级写锁仍应避免。 - RRWL 和 StampedLock 怎么选? → 需要重入、Condition、公平、复杂临界区用 RRWL;读多写少、读很短、无副作用、能重试用 StampedLock 乐观读。
- 读写锁在虚拟线程下怎么选? → 两者都基于
LockSupport.park,通常不会像 synchronized 那样 pin 载体线程;但锁竞争和临界区长度仍是瓶颈。 - 读写锁有哪些生产坑? → 读锁里做慢 IO 导致写线程饥饿;读锁升级写锁死锁;StampedLock 忘记 validate 或 unlock 传错 stamp;把乐观读结果直接用于写操作。
生产案例/取舍(示例,替换成你的项目):
- 配置中心用 RRWL:读请求拿读锁,配置刷新拿写锁;刷新后先拿读锁再释放写锁做降级,保证新配置对后续读可见。若读锁里做远程配置拉取,写线程会长期饥饿,应改成“拉取到本地快照后短临界区替换引用”。
- 商品详情缓存用
StampedLock乐观读:读多写少,读操作只拷贝几个字段,validate失败就退化为读锁重读;写操作更新缓存时拿写锁。吞吐通常高于 RRWL,但代码复杂度也更高。 - 库存扣减不适合乐观读:读到的库存可能已过期,必须在写锁或数据库原子操作里完成“读-改-写”,不能拿乐观读结果直接扣减。
- 用 RRWL 实现“读锁升级写锁”导致线程永久阻塞;改成先释放读锁再获取写锁,或使用
StampedLock.tryConvertToWriteLock并处理失败。 - 取舍:RRWL 语义完整、易维护;StampedLock 读路径更快,但不可重入、无 Condition、需要重试,适合读多写少且能控制临界区的场景。
易错点:
- 认为读锁和写锁可以自由升级/降级;实际只支持写→读降级,读→写会死锁。
- 认为非公平读锁完全无视队列;实际首个等待者是写线程时会阻塞新读者。
- 认为 RRWL 的读锁和写锁都支持 Condition;
ReadLock.newCondition()会抛UnsupportedOperationException,只有写锁支持。 - 认为
StampedLock是 RRWL 的替代品;它不可重入、无 Condition、不保证公平。 - 乐观读不
validate,或先使用数据再验证。 StampedLock解锁传错 stamp,或忘记unlockRead/unlockWrite。- 在读锁里做 RPC/DB/大文件 IO,导致写线程饥饿、TP99 升高。
- 把
tryOptimisticRead当成真正的锁,认为读期间数据不会变。 - 用
StampedLock实现递归调用,导致自死锁。 - 认为 RRWL 的读锁是“只读”的;它只保证互斥语义,不阻止代码修改共享对象。
30 秒口述稿:
读写锁把锁拆成共享读锁和独占写锁,RRWL 用 AQS state 高 16 位读计数、低 16 位写计数,读读不互斥,读写/写写互斥;它可重入、可选公平,支持写锁降级为读锁,但读锁升级写锁会死锁。StampedLock 用 long stamp 和版本号,tryOptimisticRead 不加锁,读完 validate,失败再用读锁重读;读多写少吞吐更高,但不可重入、没有 Condition、不保证公平。需要重入/Condition/公平用 RRWL,短读无副作用可重试用 StampedLock。
- 3 分钟展开顺序:结论(读共享写独占 + 乐观读)→ 为什么需要读写锁 → RRWL state 高低 16 位与 HoldCounter → 读写获取/释放与公平性 → 锁降级/升级 → StampedLock stamp/乐观读/validate → 两者对比与选型 → 生产坑与案例。