ReentrantReadWriteLock读写锁

ReentrantReadWriteLock读写锁

当读操作远远高于写操作时，这时候使用 读写锁 让 读-读 可以并发，提高性能。 类似于数据库中的 select ...from ... lock in share mode
提供一个 数据容器类 内部分别使用读锁保护数据的 read() 方法，写锁保护数据的 write() 方法

 private Object data;
    private ReentrantReadWriteLock rw = new ReentrantReadWriteLock();
    private ReentrantReadWriteLock.ReadLock r = rw.readLock();
    private ReentrantReadWriteLock.WriteLock w = rw.writeLock();

    public Object read() {
        log.debug("获取读锁...");
        r.lock();
        try {
            log.debug("读取");
            Sleep.sleep(1);
            return data;
        } finally {
            log.debug("释放读锁...");
            r.unlock();
        }
    }

    public void write() {
        log.debug("获取写锁...");
        w.lock();
        try {
            log.debug("写入");
            Sleep.sleep(1);
        } finally {
            log.debug("释放写锁...");
            w.unlock();
        }
    }

测试 读锁-读锁 可以并发

    public static void main(String[] args) {
        DataContainer dataContainer = new DataContainer();
        new Thread(dataContainer::read, "t1").start();
        new Thread(dataContainer::read, "t2").start();
    }

2022-08-21 15:15:43.792 DEBUG   --- [             t1] c.e.demo.hmjuc.DataContainer       : 获取读锁...
2022-08-21 15:15:43.792 DEBUG   --- [             t2] c.e.demo.hmjuc.DataContainer       : 获取读锁...
2022-08-21 15:15:43.800 DEBUG   --- [             t2] c.e.demo.hmjuc.DataContainer       : 读取
2022-08-21 15:15:43.800 DEBUG   --- [             t1] c.e.demo.hmjuc.DataContainer       : 读取
2022-08-21 15:15:43.803 DEBUG   --- [             t2] c.e.demo.hmjuc.DataContainer       : 释放读锁...
2022-08-21 15:15:43.803 DEBUG   --- [             t1] c.e.demo.hmjuc.DataContainer       : 释放读锁...

测试 读锁-写锁 相互阻塞

    public static void main(String[] args) throws InterruptedException {
        DataContainer dataContainer = new DataContainer();
        new Thread(dataContainer::read, "t1").start();
        Thread.sleep(100);
        new Thread(dataContainer::write, "t2").start();
    }

2022-08-21 15:16:46.677 DEBUG   --- [             t1] c.e.demo.hmjuc.DataContainer       : 获取读锁...
2022-08-21 15:16:46.680 DEBUG   --- [             t1] c.e.demo.hmjuc.DataContainer       : 读取
2022-08-21 15:16:46.717 DEBUG   --- [             t1] c.e.demo.hmjuc.DataContainer       : 释放读锁...
2022-08-21 15:16:46.778 DEBUG   --- [             t2] c.e.demo.hmjuc.DataContainer       : 获取写锁...
2022-08-21 15:16:46.778 DEBUG   --- [             t2] c.e.demo.hmjuc.DataContainer       : 写入
2022-08-21 15:16:46.780 DEBUG   --- [             t2] c.e.demo.hmjuc.DataContainer       : 释放写锁...

写锁-写锁 也是相互阻塞的，这里就不测试了

注意事项

• 读锁不支持条件变量
• 重入时升级不支持：即持有读锁的情况下去获取写锁，会导致获取写锁永久等待

     r.lock();
        try {
            // ...
            w.lock();
            try {
                // ...
            } finally {
                w.unlock();
            }
        } finally {
            r.unlock();
        }

重入时降级支持：即持有写锁的情况下去获取读锁

			Object data;
            // 是否有效，如果失效，需要重新计算 data
            volatile boolean cacheValid;
            final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();

            void processCachedData() {
                rwl.readLock().lock();
                if (!cacheValid) {
                    // 获取写锁前必须释放读锁
                    rwl.readLock().unlock();
                    rwl.writeLock().lock();
                    try {
                        // 判断是否有其它线程已经获取了写锁、更新了缓存, 避免重复更新
                        if (!cacheValid) {
                            data = ...
                            cacheValid = true;
                        }
                        // 降级为读锁, 释放写锁, 这样能够让其它线程读取缓存
                        rwl.readLock().lock();
                    } finally {
                    }
                    rwl.writeLock().unlock();
                }
                // 自己用完数据, 释放读锁
                try {
                    use(data);
                } finally {
                    rwl.readLock().unlock();
                }
            }