ReentrantReadWriteLock通过分离读写锁提升并发性能，允许多个线程同时读，但写操作独占；示例展示缓存类中读写分离的实现，强调锁必须在finally中释放、写锁可降级为读锁但读锁不可升级为写锁，适用于读多写少场景。
在Java中，ReentrantReadWriteLock 是一种高效的同步工具，适用于读多写少的并发场景。它通过分离读锁和写锁，允许多个线程同时读取共享资源，但写操作是独占的，从而提升并发性能。下面介绍如何使用它实现读写分离。
读写锁的基本原理
ReentrantReadWriteLock 维护了一对锁：
- 读锁（ReadLock）：多个线程可以同时持有读锁，适用于只读操作。
- 写锁（WriteLock）：写锁是独占的，同一时刻只能有一个线程持有写锁，且此时不允许任何读操作。
这种机制保证了：
- 读读不互斥
- 读写互斥
- 写写互斥
基本使用示例
以下是一个简单的缓存类，使用 ReentrantReadWriteLock 实现读写分离：
立即学习“Java免费学习笔记（深入）”；
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.ReentrantReadWriteLock;
public class ReadWriteCache {
private final Map cache = new HashMap<>();
private final ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
private final ReentrantReadWriteLock.ReadLock readLock = rwLock.readLock();
private final ReentrantReadWriteLock.WriteLock writeLock = rwLock.writeLock();
// 读操作：获取值
public Object get(String key) {
readLock.lock();
try {
return cache.get(key);
} finally {
readLock.unlock();
}
}
// 写操作：放入值
public Object put(String key, Object value) {
writeLock.lock();
try {
return cache.put(key, value);
} finally {
writeLock.unlock();
}
}
// 写操作：清除缓存
public void clear() {
writeLock.lock();
try {
cache.clear();
} finally {
writeLock.unlock();
}
}
}
使用要点与注意事项
在实际使用中，有几个关键点需要注意：
- 必须在 finally 块中释放锁，防止死锁。
- 读锁不能升级为写锁，否则会导致死锁。如果需要更新数据，应先释放读锁，再获取写锁。
- 写锁可以降级为读锁：持有写锁的线程可以获取读锁后再释放写锁，适用于“先修改后读取”的场景。
- 锁的获取和释放必须在同一线程中完成。
- 适合读多写少的场景，如果写操作频繁，读锁的优势会被削弱。
锁降级示例
有时候需要在修改数据后保持读访问，可以使用写锁降级：
public Object processData(String key) {
readLock.lock();
Object value = cache.get(key);
if (value == null) {
readLock.unlock(); // 释放读锁
writeLock.lock();
try {
// 再次检查是否已加载，避免重复写
value = cache.get(key);
if (value == null) {
value = expensiveOperation();
cache.put(key, value);
}
// 在释放写锁之前获取读锁，实现降级
readLock.lock();
} finally {
writeLock.unlock();
}
// 现在由读锁保护，继续使用 value
}
try {
return process(value);
} finally {
readLock.unlock();
}
}
基本上就这些。合理使用 ReentrantReadWriteLock 能有效提升并发读的性能，但要注意锁的获取顺序和释放时机，避免死锁和数据不一致问题。不复杂但容易忽略细节。
