读写锁（ReentrantReadWriteLock）的实现

最新推荐文章于 2025-11-04 00:15:00 发布

原创最新推荐文章于 2025-11-04 00:15:00 发布 · 637 阅读

CC 4.0 BY-SA版权

本文详细介绍了Java中的读写锁ReentrantReadWriteLock，包括其特性、接口、示例和实现细节。读写锁允许多个读线程并发访问，写线程独占，并通过AQS维护读写状态。文章还探讨了锁降级的概念，强调了锁升级不可逆以保证数据可见性。

读写锁

读写锁在同一时刻允许多个读线程访问，其他写线程阻塞；在写线程访问时，所有的读线程和其他写线程都被阻塞。

读写锁维护了一对锁，一个读锁，一个写锁，通过分离读锁和写锁，使得并发性比一般的排它锁（独占锁）有了很大提升。Java提供的读写锁是ReentrantReadWriteLock。

ReentrantReadWriteLock的特性

特性	说明
公平性选择	支持非公平(默认)和公平的锁获取方式,吞吐量方面非公平优于公平
重进入	该锁支持重进入,以读写线程为例: 读线程在获取了读锁之后,能够再次获取读锁。而写线程在获取了写锁之后能够再次获取写锁,同时也可以获取读锁
锁降级	遵循获取写锁、获取读锁再释放写锁的次序,写锁能够降级成为读锁

读写锁的接口与示例

ReentrantReadWriteLock实现了ReadWriteLock接口，该接口只有两个方法

Lock readLock();
Lock writeLock();

除了接口方法，ReentrantReadWriteLock还提供了便于外界监控内部工作状态的方法：

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qpzT38AA-1582780882861)(C:\Users\牧扬人\AppData\Roaming\Typora\typora-user-images\1582773683753.png)]$

读写锁使用示例：

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

    // 对于元素获取，使用读锁，允许多个线程并发读
    public static final Object get(String key){
        w.lock();
        try {
            return map.get(key);

        }finally{
            w.unlock();
        }
    }
    
    // 元素修改使用写锁，其他线程阻塞
    public static final Object put(String key,Object value){
        r.lock();
        try{
            return map.put(key,value);
        }finally{
            r.unlock();
        }
    }
    
    // 元素修改使用写锁，其他线程阻塞
    public static final void clear(){
        r.lock();
        try{
            map.clear();
        }finally{
            r.unlock();
        }
    }
}

读写锁的实现

1.读写状态设计

读写锁同样依赖AQS实现，它的读写状态就是基于AQS的同步状态实现的。读写锁将同步状态切分为两部分：高16位表示读状态，低16位表示写状态

在这里插入图片描述

读写锁通过位运算来快速定位读和写各自的状态：假设当前同步状态的值为c，写状态就为c&0x0000FFFF，读状态为c >>> 16（无符号位补0右移16位）。当写状态增加1状态变为c+1，当读状态增加1时，状态编码就是c+（1 <<< 16）

2.写锁的获取与释放

1).获取

写锁是一个支持重进入的排它锁。

如果当前线程已经获取了写锁，则增加写状态。
如果当前线程获取写锁时，读锁已经被获取，或者该线程不是已经获取写锁的线程，则当前线程进入等待状态

protected final boolean tryAcquire(int acquires) {
            Thread current = Thread.currentThread();
            int c = getState();
    // 获取读锁状态
            int w = exclusiveCount(c);
            if (c != 0) {
                // 如果读锁不为零或当前线程没有获取读锁
                if (w == 0 || current != getExclusiveOwnerThread())
                    return false;
                if (w + exclusiveCount(acquires) > MAX_COUNT)
                    throw new Error("Maximum lock count exceeded");
                // Reentrant acquire
                setState(c + acquires);
                return true;
            }
            if (writerShouldBlock() ||
                !compareAndSetState(c, c + acquires))
                return false;
            setExclusiveOwnerThread(current);
            return true;
        }

该方法在判断中判断了重入以及读锁是否存在，如果当前线程没有持有写锁（不是重入）或者存在读锁（读状态不为0）那么获取失败。

因为读写锁要确保写锁的操作对读锁可见，如果允许读锁在已被获取的情况下获取写锁，那么正在运行的读锁就无法感知到写锁的操作，所以才会判断是否存在读锁

2).释放

写锁的释放与ReentrantLock的过程类似，每次减少写状态，状态为0表示锁被释放。

3.读锁的获取与释放

1).获取

读锁是一个支持重进入的共享锁，能被多个线程同时获取。

在没有写锁被获取的时候，读锁总能被成功获取。
如果当前线程获取读锁时，已经有写锁被获取，则当前线程进入等待状态。
如果当前线程已经获取了读锁，则增加读状态。

读状态是所有线程获取的总次数，而每个线程各自获取的次数则保存在ThreadLocal中由线程自身维护。可以通过getReadHoleCount()方法获取当前线程获取读锁的次数。

        protected final int tryAcquireShared(int unused) {
            Thread current = Thread.currentThread();
            int c = getState();
            // 存在写锁且不是被当前线程获取的，获取失败
            if (exclusiveCount(c) != 0 &&
                getExclusiveOwnerThread() != current)
                return -1;
            int r = sharedCount(c);
            if (!readerShouldBlock() &&
                r < MAX_COUNT &&
                compareAndSetState(c, c + SHARED_UNIT)) {
                if (r == 0) {
                    firstReader = current;
                    firstReaderHoldCount = 1;
                } else if (firstReader == current) {
                    firstReaderHoldCount++;
                } else {
                    HoldCounter rh = cachedHoldCounter;
                    if (rh == null || rh.tid != getThreadId(current))
                        cachedHoldCounter = rh = readHolds.get();
                    else if (rh.count == 0)
                        readHolds.set(rh);
                    rh.count++;
                }
                return 1;
            }
            return fullTryAcquireShared(current);
        }