Java并发：ReadWriteLock 读写锁

读写锁在同一时刻可以允许多个线程访问，但是在写线程访问，所有的读线程和其他写线程均被阻塞。

读写锁不像 ReentrantLock 那些排它锁只允许在同一时刻只允许一个线程进行访问，读写锁可以允许多个线程同时访问，并发性能相比一般的排它锁有很大的提升。

当写操作开始时，所有晚于写操作的读操作均会进入等待状态，只有写操作完成并进行通知后，所有等待的读操作才能继续执行，这样的目的是能正确读到的数据，而不会出现脏读。

ReadWriteLock 接口：

public interface ReadWriteLock {
    /**
     * Returns the lock used for reading.
     *
     * @return the lock used for reading
     */
    Lock readLock();

    /**
     * Returns the lock used for writing.
     *
     * @return the lock used for writing
     */
    Lock writeLock();
}

读写锁维护了一个读锁和一个写锁。

ReentrantReadWriteLock 是 ReadWriteLock 接口的一个实现。Java 类图如下：

静态抽象内部类 Sync 继承了 AQS，对 ReentrantReadWriteLock 提供了支持。

ReentrantReadWriteLock 除开接口的方法外，还有展示内部工作状态的方法：

方法名称	描述
int getReadLockCount()	返回当前读锁被获取的次数
int getReadHoldCount()	返回当前线程获取读锁的次数
boolean isWriteLocked()	判断写锁是否被获取
int getReadHoldCount()	返回当前写锁被获取的次数

读写锁的实现：

① 读写状态的设计

读写锁同样是依赖自定义同步器来实现同步功能，而读写状态就是其同步器的同步状态。和 ReentrantLock 有点不同，读写锁的自定义同步器需要在同步状态（一个整型变量）上维护多个读线程和一个写线程的状态。

一个整型变量维护多个状态，就需要按其二进制位“切割”使用，读写锁把这个32位的整型变量分成了两个部分：高16位表示读状态，低16位表示写状态。

        static final int SHARED_SHIFT   = 16;
        static final int SHARED_UNIT    = (1 << SHARED_SHIFT);
        static final int MAX_COUNT      = (1 << SHARED_SHIFT) - 1;
        static final int EXCLUSIVE_MASK = (1 << SHARED_SHIFT) - 1;

        /** 返回当前状态的共享资源数，消除低16位  */
        static int sharedCount(int c)    { return c >>> SHARED_SHIFT; }
        /** 返回当前线程的独占资源数，按位与& 0x0000FFFF 除去高16位  */
        static int exclusiveCount(int c) { return c & EXCLUSIVE_MASK; }

② 写锁的获取与释放

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

    protected final boolean tryAcquire(int acquires) {
            /*
             * 可能的过程:
             * 1. 如果读取计数非零或写入计数非零并且所有者是另一个线程，则失败。
             * 2. 如果计数饱和，则失败。（计数不为0）
             * 3. 否则，如果是可重入获取或队列策略允许，
             *     则该线程有资格进行锁定。如果是这样，请更新状态*并设置所有者.
             */
            Thread current = Thread.currentThread();
            int c = getState();
            int w = exclusiveCount(c);
            if (c != 0) {
                // 存在读锁或者当前线程不是已获取锁的线程(Note: if c != 0 and w == 0 then shared count != 0)
                if (w == 0 || current != getExclusiveOwnerThread())
                    return false;
                if (w + exclusiveCount(acquires) > MAX_COUNT)
                    throw new Error("Maximum lock count exceeded");
                // 重入获取
                setState(c + acquires);
                return true;
            }
            if (writerShouldBlock() ||
                !compareAndSetState(c, c + acquires))
                return false;
            setExclusiveOwnerThread(current);
            return true;
        }

如果读锁存在，则写锁不能被获取，读写锁要确保写锁的操作对读锁可见，只有等待其他线程释放了读锁，写锁才能被获取。当写锁获取到，其他读写线程的后续访问均被阻塞。

