通常我们用的 Synchronized 和 ReentrantLock 都是独占锁，即在同一时刻只有一个线程获取到锁。然而在有些业务场景中，我们大多在读取数据，很少写入数据。这种情况下，如果仍使用独占锁，效率将及其低下。针对这种情况，Java提供了读写锁——ReentrantReadWriteLock。读写锁允许同一时刻被多个读线程访问，但是在写线程访问时，所有的读线程和其他的写线程都会被阻塞。
接下来从源码的角度分析ReentrantReadWriteLock。
成员变量和构造器：
//内部类提供的读锁 private final ReentrantReadWriteLock.ReadLock readerLock; //=内部类提供的写锁 private final ReentrantReadWriteLock.WriteLock writerLock; //同步器 final Sync sync; /** 构造器 */ //默认构造非公平的读写锁 public ReentrantReadWriteLock() { this(false); } //可选的构造公平或非公平的读写锁 public ReentrantReadWriteLock(boolean fair) { sync = fair ? new FairSync() : new NonfairSync(); readerLock = new ReadLock(this); writerLock = new WriteLock(this); }
读写锁的同步状态维护了写锁和读锁的状态，高16位表示读锁状态，低16位表示写锁状态。假设当前同步状态值为c，写状态等于c&0x0000FFFF（将高16位全部抹去），读状态等于c>>>16（无符号补0右移16位）。当写状态增加1时，等于c+1，当读状态增加1时，等于c+(1<<16)，也就是c+0x00010000。
写锁的获取与释放
获取
步骤：
1、获取同步状态c 和写锁状态 w。如果 c==0 ，w肯定为0，表示写锁未被获取，则将当前线程CAS获取写锁；
2、如果 c!=0且w==0 ，则读状态大于0，即读锁被获取，那么当前线程进入等待状态
如果 c!=0且w!=0 ，则写锁被获取；如果当前线程不是写锁的拥有者，则当前线程进入等待状态
如果w!=0且当前线程获得写锁，则可重入获取写锁
该方法除了重入条件（当前线程为获取了写锁的线程）之外，增加了一个读锁是否存在的判断。如果存在读锁，则写锁不能被获取，原因在于：读写锁要确保写锁的操作对读锁可见，如果允许读锁在已被获取的情况下对写锁的获取，那么正在运行的其他读线程就无法感知到当前写线程的操作。因此，只有等待其他读线程都释放了读锁，写锁才能被当前线程获取，而写锁一旦被获取，则其他读写线程的后续访问均被阻塞。
protected final boolean tryAcquire(int acquires) { Thread current = Thread.currentThread(); int c = getState(); //获取写锁的同步状态 int w = exclusiveCount(c); if (c != 0) { // 如果 c!=0且w==0 ，则读状态大于0，即读锁被获取，那么当前线程进入等待状态 // 如果 c!=0且w!=0 ，则写锁被获取；如果当前线程不是写锁的拥有者，则当前线程进入等待状态 if (w == 0 || current != getExclusiveOwnerThread()) return false; // w==0且当前线程持有写锁 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; }释放
1、如果当前线程不是写锁的占有者，抛出异常
2、写状态减1，如果写状态为0，写锁占有线程设为null
protected final boolean tryRelease(int releases) { //当前线程是否是写锁的占有者 if (!isHeldExclusively()) throw new IllegalMonitorStateException(); //写状态的增加与减少是直接在同步状态上做加减 //读状态的增加与减少需要对参数进行移位操作 int nextc = getState() - releases; //如果写状态为0，则不存在写锁了 boolean free = exclusiveCount(nextc) == 0; if (free) setExclusiveOwnerThread(null); setState(nextc); return free; }读锁的获取与释放
获取
读锁是一个支持重进入的共享锁，它能够被多个线程同时获取，在没有其他写线程访问（或者写状态为0）时，读锁总会被成功地获取，而所做的也只是（线程安全的）增加读状态。如果当前线程已经获取了读锁，则增加读状态。如果当前线程在获取读锁时，写锁已被其他线程获取，则进入等待状态。
解释相关属性：
firstReader ：是第一个获取读锁的线程。
firstReaderHoldCount：是firstThread持有读锁的数目。
cachedHoldCounter ：表示上一个成功获取读锁的线程的读锁计数器。
readHolds：ThreadLocal，它存储着每一个线程读锁的持有数。
根据偏向锁我们知道大多数情况下，锁不仅不存在多线程竞争，而且总是由同一线程多次获得。所以个人觉得设置firstReader和cachedHoldCounter 就是由于这个原因，使得获取锁的效率更高。下面介绍读锁的获取步骤：
1、获取同步状态c，获取写锁状态w、读锁状态r。
2、如果w!=0且写锁被其他线程获取，则进入等待状态。
3.1、如果读锁未被获取(r==0)，则设置当前线程为第一个获取读锁的线程，并设置持有读锁数目为1
3.2、如果当前线程是第一个获取读锁的线程，则持有读锁的数目加1
3.3、如果读锁被获取了，且当前线程不是第一个获取读锁的线程。那么：
3.3.1 如果上一个获取读锁的线程不是当前线程，则拿到当前线程的ThreadLocal变量，并赋予cachedHoldCounter，持有读锁数目加1
3.3.2 如果上一个获取读锁的线程是当前线程，直接持有读锁数目加1
protected final int tryAcquireShared(int unused) { Thread current = Thread.currentThread(); int c = getState(); /** * 写锁状态不为0 并且 当前线程不是写锁的占有者，即写锁由其他 * 线程占有，则获取读锁失败 */ if (exclusiveCount(c) != 0 && getExclusiveOwnerThread() != current) return -1; //读锁的同步状态 int r = sharedCount(c); // 读状态的增加与减少需要对参数进行移位操作 // compareAndSetState(c, c + SHARED_UNIT) 即为c+ 1<<16 if (!readerShouldBlock() && r < MAX_COUNT && compareAndSetState(c, c + SHARED_UNIT)) { //如果读锁未被获取 if (r == 0) { //firstThread 是第一个获取读锁的线程 //firstReaderHoldCount 是firstThread持有读锁的数目 firstReader = current; firstReaderHoldCount = 1; //如果当前线程是第一个获取读锁的线程，则计数器++ } else if (firstReader == current) { firstReaderHoldCount++; //如果读锁被获取了，且当前线程不是第一个获取读锁的线程 } else { //HoldCounter是每一个线程读锁持有数目的计数器，它包含两个成员变量：count和线程id //cachedHoldCounter表示上一个成功获取读锁的线程的读锁计数器 HoldCounter rh = cachedHoldCounter; /** * rh==null 表示这是第一个获取读锁的线程 * rh.tid != rh.tid != getThreadId(current)) 表示当前线程不是上一个成功获取读锁的线程 * 其实下面的if和else if都是在更新cachedHoldCounter，读锁持有数目的增加在rh.count++ */ if (rh == null || rh.tid != getThreadId(current)) //获得当前线程的计数器 并将其设为cachedHoldCounter cachedHoldCounter = rh = readHolds.get(); else if (rh.count == 0) readHolds.set(rh); rh.count++; } return 1; } return fullTryAcquireShared(current); }从28行开始，乍看之下不知道在做些什么，其实我们举个获取读锁的例子，然后根据代码一步步操作就会发现很简单。 举个例子：假定此时readHold是的状态如下图，上一个成功获取读锁的线程为1003。
此时线程1004来获取读锁(当前线程是1004)。从上面代码28行开始：我们将1003的计数器赋予了rh，由于rh不为null且当前线程不是1003，所以我们获取当前线程的计数器(实际上就是线程id=1004，count=0)，并将该计数器赋予rh和cachedHoldCounter；然后进行rh.count++，即读锁计数加1.
a处黑线代码中没有该操作，我这里是说明1004的计数器由readHolds维护。
同样，如果现在是1002线程来获取读锁，那么获取1002线程的计数器，然后进行相应操作。
释放
如果弄懂了读锁的获取，那么读锁的释放就很简单了。同样是获取到readHolds中维护的线程的计数器，然后对计数器进行减1操作，同时如果计数器为0，则从readHolds中移除。
protected final boolean tryReleaseShared(int unused) { Thread current = Thread.currentThread(); if (firstReader == current) { // assert firstReaderHoldCount > 0; if (firstReaderHoldCount == 1) firstReader = null; else firstReaderHoldCount--; } else { HoldCounter rh = cachedHoldCounter; if (rh == null || rh.tid != getThreadId(current)) rh = readHolds.get(); int count = rh.count; if (count <= 1) { readHolds.remove(); if (count <= 0) throw unmatchedUnlockException(); } --rh.count; } for (;;) { int c = getState(); int nextc = c - SHARED_UNIT; if (compareAndSetState(c, nextc)) return nextc == 0; } }
