J*a里如何使用ReentrantReadWriteLock实现读写锁_ReentrantReadWriteLock操作解析

发布时间：2025-12-04

点击量：

ReentrantReadWriteLock通过分离读写锁提升并发性能，允许多个线程并发读，写操作独占锁；读-读不互斥，读-写和写-写互斥；支持锁降级（先写后读），但不支持锁升级；默认非公平模式，可设为公平模式；使用时需在finally中释放锁，防止死锁。

java里如何使用reentrantreadwritelock实现读写锁_reentrantreadwritelock操作解析

在J*a并发编程中，ReentrantReadWriteLock 是一种常用的同步工具，适用于读多写少的场景。它通过分离读锁和写锁，提高并发性能：多个线程可以同时读取共享资源，但写操作是独占的。

读写锁的基本原理

ReentrantReadWriteLock 维护了一对相关的锁：

读锁（Read Lock）：允许多个线程同时获取，用于读操作。
写锁（Write Lock）：只允许一个线程持有，用于写操作，且此时其他读线程也不能进入。

这种机制保证了：

读-读操作可以并发执行。
读-写、写-写操作互斥。
写锁持有期间，所有尝试获取读锁的线程都会被阻塞。

基本使用示例

下面是一个简单的例子，展示如何使用 ReentrantReadWriteLock 来保护一个共享的缓存数据：

import j*a.util.HashMap;
import j*a.util.Map;
import j*a.util.concurrent.locks.ReentrantReadWriteLock;

public class CacheExample {
    private final Map<String, Object> cache = new HashMap<>();
    private final ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();

    // 获取读锁进行查询
    public Object get(String key) {
        rwLock.readLock().lock();
        try {
            return cache.get(key);
        } finally {
            rwLock.readLock().unlock();
        }
    }

    // 获取写锁进行更新
    public Object put(String key, Object value) {
        rwLock.writeLock().lock();
        try {
            return cache.put(key, value);
        } finally {
            rwLock.writeLock().unlock();
        }
    }

    // 写操作：清除缓存
    public void clear() {
        rwLock.writeLock().lock();
        try {
            cache.clear();
        } finally {
            rwLock.writeLock().unlock();
        }
    }
}

在这个例子中：

MedPeer科研绘图

生物医学领域的专业绘图解决方案，告别复杂绘图，专注科研创新

166

查看详情

get 方法使用读锁，多个线程可同时读取。
put 和 clear 使用写锁，确保修改时独占访问。
务必在 finally 块中释放锁，防止死锁。

锁降级：从写锁到读锁

ReentrantReadWriteLock 支持“锁降级”——即一个线程先获取写锁，再获取读锁，然后释放写锁，从而保持对资源的读权限。这在某些需要原子性更新后立即读取的场景非常有用。

public void processData() {
    rwLock.writeLock().lock();
    try {
        // 修改数据
        System.out.println("正在更新数据...");
        
        // 在释放写锁前，先获取读锁（必须当前线程持有写锁）
        rwLock.readLock().lock();
    } finally {
        // 降级的关键：释放写锁，保留读锁
        rwLock.writeLock().unlock();
    }
    
    try {
        // 此时仍持有读锁，可以安全读取
        System.out.println("正在读取数据...");
    } finally {
        rwLock.readLock().unlock();
    }
}

注意：不能直接升级（先读再写），否则会导致死锁。

公平性与非公平模式

ReentrantReadWriteLock 构造时可指定是否使用公平策略：

非公平模式（默认）：允许插队，吞吐量高，但可能造成线程饥饿。
公平模式：按请求顺序分配锁，更公平但性能略低。

// 公平模式
ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock(true);

基本上就这些。合理使用 ReentrantReadWriteLock 能显著提升读多写少场景下的并发效率，但要注意避免锁未释放、错误的锁升级等问题。理解其内部状态机制和使用限制，才能写出高效又安全的并发代码。

以上就是J*a里如何使用ReentrantReadWriteLock实现读写锁_ReentrantReadWriteLock操作解析的详细内容，更多请关注其它相关文章！

上一篇：抖音官网在线刷视频抖音网页版免登录进入

下一篇：AO3网页版入口合集 AO3在线访问官方链接