Skip to content

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 失败重试,适合短读且无副作用的场景。

  • 分层要点:

    1. 为什么需要读写锁:互斥锁把读读也串行化,但很多场景是“读多写少”,读操作之间不改变数据,可以并发。读写锁把锁分成共享的读锁和排他的写锁:读读不互斥,读写、写写互斥。ReentrantReadWriteLock 是 JDK 基于 AQS 的实现;StampedLock 是 JDK 8 引入的另一条路线,用版本戳和乐观读进一步降低读路径开销。
    2. ReentrantReadWriteLock 的结构:内部 Sync extends AQS,把 32 位 state 拆成高 16 位读计数、低 16 位写计数,各自上限 65535。ReadLock.lock() 走 acquireShared(1),WriteLock.lock() 走 acquire(1);读锁是共享模式,写锁是独占模式。读锁用 HoldCounter + ThreadLocal 记录每个线程的重入次数,并用 firstReader/firstReaderHoldCount 优化“只有一个读线程”的常见情况;写锁直接用 state 低 16 位和 exclusiveOwnerThread 记录重入。
    3. 获取、释放与公平性:写锁 tryAcquire 在 state 为 0 时 CAS,当前线程已是写锁持有者就增加低 16 位;读锁 tryAcquireShared 先检查是否有其他线程持有写锁,没有且 readerShouldBlock() 为 false 时 CAS 增加 SHARED_UNIT。非公平模式的 readerShouldBlock 不是无条件插队:如果等待队列第一个是写线程,新读者会阻塞,避免写线程饥饿;公平模式用 hasQueuedPredecessors。释放时写计数减到 0 就清 owner(降级时 state 里还可能有本线程持有的读计数),读计数减到 0 才真正释放共享状态。
    4. 锁降级与升级:写锁可以降级为读锁:先持有写锁,再获取读锁,最后释放写锁,读锁仍然持有;这样在释放写锁后仍能保持数据一致性,同时允许其他读者进入。读锁不能升级为写锁:当前线程持有读锁再去 writeLock().lock(),写锁会等待读计数归零,而读计数又被自己持有,直接死锁;多个读者时更不可能升级。tryLock 失败也不能绕过这个语义。
    5. StampedLock 的乐观读:StampedLock 用 long stamp 表示一次锁状态,内部 state 的低 7 位是读计数、紧接着的 1 位是写标志、高位是版本号。写锁 writeLock() 返回 stamp,释放必须 unlockWrite(stamp);读锁类似。tryOptimisticRead() 不加锁,只返回当前版本戳;读完字段后 validate(stamp) 检查期间有没有写锁进入,失败就退化为普通读锁重读。它适合“读操作短、无副作用、可重试”的场景;乐观读期间数据可能不一致,不能直接拿去做业务副作用。
    6. 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 更友好。
  • RRWL vs StampedLock 对比:

维度ReentrantReadWriteLockStampedLock
实现AQS,state 高低 16 位long state + stamp/version,非 AQS
可重入是否
读锁共享共享
写锁独占独占
乐观读不支持tryOptimisticRead + validate
Condition写锁支持,读锁不支持不支持
公平性可选公平/非公平不保证公平
锁降级写→读支持有限转换 API
读升级写不支持,会死锁不能通用升级
适用需要重入/Condition/公平读多写少、短读、可重试
  • 选型表:
场景建议
简单互斥synchronized
需要 tryLock、超时、可中断、ConditionReentrantLock
读多写少,且需要重入/Condition/公平ReentrantReadWriteLock
读多写少,读临界区短、无副作用、可重试StampedLock 乐观读
读操作里有 RPC/DB/大文件 IO不要持读锁做 IO,先取快照
  • 追问链:

    1. RRWL 的 state 怎么表示读写? → 高 16 位读计数、低 16 位写计数;读锁 shared,写锁 exclusive;各自上限 65535。
    2. 读锁为什么能共享? → ReadLock.lock() 走 AQS 共享模式 acquireShared;tryAcquireShared 在没有其他线程持有写锁时增加读计数,多个读者可以同时成功。
    3. 写锁怎么实现重入? → state 低 16 位记录写重入次数,exclusiveOwnerThread 记录持有者;同一线程再次获取就加一,释放减到 0 才真正释放。
    4. 读锁的重入次数存在哪? → HoldCounter + ThreadLocal,每个线程一份;firstReader/firstReaderHoldCount 优化第一个读者,减少 ThreadLocal 访问。
    5. 什么是锁降级?为什么需要? → 持有写锁时再获取读锁,然后释放写锁,读锁仍持有;用于更新后继续以读锁保护数据,同时允许其他读者进入。
    6. 读锁为什么不能升级为写锁? → 写锁要等读计数归零,而当前线程自己持有读锁,无法释放,形成自等待死锁;多个读者时更无法升级。
    7. 非公平 RRWL 会不会让写线程饥饿? → 普通读锁可能插队,但 readerShouldBlock 在队列第一个是写线程时会阻止新读者,给写线程让路;公平模式则完全按队列顺序。
    8. StampedLock 的乐观读是什么? → tryOptimisticRead 只取版本戳不加锁;读完后 validate 检查期间是否有写锁进入;失败就用普通读锁重读。
    9. 乐观读为什么必须重试? → 读的过程中可能被写线程修改,读到的字段可能来自不同版本;validate 失败说明快照无效,必须在读锁下重读。
    10. StampedLock 可重入吗? → 不可重入;同一线程重复加写锁,或持有写锁再加读锁,都会死锁;也不能用 Condition。
    11. StampedLock 的 stamp 是什么? → 一次锁状态的凭证;解锁必须传对应 stamp,失败获取通常返回 0,validate(0) 为 false。
    12. StampedLock 的转换 API 能替代锁升级吗? → 不能通用替代;tryConvertToWriteLock 只在特定状态下成功,失败返回 0;普通读锁升级写锁仍应避免。
    13. RRWL 和 StampedLock 怎么选? → 需要重入、Condition、公平、复杂临界区用 RRWL;读多写少、读很短、无副作用、能重试用 StampedLock 乐观读。
    14. 读写锁在虚拟线程下怎么选? → 两者都基于 LockSupport.park,通常不会像 synchronized 那样 pin 载体线程;但锁竞争和临界区长度仍是瓶颈。
    15. 读写锁有哪些生产坑? → 读锁里做慢 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 → 两者对比与选型 → 生产坑与案例。