跳到主要内容
约 8 分钟3 张卡

读写锁

读写锁把一把锁拆成读锁和写锁:多个线程可以同时持有读锁并行读取,写线程则要独占写锁才能修改。读多写少的数据,用普通互斥锁会让读线程之间也互相排队,读写锁就是为了解决这个问题。

Java 里有两种读写锁。ReentrantReadWriteLock 是标准的读写锁,要讲清它为什么能降级、不能升级。StampedLock 多了一种不加锁的乐观读,更快,但要自己验证读到的数据,也不支持重入和条件队列。用错的代价都是数据不一致或者线程把自己卡住。

1. 面试核心​

先记住这几条,再读正文
  • 多个线程可以同时持有读锁,写锁则和其他线程的读锁、写锁都互斥。
  • ReentrantReadWriteLock 支持锁降级:先获取读锁、再释放写锁;不支持读锁直接升级,读线程申请写锁前要先释放读锁。卡 · 写锁降级的持锁区间
  • StampedLock 用获取时返回的 stamp 释放锁或转换模式,它不支持重入,也不支持条件队列。
  • 乐观读要先把字段读进局部变量,再验证 stamp,验证失败就加读锁重读全部字段。卡 · StampedLock 与 stamp
  • 持有读锁时,tryConvertToWriteLock 转换失败会返回零,原来的读锁仍然持有。卡 · StampedLock 的模式转换

2. 读锁与写锁​

读写锁的规则是:读和读可以并行,读和写、写和写互斥。读线程用读锁,写线程用写锁:

private final ReentrantReadWriteLock rw = new ReentrantReadWriteLock();
private final Lock read = rw.readLock();
private final Lock write = rw.writeLock();

Value find(Key key) {
read.lock();
try {
return values.get(key);
} finally {
read.unlock();
}
}

多个线程可以同时执行 find,修改 values 的线程则必须取得同一个 rw 的写锁。正因为读锁允许并行,读锁内的代码不能修改共享状态,否则多个读线程同时改,就又产生竞争了。

锁只保护方法内部的访问。find 返回的 Value 如果是可变对象,调用者在方法外修改它时,锁已经释放,仍然需要另外遵守同一套同步规则。

读写锁也不是免费的:它要维护读线程的数量,还要安排竞争的线程排队。读操作很短或者写入很频繁时,这些成本会抵消并行读取的收益,甚至比普通互斥锁更慢,所以要和互斥锁实测比较。

3. 锁降级与锁升级​

锁降级是持有写锁的线程,在不让出保护的前提下换成读锁。典型场景是更新完数据后,还要继续读刚写入的结果:先获取读锁,再释放写锁。这样其他读线程可以进来,但其他写线程仍然被挡住。

反方向的锁升级,也就是持有读锁时直接申请写锁,ReentrantReadWriteLock 不支持。写锁要等所有读锁都释放,而当前线程自己还拿着读锁,于是它会一直等自己,永远卡住。两个读线程同时尝试升级,也会互相等待。

需要更新时,只能先释放读锁,再获取写锁。两次获取之间有一个空档,其他写线程可能已经改了数据,所以拿到写锁后必须重新检查更新条件。

3.1 写锁降级的持锁区间​

降级的关键是让写锁和读锁的持有时间重叠,读锁在写锁释放之前就接过保护:

write.lock();
try {
refresh();
read.lock();
} finally {
write.unlock();
}
try {
useSnapshot();
} finally {
read.unlock();
}

refresh() 完成后,当前线程在仍持有写锁时取得读锁,然后才释放写锁。这时其他写线程仍被读锁挡住,useSnapshot() 读取期间数据保持不变。如果顺序反过来,先释放写锁再申请读锁,其他写线程就能在这两步之间插进来修改数据。

4. StampedLock 与 stamp​

StampedLock 每次获取锁都返回一个 long 类型的 stamp,它代表这次获取得到的访问凭据,包含锁模式和版本信息。释放锁或转换模式时,要把仍然有效的 stamp 传回去:

long stamp = lock.readLock();
try {
return new Point(x, y);
} finally {
lock.unlockRead(stamp);
}

示例先获取读锁,读出两个坐标,再用同一个 stamp 释放读锁。因为权限由 stamp 管理,而不是记在某个线程名下,获取和释放可以由不同的线程完成。

这也带来两个限制。第一,StampedLock 不可重入:持有写锁的方法再调用一次 writeLock(),会一直等待自己释放,把自己卡死。所以持锁代码调用其他方法之前,要确认那个方法不会再获取同一把锁。

