首页 > > 程序设计 > Java技术 >

【漫画】互斥锁ReentrantLock不好用？试试读写锁…

2020-05-15 16:09:19来源：博客园阅读 ()

【漫画】互斥锁ReentrantLock不好用？试试读写锁ReadWriteLock

ReentrantLock完美实现了互斥，完美解决了并发问题。但是却意外发现它对于读多写少的场景效率实在不行。此时ReentrantReadWriteLock来救场了！一种适用于读多写少场景的锁，可以大幅度提升并发效率，你必须会哦！

序幕

为何引入读写锁？

ReentrantReadWriteLock，顾名思义，是可重用的读写锁。

在读多写少的场合，读写锁对系统性能是很有好处的。因为如果系统在读写数据时均只使用独占锁，那么读操作和写操作间、读操作和读操作间、写操作和写操作间均不能做到真正的并发，并且需要相互等待。而读操作本身不会影响数据的完整性和一致性。

因此，理论上讲，在大部分情况下，应该可以允许多线程同时读，读写锁正是实现了这种功能。

划重点：读写锁适用于读多写少的情况。可以优化性能，提升易用性。

读写锁 ReadWriteLock

读写锁，并不是 Java 语言特有的，而是一个广为使用的通用技术，所有的读写锁都遵守以下三条基本原则：

允许多个线程同时读共享变量；
只允许一个线程写共享变量；
如果一个写线程正在执行写操作，此时禁止读线程读共享变量。

读写锁与互斥锁的一个重要区别就是读写锁允许多个线程同时读共享变量，而互斥锁是不允许的，这是读写锁在读多写少场景下性能优于互斥锁的关键。但读写锁的写操作是互斥的、独占的，当一个线程在写共享变量的时候，是不允许其他线程执行写操作和读操作。只要没有写操作，读取锁可以由多个读线程同时保持。读写锁访问约束如下表所示：

读写锁	读	写
读	非阻塞	阻塞
写	阻塞	阻塞

读写锁维护了一对相关的锁，一个用于只读操作，一个用于写入操作。

    private final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
    //读锁
    private final Lock r = rwl.readLock();
    //写锁
    private final Lock w = rwl.writeLock();

为了对比读写锁和独占锁的区别，我们可以写一个测试代码，分别传入ReentrantLock 和 ReadLock，对比一下总耗时。

    private static final ReentrantLock lock = new ReentrantLock();
    private static final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
    private static final Lock r = rwl.readLock();

    public static String read(Lock lock, String key) throws InterruptedException {
        r.lock();
        try {
            // 模拟读耗时多的场景 更能看出区别
            Thread.sleep(1000 * 10);
            return m.get(key);
        } finally {
            r.unlock();
        }
    }

快速实现一个缓存

回想一下工作中经常用到的缓存，例如缓存元数据，不就是一种典型的读多写少应用场景吗？缓存之所以能提升性能，一个重要的条件就是缓存的数据一定是读多写少的，例如元数据和基础数据基本上不会发生变化（写少），但是使用它们的地方却很多（读多）。

我们是不是可以用ReentrantReadWriteLock来手写一个缓存呢？先画一张图模拟简单的缓存流程吧：
未命名文件.png

    String get(String key) throws InterruptedException {
        String v = null;
        r.lock();
        log.info("{}获取读锁 time={}",Thread.currentThread().getName(),System.currentTimeMillis());
        try {
            v = m.get(key);
        } finally {
            r.unlock();
            log.info("{}释放读锁 time={}",Thread.currentThread().getName(),System.currentTimeMillis());
        }
        if (v != null) {
            log.info("{}缓存存在，返回结果 time={}",Thread.currentThread().getName(),System.currentTimeMillis());
            return v;
        }
        w.lock();
        log.info("{}缓存中不存在，查询数据库，获取写锁 time={}",Thread.currentThread().getName(),System.currentTimeMillis());
        try {
            log.info("{}二次验证 time={}",Thread.currentThread().getName(),System.currentTimeMillis());
            v = m.get(key);
            if (v == null) {
                log.info("{}查询数据库完成 time={} ",Thread.currentThread().getName(),System.currentTimeMillis());
                v = "value";
                log.info("-------------验证写锁占有的时候 其他线程无法执行写操作和读操作----------------");
                Thread.sleep(1000*5);
                m.put(key, v);
            }
        } finally {
            log.info("{}写锁释放 time={}",Thread.currentThread().getName(),System.currentTimeMillis());
            w.unlock();
        }
        return v;
    }

