知序
返回
保存草稿
发布
H1
H2
H3
1
2
3
Excalidraw 图
AI 写作
AI 优化
目录
输入内容后显示目录
Markdown
# 读写锁与 StampedLock > 导读:本文从"一个读多写少的缓存,明明没多少写操作,为什么还是会被锁拖慢,写线程又为什么迟迟拿不到锁"这一具体疑问出发,把 ReentrantReadWriteLock 的读写互斥规则、锁降级与锁升级、公平性与写锁饥饿,以及 StampedLock 的写锁/悲观读/乐观读三种模式与 stamp 校验机制逐项讲透,最后给出生产选型与踩坑。适合已经会用 synchronized / ReentrantLock、想搞懂读写锁边界与 StampedLock 取舍的同学。 ## 一、先建立全局认知 ### Q:读多写少的场景,为什么用普通互斥锁会"浪费"? A:结论先行——普通互斥锁(synchronized / ReentrantLock)在任何时刻只允许一个线程进入临界区,两个纯读操作本身不冲突,却被迫排队,这是纯浪费。 为什么:互斥锁的语义是"独占",它不区分你到底是想读还是想写。假设一个配置缓存,99% 的请求只是读 `get(key)`,1% 的请求是 `reload()` 全量刷新。用 ReentrantLock 时,两个读 `get` 的线程也会互相阻塞,等于把本可以并行的读操作串行化了。CPU 核心越多,这种浪费越明显——因为多出来的核心全都在等同一把锁。 证据/示例:下面这段代码就有"读-读互斥"问题。 ```java import java.util.HashMap; import java.util.Map; import java.util.concurrent.locks.ReentrantLock; public class ConfigCache { private final Map<String, String> cache = new HashMap<>(); private final ReentrantLock lock = new ReentrantLock(); // 读:被独占锁串行化,多个读线程无法并行 public String get(String key) { lock.lock(); try { return cache.get(key); } finally { lock.unlock(); } } public void put(String key, String value) { lock.lock(); try { cache.put(key, value); } finally { lock.unlock(); } } } ``` 关键点:读操作不会修改 `cache`,从数据安全角度多个读线程并存完全没问题,是锁的语义把并行度压到了 1。预期行为是读吞吐受限于锁串行,而不是受限于 CPU。适用场景就是"读多写少且临界区不短"——如果临界区只有一两条指令,加锁开销本身也可能盖过收益(这点后文评判)。 ### Q:ReentrantReadWriteLock 到底允许多少种并发组合? A:结论先行——读-读可并发、读-写互斥、写-写互斥;一旦有线程持写锁,任何其他读/写线程都必须等。 为什么:`ReentrantReadWriteLock`(可重入读写锁)把"锁"拆成两把逻辑锁:读锁(共享锁)与写锁(排他锁),底层共用同一个 AQS 同步器,通过同步状态 state 的高低 16 位分别记录读计数与写计数。共享语义让多个持有读锁的线程可以同时进入,排他语义让写锁独占。二者混合的规则如下。 | 当前持锁情况 | 新来读锁请求 | 新来写锁请求 | | --- | --- | --- | | 无锁 | 允许 | 允许 | | 已有一个或多个读锁(无写锁) | 允许(读读共享) | 阻塞等待 | | 已有写锁 | 阻塞等待 | 同一线程可重入;其他线程阻塞 | 证据/示例:读锁与写锁是两个独立对象,但语义互相约束。 ```java import java.util.concurrent.locks.ReentrantReadWriteLock; import java.util.concurrent.locks.Lock; ReentrantReadWriteLock rw = new ReentrantReadWriteLock(); Lock readLock = rw.readLock(); Lock writeLock = rw.writeLock(); // 线程 A、B 同时拿读锁:都能进去 readLock.lock(); try { // 只读临界区 } finally { readLock.unlock(); } // 线程 C 拿写锁时必须等 A、B 都释放读锁 writeLock.lock(); try { // 写临界区,此时没有任何读线程 } finally { writeLock.unlock(); } ``` 关键点:`readLock()` 返回的是共享锁,`writeLock()` 返回的是排他锁,但切记"先拿读锁再尝试拿写锁"会在同一线程里把自己锁死(详见下一节锁升级)。不适用场景:写操作占比高、或者临界区极短时,读写锁的管理开销(两把锁、计数维护、唤醒逻辑)可能反而比一把 ReentrantLock 更重。 ### Q:既然读写锁这么好,为什么说它不是万能的? A:结论先行——读多写少才有收益,写作密集、临界区极短、竞争已经很高时,读写锁可能不如普通锁甚至更慢,而且默认非公平模式下写线程可能被饿死。 为什么有三点: 1. **写多场景收益消失**。写操作之间本来就互斥,读写锁在写密集时退化得和普通互斥锁差不多,还多了一层读计数维护。 2. **锁竞争已经很重时**,AQS 队列的唤醒与 park/unpark 成本占主导,读读并发带来的收益被稀释。 3. **默认非公平模式下写锁饥饿**:读线程可以"插队"不断拿读锁,写线程可能在队列里一直等(原因见第二节)。 因此判断是否该用读写锁,不能只看"读多写少"这四个字,还要看临界区长度、读写比例量级、以及能否容忍写操作的延迟。这条经验在《Java 并发编程实践》里也反复强调:先测量,再决定。 ## 二、理解核心机制 ### Q:读锁和写锁在一把锁里怎么同时存在? A:结论先行——`ReentrantReadWriteLock` 用一个 AQS 的 int 型 state 同时编码读写计数:高 16 位存读锁持有数,低 16 位存写锁持有数。 为什么:AQS 只提供"一个 state + 一个队列",而读写锁需要同时表达"当前有几个读、有没有写"。如果把读写分成两个独立的 AQS,就会破坏原子性——读写之间的互斥判断必须基于同一份状态快照,所以设计上用位分段(bit packing)把两个计数塞进一个 int。 证据/示例(源码字段与位移含义):  *图:读写锁与 StampedLock:state 位拆分与计数提取* ```text state(32 位 int) ┌───────────────────────┬───────────────────────┐ │ 高 16 位:读锁计数 │ 低 16 位:写锁计数 │ └───────────────────────┴───────────────────────┘ SHARED_SHIFT = 16 EXCLUSIVE_MASK = (1 << 16) - 1 = 0xFFFF sharedCount(c) = c >>> 16 // 读计数 exclusiveCount(c) = c & EXCLUSIVE_MASK // 写计数 ``` 由此推出两个硬限制: - 读锁最多 65535(2^16−1)个,写锁最多 65535 层重入; - 写锁是低 16 位,读锁是高 16 位,所以判断"是否有写锁"只需看低位是否为 0。 关键点:理解了位分段,就能明白"写锁拿不到时为什么连读锁也会挡"——写锁尝试获取时要判断低位之外整个 state 是否都为 0(即 `c != 0` 就失败),因此只要还有任何读锁,写锁就进不来。至于同一线程的读锁重入计数,`ReentrantReadWriteLock` 额外用了一个 `ThreadLocal` 维护 `HoldCounter`(每个线程自己持有多少把读锁),这样才能实现"读锁可重入"以及锁降级里的持有判断。 ### Q:锁降级是什么?为什么降级可行? A:结论先行——锁降级指"先持有写锁,再获取读锁,然后释放写锁",最终以读锁身份继续读;这个方向是安全的,所以可行。 为什么:降级的本质是"持有写锁的线程,在它自己独占期间再去拿读锁",此时没有任何其他读/写线程干扰,读锁能立刻拿到;拿到读锁后再释放写锁,整个过程中数据一直处于本线程的保护之下,其他写线程无法插进来,因此不会读到半更新状态。 证据/示例(典型的"更新后继续读"降级用法): ```java import java.util.concurrent.locks.ReentrantReadWriteLock; import java.util.concurrent.locks.Lock; ReentrantReadWriteLock rw = new ReentrantReadWriteLock(); Lock readLock = rw.readLock(); Lock writeLock = rw.writeLock(); public void updateThenRead() { writeLock.lock(); boolean downgraded = false; try { // 1. 修改数据(此时独占) // modifyState(); // 2. 在释放写锁前先获取读锁 —— 降级 readLock.lock(); downgraded = true; // 3. 释放写锁,仍持有读锁,可继续安全读取 writeLock.unlock(); // ... 后续只读操作受读锁保护,其他写线程进不来 } finally { if (downgraded) { readLock.unlock(); } else { writeLock.unlock(); } } } ``` 关键点:降级的正确姿势是"读锁必须在写锁释放**之前**获取",顺序不能反。不适用场景:如果你只是单纯改完就结束,根本不需要再读一次,那没必要降级——降级只在"改完之后还要连续读取、且希望保持弱一致视角"时才有意义(比如缓存更新后立即返回最新值)。 ### Q:锁升级为什么不可行? A:结论先行——升级(持有读锁时去拿写锁)在 `ReentrantReadWriteLock` 里不支持,会直接把当前线程死锁(self-deadlock)。 为什么:写锁的获取条件是"state 的写计数为 0 且读计数为 0",也就是所有读锁都已释放。而当前线程自己正持有读锁,读计数不可能是 0;同时写锁又要求释放读锁后自己排队,于是形成"我需要自己先放手、但我又在等自己"的循环等待。这不是实现缺陷,而是共享锁与排他锁的内存语义决定的——如果允许升级,两个都持读锁的线程可能同时想升级,彼此又都不肯先释放读锁,谁都无法推进。 证据/示例(这段代码会卡死): ```java import java.util.concurrent.locks.ReentrantReadWriteLock; import java.util.concurrent.locks.Lock; ReentrantReadWriteLock rw = new ReentrantReadWriteLock(); Lock readLock = rw.readLock(); Lock writeLock = rw.writeLock(); public void wrongUpgrade() { readLock.lock(); try { // 读过程中发现要修改,尝试升级为写锁 writeLock.lock(); // ❌ 当前线程永久阻塞在这里 try { // 永远到不了这里 } finally { writeLock.unlock(); } } finally { readLock.unlock(); } } ``` 关键点:正确做法是"先释放读锁,再重新申请写锁",然后**重新校验**数据是否还是你以为的样子(因为中间可能被别的写线程改过)。这就是典型的"双检 / 重读-比较-再写"模式。不适用场景:如果你能确定临界区内不需要读后写,就别做升级动作。 ### Q:读锁也是可重入的,可线程怎么知道自己持有几把读锁? A:结论先行——读锁的重入不能记在共享的 state 里,`ReentrantReadWriteLock` 额外用一个 `ThreadLocal` 保存"本线程持有多少把读锁"(`HoldCounter`),这就是它读路径开销高于普通锁的一个原因。 为什么:写锁的重入计数可以直接放进 state 的低 16 位,因为写锁是排他的,低位那个计数天然属于唯一持有者。但读锁不同——state 高 16 位是所有读线程共享的"总读计数",它无法区分"当前这 3 把读锁里有几把是我自己持有的"。于是实现上引入两个辅助结构: - **`HoldCounter`**:两个字段 `count`(本线程持有读锁次数)与 `tid`(线程 ID); - **`ThreadLocalHoldCounter`**:一个 `ThreadLocal<HoldCounter>` 容器,并缓存"上一次成功获取读锁的线程的 HoldCounter",减少 ThreadLocal 查找。 读锁获取的大致流程(伪代码,细节以源码为准): ```text readLock().lock() -> Sync.acquireShared(1) -> tryAcquireShared(1): 1. 若有其他线程持有写锁 → 获取失败,进入队列排队 2. 按公平/非公平规则判断当前是否应阻塞读(readerShouldBlock)→ 是则失败排队 3. 否则 CAS 将 state 高 16 位加 1;若累计超过 65535 上限则抛 Error 4. 本线程的 HoldCounter.count 加 1(记录重入层数) ``` 关键点:正因为有 HoldCounter,同一线程才能多次 `readLock().lock()` 而不自我阻塞,也才能在锁降级时准确判断"我确实持有读锁"。代价是每次读锁的获取/释放都要维护线程本地状态,重入层数越多、判断越多。不适用场景:如果你的读操作既不重入也不做降级,这部分开销用不上却仍要付——此时可优先考虑 StampedLock。 ### Q:公平与非公平模式下,写锁为什么会被"饿死"? A:结论先行——默认的非公平模式允许新来的读线程"插队"抢读锁,若读请求持续不断,队列里的写线程可能长期拿不到锁,出现写锁饥饿(writer starvation)。 为什么:看读锁的获取逻辑,有一个关键的 `readerShouldBlock()` 判断: - **公平模式**(`new ReentrantReadWriteLock(true)`):只要队列头是等待中的写线程(`apparentlyFirstQueuedIsExclusive()` 为 true),新来的读线程就要排队,不能插队。这样写线程在队首一定轮得到。 - **非公平模式**(默认):读线程只在"队首正好是写线程"时才稍微谦让,其余情况倾向直接 CAS 抢锁。读请求密集时,写线程在队首等,可每次刚被唤醒又有一批新读线程插到前面,于是饿死。 证据/示例: ```java // 公平模式:先来先得,能防止写线程饥饿,但吞吐通常略低 ReentrantReadWriteLock fair = new ReentrantReadWriteLock(true); // 非公平模式(默认):吞吐更高,但写线程可能长时间等待 ReentrantReadWriteLock nonfair = new ReentrantReadWriteLock(); ``` 关键点:公平锁不是"更好",它是"更可预测"。公平模式增加了排队与唤醒判断,吞吐一般会下降,换来的是等待时间的公平性和写请求的及时响应。生产建议:如果写操作对延迟敏感(比如刷新缓存、更新配置),优先考虑公平模式或者干脆换 StampedLock;如果写很少可容忍延迟,用默认非公平换吞吐即可。另外注意,`ReentrantReadWriteLock` 的公平性是"锁层面"的,并不能保证业务层面的绝对公平。 ## 三、StampedLock 的三种模式 ### Q:StampedLock 的三种模式分别是什么? A:结论先行——StampedLock 提供写锁(排他)、悲观读锁(共享)和乐观读(无锁探测)三种模式,其方法大多返回一个 long 型 stamp(邮戳),解锁/校验时要带着这个 stamp。 为什么:StampedLock 是 JDK 8 引入的一个"带版本号"的锁。它不像 `ReentrantLock` 那样用 `lock()/unlock()` 的对称调用,而是"每次加锁返回一个 stamp,解锁时把 stamp 传回去",用 stamp 来表示一次锁的版本,从而支持乐观读的"读完校验版本"。 三种模式对照: | 模式 | 获取方法 | 释放方法 | 语义 | | --- | --- | --- | --- | | 写锁(排他) | `writeLock()` | `unlockWrite(stamp)` | 独占,与其他所有模式互斥 | | 悲观读锁(共享) | `readLock()` | `unlockRead(stamp)` | 多读并发,与写锁互斥 | | 乐观读(无锁) | `tryOptimisticRead()` | 无需释放,用 `validate(stamp)` 校验 | 不加锁直接读,读后验证期间有没有写 | 证据/示例(三种模式的骨架): ```java import java.util.concurrent.locks.StampedLock; public class Counter { private int value; private final StampedLock sl = new StampedLock(); // 写锁 public void increment() { long stamp = sl.writeLock(); try { value++; } finally { sl.unlockWrite(stamp); } } // 悲观读锁 public int getPessimistic() { long stamp = sl.readLock(); try { return value; } finally { sl.unlockRead(stamp); } } // 乐观读 public int getOptimistic() { long stamp = sl.tryOptimisticRead(); int current = value; // 先读进局部变量 if (!sl.validate(stamp)) { // 校验:期间是否发生过写 stamp = sl.readLock(); // 有写则退化为悲观读 try { current = value; } finally { sl.unlockRead(stamp); } } return current; } } ``` 关键点:乐观读不需要 unlock,但**必须把字段读到局部变量后再 validate**,否则 validate 通过也不代表你拿到的是一致快照。不适用场景:写频繁时乐观读几乎每次都要回退到悲观读,收益变负;另外 StampedLock 不支持重入与 Condition。 ### Q:乐观读的 stamp 校验机制是怎么回事? A:结论先行——`tryOptimisticRead()` 会返回当前锁的版本号;只要期间没有写锁获取/释放,`validate(stamp)` 就返回 true,说明你刚才读到的数据是一致的;否则返回 false,需要退化为悲观读再读一次。 为什么:可以把 stamp 想成"写锁的版本计数器"。`tryOptimisticRead()` 读一个当前版本(如果此刻正有写锁持有,会返回 0,表示乐观读无效)。等你把共享数据读完后,用 `validate(stamp)` 检查"自我拿到 stamp 之后,写锁有没有被获取过"。没有写进去过,就说明读的这段时间数据没被修改,读到的值是可用的;一旦有写发生过,版本变了,校验失败,就要走安全路径。这本质上是一种"乐观并发控制(optimistic concurrency control)"。 证据/示例(JDK 官方文档给出的典型 `Point` 示例,读坐标算距离): ```java import java.util.concurrent.locks.StampedLock; public class Point { private double x, y; private final StampedLock sl = new StampedLock(); void move(double dx, double dy) { long stamp = sl.writeLock(); try { x += dx; y += dy; } finally { sl.unlockWrite(stamp); } } double distanceFromOrigin() { long stamp = sl.tryOptimisticRead(); double currentX = x, currentY = y; // 1. 先读到局部变量(可能读到不一致的中间态) if (!sl.validate(stamp)) { // 2. 校验:读的过程中是否出现过写 stamp = sl.readLock(); // 3. 有写,升级为悲观读,锁内重读 try { currentX = x; currentY = y; } finally { sl.unlockRead(stamp); } } return Math.sqrt(currentX * currentX + currentY * currentY); } } ``` 关键点:注意 `double currentX = x, currentY = y;` 这两次读之间可能夹着一次 `move()`,乐观读允许你读到 `(新 x, 旧 y)` 这种不一致的中间态——正因如此才必须 validate,失败就重读。这里 `x`、`y` 声明为普通字段(非 volatile)是刻意的:validate 成功会建立必要的内存可见性,无需再加 volatile 拖慢写路径。适用场景:读远多于写、临界区"读多算少",乐观读绝大多数时候根本不进入任何同步状态。 ### Q:StampedLock 为什么不支持重入? A:结论先行——因为 StampedLock 的设计目标是"极简、极快",它不记录持锁线程身份,只用一个版本号;没有重入所需的 owner 与计数,也就无法识别"是不是同一个线程",自然无法重入。 为什么:`ReentrantLock` / `ReentrantReadWriteLock` 内部都要维护"当前持锁线程 + 重入次数",这需要额外的字段维护和判断,成本不低。StampedLock 为了在乐观读路径上做到接近于无同步开销,砍掉了 owner 与重入计数。代价就是: - 同一个线程连续两次 `writeLock()`,第二次会阻塞自己(死锁); - 持有写锁时再调 `readLock()` 也可能自我阻塞; - 不支持 `Condition`,不支持 `tryLock` 那样的"已持有则成功"。 证据/示例(典型死锁): ```java import java.util.concurrent.locks.StampedLock; public class ReentrantTrap { private final StampedLock sl = new StampedLock(); public void outer() { long stamp = sl.writeLock(); try { inner(); // 调用链深处又去加锁 } finally { sl.unlockWrite(stamp); } } public void inner() { long stamp = sl.writeLock(); // ❌ 同一个线程二次加锁 -> 永久阻塞 try { // ... } finally { sl.unlockWrite(stamp); } } } ``` 关键点:业务代码里最容易踩的就是"锁的获取散落在多个方法里"。用 StampedLock 时必须保证加锁/解锁成对出现在一个方法内,不能跨方法重入。如果你确实需要"读过程中按需升级",可以用 `tryConvertToWriteLock(stamp)` 做条件式转换(转换失败则先读锁释放再单独申请写锁),但依然不能依赖重入。不适用场景:任何存在嵌套加锁、递归调用、需要 Condition 的场景,应直接选 ReentrantReadWriteLock。 ### Q:乐观读适合什么样的场景? A:结论先行——乐观读适合"读极多、写极少、临界区是纯读取少量字段或不可变结构的短操作",这样才能让绝大多数读走无锁路径。 为什么:乐观读的收益来自"读到 validate 之间没有被写打断",也就是命中率高。命中率取决于两个因素:写发生的频率,以及"读-校验"窗口的长度。写越少、窗口越短,命中率越高,收益越明显;反之,乐观读频繁失败回退,等于每次读都白白做了一次乐观尝试再叠加一次悲观读,反倒更慢。 判断清单(可以用它自检): - 写比例低(绝大多数请求是读); - 读的是少量字段或对不可变对象快照的读取,耗时极短; - 无嵌套加锁、无重入需求、无需 Condition; - 能接受"读到-校验失败-重读"的偶发重试。 证据/示例:上文 `Point.distanceFromOrigin()` 就是标准范式。反过来,如果你要读的是一个大数组并在上面做大量计算,validate 窗口会很长,写线程一插进来就失败,这时悲观读更稳。 关键点:乐观读是"用重试换无锁",不是"免费午餐"。当写入频繁到一定程度,StampedLock 未必优于 ReentrantReadWriteLock;务必以实测为准(不同 JDK 版本与硬件上行为可能有差异,需结合版本确认)。 ### Q:StampedLock 的 tryConvertToWriteLock 是干什么的? A:结论先行——它尝试把当前持有的(悲观读或写)stamp 转换成写锁 stamp:成功返回新 stamp(相当于就地升级为写锁),失败返回 0,此时必须先释放读锁、再单独申请写锁,并重新校验业务前提。 为什么:StampedLock 不支持重入,也不支持"读锁未释放就再拿写锁",但它提供了条件式转换来覆盖"读着读着发现要改"的常见需求。调用 `tryConvertToWriteLock(stamp)` 时,如果当前恰好只有你这一个读锁持有者、也没有其他写者排队,转换就可能成功;只要还有别的读线程或写线程,转换就会失败。 证据/示例(含转换失败的安全回退): ```java import java.util.concurrent.locks.StampedLock; public class Converter { private int value; private final StampedLock sl = new StampedLock(); public void incrementIfEven() { long stamp = sl.readLock(); boolean writeHeld = false; try { if ((value & 1) == 0) { long ws = sl.tryConvertToWriteLock(stamp); if (ws != 0L) { stamp = ws; // 转换成功,现持有写锁 writeHeld = true; } else { sl.unlockRead(stamp); // 转换失败:先放读锁 stamp = sl.writeLock(); // 再单独申请写锁 writeHeld = true; // 注意:此处应重新校验业务前提,值可能已被改动 } value++; } } finally { if (writeHeld) { sl.unlockWrite(stamp); } else { sl.unlockRead(stamp); } } } } ``` 关键点:转换失败分支里"重新申请写锁后要重新校验业务前提"是安全的关键,因为在放读锁与拿写锁的间隙,值可能已被别的线程改掉。预期行为:能转换时省掉一次"放锁—抢锁"往返;不能转换时退化为常规读写锁路径,语义依然正确。不适用场景:如果转换频繁失败,说明写竞争并不小,此时 StampedLock 未必优于 ReentrantReadWriteLock,应以实测判断。 ## 四、三种锁的横向对比 ### Q:ReentrantLock、ReentrantReadWriteLock、StampedLock 该怎么选? A:结论先行——需要独占互斥且要重入/Condition 就选 ReentrantLock;读多写少且需要重入、Condition、写锁公平性就选 ReentrantReadWriteLock;读极多写极少、临界区短、能接受不可重入,才考虑 StampedLock 的乐观读。 对比表: | 维度 | ReentrantLock | ReentrantReadWriteLock | StampedLock | | --- | --- | --- | --- | | 锁语义 | 纯排他 | 读共享 + 写排他 | 写排他 + 悲观读共享 + 乐观读无锁 | | 是否可重入 | 是 | 是 | 否(关键差异) | | 公平模式 | 支持 `new ReentrantLock(true)` | 支持 `new ReentrantReadWriteLock(true)` | 无公平/非公平概念 | | Condition | 支持 `newCondition()` | 写锁支持 `writeLock().newCondition()` | 不支持 | | 中断获取 | `lockInterruptibly()` | 读写锁均支持 | `readLockInterruptibly()` 等 | | 超时获取 | `tryLock(timeout)` | 支持 | `tryWriteLock(timeout)` / `tryReadLock(timeout)` | | 升级/降级 | 不适用 | 支持降级,不支持升级 | `tryConvertToWriteLock` 条件转换 | | 典型收益点 | 通用互斥、精确唤醒 | 读读并发 | 乐观读无同步开销 | | 主要代价 | 读也串行 | 管理开销、非公平下写饥饿 | 不可重入、无 Condition、误用易死锁 | | 适用 | 读写混合、需要锁特性 | 读多写少、要重入/公平 | 读极多写极少、短临界区 | 关键点:选型的第一原则是"先满足正确性,再谈性能"。StampedLock 更快的前提是你**不用重入、不用 Condition**,一旦业务里存在嵌套加锁,用 StampedLock 就是给自己埋雷。第二原则是"不要凭直觉给性能结论"——读写锁与乐观读的相对优劣跟 JDK 版本、硬件、临界区形态强相关,必须压测。 ## 五、生产用法与踩坑 ### Q:缓存场景用读写锁,怎么写才安全? A:结论先行——读写操作用两把锁分开,写操作完成后如需立即读,用锁降级;千万不要在读锁里尝试升级。用 `finally` 保证一定解锁。 为什么:缓存是读写锁最经典的落地场景。要点是:读锁只保护读,写锁保护写与相关结构变更;写完后立即返回最新值用降级;避免把远程调用、日志等耗时操作放进临界区。 证据/示例(一个能直接照用的缓存骨架): ```java import java.util.HashMap; import java.util.Map; import java.util.concurrent.locks.ReentrantReadWriteLock; public class SafeCache<K, V> { private final Map<K, V> map = new HashMap<>(); private final ReentrantReadWriteLock rw = new ReentrantReadWriteLock(); public V get(K key) { rw.readLock().lock(); try { return map.get(key); } finally { rw.readLock().unlock(); } } public void reload(K key, V newValue) { rw.writeLock().lock(); try { map.put(key, newValue); // 若需要在写锁保护下立即确认最新值,可在此降级: // rw.readLock().lock(); // try { return map.get(key); } finally { rw.readLock().unlock(); } } finally { rw.writeLock().unlock(); } } } ``` 关键点:`HashMap` 本身不是线程安全的,这里靠读写锁保证互斥,读读并发是安全的(结构不变时)。不适用场景:如果缓存是"读多写极少且要求读极致性能",可以考虑 `ConcurrentHashMap` 或 `StampedLock`,但要知道 `ConcurrentHashMap` 在复合操作上仍需额外同步,而 StampedLock 有不可重入的约束。 ### Q:StampedLock 不可重入导致的死锁长什么样? A:结论先行——症状是线程栈里卡在 `StampedLock.writeLock()` 或 `readLock()`,且往往是同一线程的调用链在方法 A 持锁后又调用方法 B 再次加锁,形成自我死锁。 为什么:StampedLock 不识别 owner,第二次加锁对同一个线程也视为"另一个竞争者",于是该线程在等自己释放。这种死锁 `jstack` 里能看到,但不会像 `ReentrantLock` 那样被检测器报"found one Java-level deadlock",需要你人工顺着栈回溯到第一次加锁的位置。 排查思路: ```text 1. jstack <pid> 导出线程栈 2. 找到堆栈停在 java.util.concurrent.locks.StampedLock 3. 顺着调用链向上找第一次 writeLock()/readLock() 的入口 4. 检查是否存在:方法 A 加锁 -> 调用方法 B -> 方法 B 再次加锁 5. 修复:把锁的获取收敛到一个方法内,或改用 ReentrantReadWriteLock ``` 关键点:预防手段是"加锁范围最小化 + 锁成对出现在同一方法",并在代码评审中特别关注 StampedLock 的跨方法复用。另一个隐蔽坑:`tryOptimisticRead()` 返回 0 表示当前有写锁,此时必须按"校验失败"处理并走悲观读,不要当成功。 ### Q:还有哪些容易忽略的坑? A:结论先行——至少有以下几点:解锁必须带对 stamp;悲观读锁也需要 `finally`;不要用 StampedLock 的乐观读读大范围数据;以及别忽视非公平读写锁的写饥饿与死锁排查。 逐一说明: 1. **stamp 必须传回正确的方法**。`unlockWrite(stamp)` 与 `unlockRead(stamp)` 不能混用,stamp 也不能送给别的线程。 2. **悲观读锁也要 `try/finally`**,否则异常路径漏解锁会拖垮整个写路径。 3. **乐观读别覆盖大范围/长耗时逻辑**,validate 窗口越长越容易失败。 4. **死锁排查**用 `jstack`、`jconsole`、`jvisualvm`、`arthas` 定位卡在锁上的线程;预防上统一加锁顺序、减少锁嵌套、避免持锁做远程调用、必要时用 `tryLock(timeout)` 兜底。 5. **属性可见性别想当然**。StampedLock 的乐观读要求"读到局部变量 + validate",不要指望给字段加 volatile 就能免除校验。 6. **版本与方言**。StampedLock 自 JDK 8 引入,方法签名以你的 JDK 为准;个别行为(如中断相关方法)建议结合所用版本确认。 ### Q:读写锁里能用 Condition 吗?读锁里能不能改数据? A:结论先行——只有写锁能 `newCondition()`,读锁不提供 Condition;读锁期间只能读,绝不能修改任何共享状态(包括懒初始化、计数、缓存填充)。 为什么:Condition 的本质是"在一个排他临界区里等待/唤醒",它依赖对锁的独占来保证"被唤醒时条件判断是安全的"。读锁是共享的,多个读线程同时持有,若允许在读锁上 await,就无法保证醒来时条件仍成立,因此 `ReadLock` 根本不提供 `newCondition()`,只有 `writeLock().newCondition()` 才可用。另一方面,读锁的语义是"只读共享";任何形如 `get` 却偷偷修改内部状态(懒加载字段、访问计数、缓存回填)的写法,都会在没有互斥保护的情况下产生数据竞争——这类 bug 往往只在并发下偶发,极难复现。 证据/示例(只有写锁能创建 Condition): ```java import java.util.concurrent.locks.ReentrantReadWriteLock; import java.util.concurrent.locks.Condition; ReentrantReadWriteLock rw = new ReentrantReadWriteLock(); Condition cond = rw.writeLock().newCondition(); // ✅ 写锁可以 // Condition c2 = rw.readLock().newCondition(); // ❌ 编译不通过:ReadLock 无此方法 ``` 关键点:这条规则带来的常见需求是"读未命中就加载并写回"——它天然属于"读后写",不能塞进读锁里。正确做法是:先按读锁快速判断是否命中,未命中则释放读锁、改走写锁再检查一次(double-check)并写入。不适用场景:纯只读查询完全没问题,前提是方法内部不产生任何副作用。 ## 小结 - 读写锁的核心价值是"读读并发、读写互斥、写写互斥",只在读多写少且临界区不太短时才有明显收益。 - `ReentrantReadWriteLock` 用一个 state 的高 16 位存读计数、低 16 位存写计数;锁降级(写→读)可行,锁升级(读→写)会自我死锁,必须"先放读锁再申请写锁并重校验"。 - 默认非公平模式下新读线程可插队,写线程可能饥饿;公平模式可缓解但通常牺牲吞吐。 - `StampedLock` 有写锁、悲观读、乐观读三种模式,用 long stamp 表示版本;乐观读必须"先读入局部变量,再 validate,失败回落悲观读"。 - StampedLock 不可重入、无 Condition,跨方法嵌套加锁会自我死锁;乐观读适合读极多写极少、窗口短的场景。 - 选型口诀:要重入与 Condition → ReentrantLock / ReentrantReadWriteLock;读极多写极少且能接受不可重入 → StampedLock。性能优劣务必实测,不能一概而论。 ## 思考题 1. 为什么锁降级是安全的,而锁升级会死锁?请从"共享锁与排他锁的获取条件"角度解释。 2. 非公平模式下写锁饥饿的根因是什么?公平模式用哪些判断来避免它? 3. 如果一段逻辑既要读又要写,用 StampedLock 该如何组织代码才能既升级又不重入? 4. `tryOptimisticRead()` 返回 0 代表什么?此时应该怎么处理? 5. 一个读多写少的缓存,你会怎么在 ReentrantReadWriteLock、ConcurrentHashMap、StampedLock 之间做选择?请给出你的判断依据。
预览
发布文章
添加摘要让读者更快了解文章内容
取消
确认发布
AI 写作助手
输入一个主题,AI 将为你生成一篇 Markdown 博客文章
AI 正在写作中...
取消
开始生成
AI 优化助手
描述你的修改需求,AI 将在原文基础上进行补充或微调
AI 正在优化中...
取消
开始优化
画布
从已有图里选
✕
图名
保存后生成 /images/excalidraw/<图名>.svg(只能用字母、数字、短横线、下划线、点)
取消
保存并插入