Java并发：ReadWriteLock 读写锁

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

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

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

ReadWriteLock 接口：

 1 public interface ReadWriteLock {
 2     /**
 3      * Returns the lock used for reading.
 4      *
 5      * @return the lock used for reading
 6      */
 7     Lock readLock();
 8
 9     /**
10      * Returns the lock used for writing.
11      *
12      * @return the lock used for writing
13      */
14     Lock writeLock();
15 }

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

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

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

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

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

读写锁的实现：

① 读写状态的设计

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

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

1         static final int SHARED_SHIFT   = 16;
2         static final int SHARED_UNIT    = (1 << SHARED_SHIFT);
3         static final int MAX_COUNT      = (1 << SHARED_SHIFT) - 1;
4         static final int EXCLUSIVE_MASK = (1 << SHARED_SHIFT) - 1;
5
6         /** 返回当前状态的共享资源数，消除低16位  */
7         static int sharedCount(int c)    { return c >>> SHARED_SHIFT; }
8         /** 返回当前线程的独占资源数，按位与& 0x0000FFFF 除去高16位  */
9         static int exclusiveCount(int c) { return c & EXCLUSIVE_MASK; }

② 写锁的获取与释放

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

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

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

写锁的释放与 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);　　// 死循环获取读锁
        }

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

 1     final int fullTryAcquireShared(Thread current) {
 2             /*
 3              *  该代码与tryAcquireShared中的代码部分冗余，但由于不使
 4              *  tryAcquireShared与重试和延迟读取保持计数之间的交互复杂化，
 5              *  因此总体上更简单。
 6              */
 7             HoldCounter rh = null;
 8             for (;;) {
 9                 int c = getState();　　
10                 if (exclusiveCount(c) != 0) {  // 低16位不为0，有线程有写锁
11                     if (getExclusiveOwnerThread() != current) // 写锁被其他线程持有，获取锁失败
12                         return -1;
13                     // 否则我们将持有排他锁；在这里阻塞
14                     // 将导致死锁
15                 } else if (readerShouldBlock()) {
16                     // 确保我们不会再获取读锁，若第一个读取线程为当前进程
17                     if (firstReader == current) {
18                         // 断言 firstReaderHoldCount > 0;
19                     } else { // 若不是当前线程
20                         if (rh == null) {
21                             rh = cachedHoldCounter;
22                             if (rh == null || rh.tid != getThreadId(current)) {
23                                 rh = readHolds.get(); // 从ThreadLocal中取出计数器
24                                 if (rh.count == 0)
25                                     readHolds.remove();
26                             }
27                         }
28                         if (rh.count == 0)
29                             return -1;
30                     }
31                 }
32                 if (sharedCount(c) == MAX_COUNT)
33                     throw new Error("Maximum lock count exceeded");
34                 if (compareAndSetState(c, c + SHARED_UNIT)) {　　// 尝试设置读锁，高16位加1
35                     if (sharedCount(c) == 0) {　　// 读锁空闲
36                         firstReader = current;
37                         firstReaderHoldCount = 1;// 计数为1
38                     } else if (firstReader == current) { // 不为空闲的话看看第一个线程是否为当前进程，是则更新当前计数器
39                         firstReaderHoldCount++;
40                     } else {　　// 不是当前线程
41                         if (rh == null)
42                             rh = cachedHoldCounter;
43                         if (rh == null || rh.tid != getThreadId(current))　　// 如果最后一个读计数器所属线程不是当前线程
44                             rh = readHolds.get();　　　　　　　　　　　　　　　　 // 自己新建一个
45                         else if (rh.count == 0)
46                             readHolds.set(rh);
47                         rh.count++;
48                         cachedHoldCounter = rh; // 更新缓存计数器
49                     }
50                     return 1;
51                 }
52             }
53         }
54                 

④ 降级锁

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