原创声明：本文来源于微信公众号【胖滚猪学编程】，持续更新JAVA\大数据干货，用漫画形式让编程so easy and interesting。转载请注明出处。

ReentrantReadWriteLock的特色功能

在 J.U.C Lock包之ReentrantLock互斥锁，我们介绍了ReentrantLock相比synchronized的几大特色功能，例如公平锁、非阻塞获取锁、超时、中断。那么ReentrantReadWriteLock是否也有呢？

简单。。看看源码不就清楚了。以下源码都是在ReentrantReadWriteLock.java中撩出来的~ 剩下的我就不用多说了吧！如果不清楚这些方法可以回头看看 J.U.C Lock包之ReentrantLock互斥锁

    public ReentrantReadWriteLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
        readerLock = new ReadLock(this);
        writerLock = new WriteLock(this);
    }

        public boolean tryLock(long timeout, TimeUnit unit)
                throws InterruptedException {
            return sync.tryAcquireNanos(1, unit.toNanos(timeout));
        }

        public void lockInterruptibly() throws InterruptedException {
            sync.acquireInterruptibly(1);
        }

读写锁的升级与降级

还想跟你聊聊锁的升级和降级。也许你是第一次听到，锁还有升级降级的功能。但其实不难理解，比如在读写锁中，写锁变为读锁是完全可行的方案，不会有任何问题，这里写锁变读锁就叫做锁的降级。

那么可以升级吗？熟话说降级容易，你只要天天不来上班就行了，升级可难哦。锁中也是，只是在锁中更加苛刻，完全不允许升级，即读锁无法升级为写锁。必须先释放读锁，才可以获取写锁。为什么不允许升级？试想有1000个读线程同时执行，同时升级为写锁，会发生什么？获取写锁的前提是读锁和写锁均未被占用，因此可能导致阻塞较长的时间，也可能发生死锁。

先写个代码验证一下吧，在(2)处我们实现了降级，程序是完全ok的，在(1)处如果你注释掉 r.unlock()，试图升级为读锁，你会发现程序会跑不下去的，据此可以验证我们所说的：读写锁可以降级、无法升级。

    void processCachedData() {
        // 获取读锁
        r.lock();
        if (!cacheValid) {
            // 释放读锁 因为不允许读锁的升级 可以注释掉该行代码 整个程序会阻塞
            r.unlock(); //（1）
            // 获取写锁
            w.lock();
            try {
                // 再次检查状态
                if (!cacheValid) {
                    data = "胖滚猪学编程";
                    cacheValid = true;
                }

                // 释放写锁前 降级为读锁 降级是可以的
                r.lock(); //（2）
            } finally {
                // 释放写锁
                w.unlock();

            }

        }
        // 此处仍然持有读锁
        try {
            System.out.println(data);
        } finally {
            r.unlock();
        }

    }

总结

读写锁适用于读多写少的情况。可以优化性能，提升易用性。缓存就是个很好的例子。

读写锁最大的特征是允许多个线程同时读共享变量。但是只允许一个线程写共享变量，且如果一个写线程正在执行写操作，此时禁止读线程读共享变量。

ReentrantReadWriteLock读写锁类似于 ReentrantLock，支持公平模式和非公平模式、支持非阻塞获取锁、超时、中断等特性。但是有一点需要注意，那就是只有写锁支持条件变量，读锁是不支持条件变量的，读锁调用 newCondition() 会抛出 UnsupportedOperationException 异常。

所以！我们必须了解各种锁的用途，才能在生产上选择最合适高效的方式。