ReentrantReadWriteLock

ReentrantReadWriteLock 是 Java 中 java.util.concurrent.locks 包下的一个可重入的读写锁实现。它允许多个读线程同时访问共享资源，但在写线程访问时，所有其他读和写的线程都会被阻塞。这种机制非常适合读多写少的并发场景。

什么是读写锁？

• 读锁（Shared Lock）：多个线程可以同时持有读锁。

• 写锁（Exclusive Lock）：只能有一个线程持有写锁，并且在写锁存在期间不允许任何读锁。

这比直接使用 ReentrantLock 更高效，因为读操作通常不会改变数据状态，所以允许多个线程并行读取能显著提高并发性能。

ReentrantReadWriteLock 的特点

使用示例

示例：缓存类中使用 ReentrantReadWriteLock

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class Cache {
    private final Map<String, Object> cache = new HashMap<>();
    private final ReadWriteLock lock = new ReentrantReadWriteLock();

    // 读操作使用读锁
    public Object get(String key) {
        lock.readLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + " 正在读取: " + key);
            return cache.get(key);
        } finally {
            lock.readLock().unlock();
        }
    }

    // 写操作使用写锁
    public void put(String key, Object value) {
        lock.writeLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + " 正在写入: " + key);
            cache.put(key, value);
        } finally {
            lock.writeLock().unlock();
        }
    }

    public static void main(String[] args) {
        Cache cache = new Cache();

        // 多线程测试
        Runnable readTask = () -> {
            for (int i = 0; i < 3; i++) {
                cache.get("key" + i);
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        };

        Runnable writeTask = () -> {
            for (int i = 0; i < 3; i++) {
                cache.put("key" + i, "value" + i);
                try {
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        };

        Thread t1 = new Thread(writeTask, "Writer");
        Thread t2 = new Thread(readTask, "Reader1");
        Thread t3 = new Thread(readTask, "Reader2");

        t1.start();
        t2.start();
        t3.start();
    }
}

执行结果

Reader1 正在读取: key0
Reader2 正在读取: key0
Writer 正在写入: key0
Reader1 正在读取: key1
Reader2 正在读取: key1
Writer 正在写入: key1
Reader2 正在读取: key2
Reader1 正在读取: key2
Writer 正在写入: key2

适用场景

注意事项

1. 不要嵌套加锁顺序错误

• 避免先加读锁再尝试加写锁，会造成死锁。

• 推荐写锁降级为读锁。

2.避免锁泄漏

• 使用 try/finally 确保锁一定会被释放。

3.公平性设置谨慎

• 默认是非公平模式，适用于大多数高并发场景。

• 公平模式虽然保证等待顺序，但可能降低吞吐量。

4.锁粒度控制

• 如果数据结构本身很大，可以考虑分段加锁（类似 ConcurrentHashMap）。

性能对比（简单说明）

总结

如果正在开发一个需要高性能并发控制的组件（如缓存、数据库代理、配置中心等），强烈推荐使用 ReentrantReadWriteLock 来优化读写性能。