第二,它的锁视图不支持 Condition,也就是不能让线程在锁上等待某个业务条件。需要重入或者条件队列的代码,应继续使用 ReentrantReadWriteLock 或 ReentrantLock。

5. 乐观读​

乐观读是先不加锁直接读,读完再检查这期间有没有写线程介入;没有就用读到的结果,有就加读锁重读。它省掉了普通读锁的获取和释放,代价是程序要自己验证结果、处理验证失败:

long stamp = lock.tryOptimisticRead();
double currentX = x;
double currentY = y;

if (!lock.validate(stamp)) {
stamp = lock.readLock();
try {
currentX = x;
currentY = y;
} finally {
lock.unlockRead(stamp);
}
}
return new Point(currentX, currentY);

本例要求所有对坐标的写入都使用同一个 lock 的写锁。tryOptimisticRead() 在写锁已经被持有时返回零,否则返回一个用来验证的 stamp。

乐观读期间没有持有任何锁,写线程可以随时修改,所以读到的 currentX 和 currentY 可能来自两次不同的更新,比如新的 x 配上旧的 y。读完以后,validate(stamp) 检查从拿到 stamp 到现在,有没有线程取得过写锁。验证成功,才接受局部变量里的坐标;验证失败,就在读锁内把全部字段重读一遍,避免把两次读取的结果混在一起。

这里有两条边界。一是验证之前的代码必须能容忍暂时的不一致。比如顺着可变引用访问对象或数组,可能遇到空引用或者已经失效的下标,在验证之前就抛异常了。所以乐观读适合读几个简单字段,付款这类不可撤销的操作要放在验证成功之后。二是验证只覆盖从获取 stamp 到调用 validate 之间的读取,验证之后再读共享字段,需要重新验证或者加锁。

6. StampedLock 的模式转换​

读着读着发现需要更新时,StampedLock 可以用 tryConvertToWriteLock(stamp) 尝试直接转换成写模式,不用先释放再获取。stamp 有效、并且属于下面三种情况之一时,转换能成功:

  • 已经持有写锁,继续保持写模式。
  • 持有读锁,并且当前线程是唯一的读锁持有者。
  • 持有乐观读 stamp,并且锁当前处于空闲状态。

转换成功会返回一个新的 stamp,之后用它释放写锁。转换失败返回零,原来的读锁仍然持有。所以要先用一个临时变量接收结果,不能直接覆盖旧 stamp,否则失败时就没法释放原来的读锁了:

long writeStamp = lock.tryConvertToWriteLock(stamp);
if (writeStamp != 0L) {
stamp = writeStamp;
} else {
lock.unlockRead(stamp);
stamp = lock.writeLock();
// 重新检查更新条件。
}

这段代码假设进入时持有一个有效的读 stamp。转换失败时,先用旧 stamp 释放读锁,再获取写锁。和锁升级一样,释放和获取之间数据可能被改过,所以拿到写锁后要重新检查更新条件。更新结束后,用 unlockWrite(stamp) 释放写锁。

7. 不可变快照与并发容器​

在选读写锁之前,先看看数据适不适合下面三种更简单的共享方式:

  • 配置这类整体更新的数据,用 volatile 发布不可变快照,读者直接拿到一份完整的配置。
  • 按键查询和更新的数据,用 ConcurrentHashMap 管理并发访问。
  • 读极多、写极少的小集合,可以考虑 Copy-on-Write:修改时复制一份新的,读取时用已有的快照。

这些方案把发布或同步封装在明确的操作里,省去手动维护读写锁的工作。具体机制见 安全发布、ConcurrentHashMap 和 CopyOnWriteArrayList。

读写锁适合需要一起保护多个字段的场景。读取占比高、每次读有一定成本、写竞争又可控时,并行读取才更有机会带来收益。评估时要测量这四项:

  • 读写比例,确认写入确实足够少。
  • 临界区耗时,也就是每次持锁执行代码的时间。
  • 写线程的等待时间,检查源源不断的读取是否拖延了更新。
  • p99 延迟,即 99% 的请求都能在这个时间内完成,用来观察慢请求的等待。

8. 常见问题​

8.1 乐观读可以直接替代读锁吗?​

不能直接替换。乐观读适合读取几个简单字段、读取过程能容忍暂时不一致的代码。它的流程包括获取 stamp、读取、验证和失败后重读,比读锁多了几个环节。复杂的可变结构里,每一次引用访问都可能在验证前出错,所以迁移之前要逐处检查读取代码。

8.2 读写锁支持公平策略和 Condition 吗?​

9. 面试题卡片​

10. 参考资料​

来源:Coding 101 原文 · 免费阅读,引用请保留出处。内容使用说明