写锁的释放与 ReentrantLock 基本类似，每次释放均减少同步状态值，写状态为0是表示锁已被释放，其他读写线程才能继续访问读写锁，同时前一次写线程的修改对后续的读写进程可见。

③ 读锁的获取与释放

    protected final int tryAcquireShared(int unused) {
            /*
             * 可能的情况:
             * 1. 如果另一个线程持有写锁，则失败。
             * 2. 否则，此线程有资格获得锁定状态，因此询问是否由于队列策略而应阻塞。
             *    如果不是，尝试按CAS方式更新计数。
             *    请注意，该步骤不检查重入获取，这会推迟到完整版本的获取方法，
             *    以避免必须在更典型的非重入情况下检查保留计数。
             * 3. 如果第2步失败，或者由于线程显然不符合条件或者CAS失败或计数饱和，请使用完全死循环版本。
             */
            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)) {　　// 在合适的条件下尝试用CAS设置
                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)　　// 如果不是空的，且count是0，将上一个线程的HoldCounter覆盖本地的
                        readHolds.set(rh);
                    rh.count++;
                }
                return 1;
            }
            return fullTryAcquireShared(current);　　// 死循环获取读锁
        }

 完整版本的获取读锁（死循环），包含降级策略

    final int fullTryAcquireShared(Thread current) {
            /*
             *  该代码与tryAcquireShared中的代码部分冗余，但由于不使 
             *  tryAcquireShared与重试和延迟读取保持计数之间的交互复杂化，
             *  因此总体上更简单。
             */
            HoldCounter rh = null;
            for (;;) {
                int c = getState();　　
                if (exclusiveCount(c) != 0) {  // 低16位不为0，有线程有写锁
                    if (getExclusiveOwnerThread() != current) // 写锁被其他线程持有，获取锁失败
                        return -1;
                    // 否则我们将持有排他锁；在这里阻塞
                    // 将导致死锁
                } else if (readerShouldBlock()) {
                    // 确保我们不会再获取读锁，若第一个读取线程为当前进程
                    if (firstReader == current) {
                        // 断言 firstReaderHoldCount > 0;
                    } else { // 若不是当前线程
                        if (rh == null) {
                            rh = cachedHoldCounter;
                            if (rh == null || rh.tid != getThreadId(current)) {
                                rh = readHolds.get(); // 从ThreadLocal中取出计数器
                                if (rh.count == 0)
                                    readHolds.remove();
                            }
                        }
                        if (rh.count == 0)
                            return -1;
                    }
                }
                if (sharedCount(c) == MAX_COUNT)
                    throw new Error("Maximum lock count exceeded");
                if (compareAndSetState(c, c + SHARED_UNIT)) {　　// 尝试设置读锁，高16位加1
                    if (sharedCount(c) == 0) {　　// 读锁空闲
                        firstReader = current;
                        firstReaderHoldCount = 1;// 计数为1
                    } else if (firstReader == current) { // 不为空闲的话看看第一个线程是否为当前进程，是则更新当前计数器
                        firstReaderHoldCount++;
                    } else {　　// 不是当前线程
                        if (rh == null)
                            rh = cachedHoldCounter;
                        if (rh == null || rh.tid != getThreadId(current))　　// 如果最后一个读计数器所属线程不是当前线程
                            rh = readHolds.get();　　　　　　　　　　　　　　　　 // 自己新建一个
                        else if (rh.count == 0)
                            readHolds.set(rh);
                        rh.count++;
                        cachedHoldCounter = rh; // 更新缓存计数器
                    }
                    return 1;
                }
            }
        }
                

④ 降级锁

降级锁从获取到写锁开始。降级锁是指把持有的写锁，再获取到读锁，锁后释放写锁的过程。锁降级中读锁的获取是必要的，主要是为了保证数据获取的可见性，如果当前线程不获取读锁而是直接释放写锁，此刻若是有一个线程获取到写锁并修改了数据，当前的线程就无法感知之后那个线程的数据更新。若当前线程获取了读锁再释放写锁，之后那个想要获取写锁的线程就会被阻塞，直到当前线程释放了读锁之后，下个想获取写锁的线程才能进行数据更新。