AQS之ReentrantReadWriteLock源码总结

最新推荐文章于 2024-11-12 21:14:07 发布

Butterfly(Papillon)

最新推荐文章于 2024-11-12 21:14:07 发布

阅读量946

点赞数 1

文章标签： java 后端

本文链接：https://blog.csdn.net/weixin_36279234/article/details/122342814

版权

java并发包下面提供了读写锁ReentrantReadWriteLock，在读多余写的情况下，续写所能提供比排它锁更好的并发性和吞吐量。它内部维护了一对读写锁，一个用于只读操作，称作读锁；一个用于写入操作，称作写锁。此外，在没有写操作时，读读操作可以并发，其他写读、读写和写写操作都是互斥的。

读写锁三个重要的特性：

公平性选择：支持非公平和公平的锁获取方式，默认是非公平，因为非公平吞吐量比公平锁高。

可重入：读锁和写锁都支持线程重入

锁降级：线程获取写锁后，在获取读锁之后释放写锁的过程为写锁降级为读锁

应用场景

我们知道HashMap是线程不安全的，通过读写锁ReentrantReadWriteLock不仅可以使其保证线程安全，在读多写少的情况下还能保证良好的吞吐量。从应用场景来看，不难猜测，读锁是通过AQS的共享锁实现的，支持多线程同时获得锁；而写锁为互斥锁是通过AQS的独占锁实现的。

public class RWDictionary {
    private final Map<String, Object> m = new HashMap<>();
    private final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
    private final Lock r = rwl.readLock();
    private final Lock w = rwl.writeLock();

    public Object get(String key) {
        r.lock();
        try {
            return m.get(key);
        } finally {
            r.unlock();
        }
    }

    public Object[] allKeys() {
        r.lock();
        try {
            return m.keySet().toArray();
        } finally {
            r.unlock();
        }
    }

    public Object put(String key, Object value) {
        w.lock();
        try {
            return m.put(key, value);
        } finally {
            w.unlock();
        }
    }

    public void clear() {
        w.lock();
        try {
            m.clear();
        } finally {
            w.unlock();
        }
    }

    public static void main(String[] args) {
        RWDictionary dictionary = new RWDictionary();
        dictionary.put("str", "str");
        log.debug(dictionary.get("str").toString());
    }
}

锁降级：

锁降级是指写锁降级为读锁。注意：锁降级是在把持住写锁，再获取读锁，随后释放写锁的过程；锁降级可以帮助当前线程修改公共资源后继续使用不被其他线程更新而导致更新丢失。

public class CachedData {
    Object data;
    volatile boolean cacheValid;
    final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();

    void processCachedData() {
        rwl.readLock().lock();
        if (!cacheValid) {
            // Must release read lock before acquiring write lock
            rwl.readLock().unlock();
            rwl.writeLock().lock();
            try {
                // Recheck state because another thread might have
                // acquired write lock and changed state before we did.
                if (!cacheValid) {
                    data = "data";
                    cacheValid = true;
                }
                // Downgrade by acquiring read lock before releasing write lock
                rwl.readLock().lock();
            } finally {
                rwl.writeLock().unlock(); // Unlock write, still hold read
            }
        }
        try {
            log.debug("test：{}", data);
        } finally {
            rwl.readLock().unlock();
        }
    }
}

锁降级中读锁的获取是否必要呢？答案是必要的。主要是为了保证数据的可见性，如果当前线程不获取读锁而是直接释放写锁，假设此刻另一个线程（记作线程T）获取了写锁并修改了数据，那么当前线程无法感知线程T的数据更新。如果当前线程获取读锁，即遵循锁降级的步骤，则线程T将会被阻塞，直到当前线程使用数据并释放读锁之后，线程T才能获取写锁进行数据更新

读写锁状态的state设计

上面已经说到，ReentrantReadWriteLock是通过AQS的独占锁和共享锁实现写锁和读锁的，那么在底层是如何通过一个int类型变量state表示这两种状态的呢？我们知道int类型在java中是有4个字节32位构成的，这里通过高16位表示读状态，低16位表示写状态，高低位的数值大小分别表示读写的重入次数。