先做总结：
1、为什么用读写锁 ReentrantReadWriteLock？
重入锁ReentrantLock是排他锁，在同一时刻仅有一个线程可以进行访问，但是在大多数场景下，大部分时间都是提供读服务，而写服务占有的时间较少。然而读服务不存在数据竞争问题，如果一个线程在读时禁止其他线程读势必会导致性能降低。所以就提供了读写锁。
读写锁维护着一对锁，一个读锁和一个写锁。通过分离读锁和写锁，使得并发性比一般的排他锁有了较大的提升：在同一时间可以允许多个读线程同时访问，但是在写线程访问时，所有读线程和写线程都会被阻塞。
2、读写锁实现原理：
（1）每个ReentrantReadWriteLock对象都对应着读锁和写锁两个锁。
（2）ReentrantReadWriteLock通过其属性sync（继承了AQS），一个对象实现了读写两个锁。
（3）sync.state（int）分为高 16 位和低16位，高16位用于共享模式ReadLock，低16位用于独占模式WriteLock
（4）获取写锁标志：
1.sync.state的低16位（0代表没有被占用，大于0代表有线程持有当前锁(锁可以重入，每次重入都+1） 最多2^16-1次重入
2.sync.exclusiveOwnerThread == Thread.currentThread()
（5）获取读锁标志：
1.state的高16位（0代表没有被占用，大于0代表有线程持有当前锁(锁可以重入，每次重入都+1） 最多2^16-1次重入
2.ThreadLocalHoldCounter readHolds; // 记录线程持有的读锁数量（ThreadLocalHoldCounter extends ThreadLocal）
readHolds.threadLocals - Map<ThreadLocal, HoldCounter>
HoldCounter - count tid
（关于ThreadLocal：Java并发（二十）：线程本地变量ThreadLocal）
3.sync.cachedHoldCounter 记录最后一个获取读锁的线程的读锁重入次数，用于缓存提高性能
4.sync.firstReader 第一个获取读锁的线程(并且其未释放读锁)，以及它持有的读锁数量 提高性能
（6）ReentrantReadWriteLock的内部类WriteLock/ReadLock通过操作sync的属性实现的锁的操作。
一、类结构
public class ReentrantReadWriteLock implements ReadWriteLock, java.io.Serializable {
// 属性
private final ReentrantReadWriteLock.ReadLock readerLock;
private final ReentrantReadWriteLock.WriteLock writerLock;
final Sync sync; // 锁
// 内部类
abstract static class Sync extends AbstractQueuedSynchronizer {}
static final class FairSync extends Sync {}
static final class NonfairSync extends Sync {}
public static class ReadLock implements Lock, java.io.Serializable {}
public static class WriteLock implements Lock, java.io.Serializable {}
}
二、读写锁实现
ReadLock 使用了共享模式，WriteLock 使用了独占模式。
ReadLock 和 WriteLock都是通过同一个Sync实例实现的。
AQS 将 state（int）分为高 16 位和低16位，高16位用于共享模式ReadLock，低16位用于独占模式WriteLock 。
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; static int sharedCount(int c) { return c >>> SHARED_SHIFT; } // 无符号补0右移16位 - 读锁
static int exclusiveCount(int c) { return c & EXCLUSIVE_MASK; } // 抹掉高16位 - 写锁
WriteLock：
1.state的低16位（0代表没有被占用，大于0代表有线程持有当前锁(锁可以重入，每次重入都+1） 最多2^16-1次重入
2.exclusiveOwnerThread == Thread.currentThread()
ReadLock：
1.state的高16位（0代表没有被占用，大于0代表有线程持有当前锁(锁可以重入，每次重入都+1） 最多2^16-1次重入
2.ThreadLocalHoldCounter readHolds; // 记录线程持有的读锁数量
readHolds.threadLocals - Map<Thread, HoldCounter>
HoldCounter - count tid
三、源码分析
写锁获取：
// ReentrantReadWriteLock.WriteLock.lock()
public void lock() {
sync.acquire(1);
} // AbstractQueuedSynchronizer.acquire(int)
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
} /**
* ReentrantReadWriteLock.Sync.tryAcquire(int)
* 可以获取写锁的两种情况：
* 1.没有线程占用该锁(读锁和写锁都没有被占用)
* 2.当前线程已经拿到过该写锁，重入
*/
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) // 重入锁上限 2^16-1
throw new Error("Maximum lock count exceeded");
setState(c + acquires);
return true;
}
// 没有线程占用该锁,直接获取锁
if (writerShouldBlock() || // 如果是公平锁需要排队
!compareAndSetState(c, c + acquires))
return false;
setExclusiveOwnerThread(current);
return true;
}
写锁释放：
// ReentrantReadWriteLock.WriteLock.unlock()
public void unlock() {
sync.release(1);
} // AbstractQueuedSynchronizer.release(int)
public final boolean release(int arg) {
if (tryRelease(arg)) {
Node h = head;
if (h != null && h.waitStatus != 0)
unparkSuccessor(h);
return true;
}
return false;
} /**
* ReentrantReadWriteLock.Sync.tryRelease(int)
* 释放写锁：维护state和exclusiveOwnerThread
*
*/
protected final boolean tryRelease(int releases) {
if (!isHeldExclusively())
throw new IllegalMonitorStateException();
int nextc = getState() - releases;
boolean free = exclusiveCount(nextc) == 0;
if (free)
setExclusiveOwnerThread(null);
setState(nextc);
return free;
}
读锁
abstract static class Sync extends AbstractQueuedSynchronizer {
// 这个嵌套类的实例用来记录每个线程持有的读锁数量(读锁重入)
static final class HoldCounter {
int count = 0; // 持有的读锁数
final long tid = getThreadId(Thread.currentThread()); // 线程 id
}
static final class ThreadLocalHoldCounter extends ThreadLocal<HoldCounter> {
public HoldCounter initialValue() {
return new HoldCounter();
}
}
/**
* 组合使用上面两个类，用一个 ThreadLocal 来记录线程持有的读锁数量
*/
private transient ThreadLocalHoldCounter readHolds;
/**
* 用于缓存，记录最后一个获取读锁的线程的读锁重入次数
* 不管哪个线程获取到读锁后，就把这个值占为已用，这样就不用到 ThreadLocal 中查询 map 了
* 通常读锁的获取很快就会伴随着释放，在 获取->释放 读锁这段时间，如果没有其他线程获取读锁的话，此缓存就能帮助提高性能
*/
private transient HoldCounter cachedHoldCounter;
/**
* 第一个获取读锁的线程(并且其未释放读锁)，以及它持有的读锁数量
* 提高性能用
*/
private transient Thread firstReader = null;
private transient int firstReaderHoldCount;
}
读锁获取：
// ReentrantReadWriteLock.ReadLock.lock()
public void lock() {
sync.acquireShared(1);
} // AbstractQueuedSynchronizer.acquireShared(int)
public final void acquireShared(int arg) {
if (tryAcquireShared(arg) < 0)
doAcquireShared(arg);
} /**
* ReentrantReadWriteLock.Sync.tryAcquireShared(int)
* 可以获取读锁情况：
* 1.没有线程占用该锁
* 2.只有读锁
* 3.有写锁，写锁被当前线程占用，锁降级
* 三种情况 - 只要没有其他线程占用写锁就可以获取读锁
*/
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,表示可以拿到读锁了
if (r == 0) { // 将"第一个"获取读锁的线程记录在firstReader属性中
firstReader = current;
firstReaderHoldCount = 1;
} else if (firstReader == current) {
firstReaderHoldCount++;
} else { // 1.当前线程及对应读锁次数存入cachedHoldCounter 2.当前线程及对应读锁次数存入readHolds
HoldCounter rh = cachedHoldCounter;
if (rh == null || rh.tid != getThreadId(current))
cachedHoldCounter = rh = readHolds.get();// readHolds中取当先线程的ThreadLocal(没有就创建一个)
else if (rh.count == 0)
readHolds.set(rh);
rh.count++;
}
return 1;
}
return fullTryAcquireShared(current);// 公平锁排队非公平锁下一个是写锁/读锁重入次数上限/CAS失败 重新拿读锁
} /**
* ReentrantReadWriteLock.Sync.fullTryAcquireShared(Thread)
*/
final int fullTryAcquireShared(Thread current) {
HoldCounter rh = null;
for (;;) { // 循环CAS拿锁
int c = getState();
if (exclusiveCount(c) != 0) {
if (getExclusiveOwnerThread() != current) // 其他线程占用写锁
return -1;
} else if (readerShouldBlock()) { // 处理读锁重入,将cachedHoldCounter设置为当前线程
if (firstReader == current) {
// assert firstReaderHoldCount > 0;
} else {
if (rh == null) {
rh = cachedHoldCounter;
if (rh == null || rh.tid != getThreadId(current)) {
rh = readHolds.get();
if (rh.count == 0)
readHolds.remove();
}
}
if (rh.count == 0) // 不是重入，返回-1
return -1;
}
}
if (sharedCount(c) == MAX_COUNT)
throw new Error("Maximum lock count exceeded");
if (compareAndSetState(c, c + SHARED_UNIT)) { // 正常拿读锁
if (sharedCount(c) == 0) {
firstReader = current;
firstReaderHoldCount = 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; // cache for release
}
return 1;
}
}
}
锁降级：
持有写锁的线程，去获取读锁的过程称为锁降级
读锁释放：
// ReentrantReadWriteLock.ReadLock.unlock()
public void unlock() {
sync.releaseShared(1);
} // AbstractQueuedSynchronizer.releaseShared(int)
public final boolean releaseShared(int arg) {
if (tryReleaseShared(arg)) {
doReleaseShared();
return true;
}
return false;
} /**
* ReentrantReadWriteLock.Sync.tryReleaseShared(int)
* 维护readHolds state
*/
protected final boolean tryReleaseShared(int unused) {
Thread current = Thread.currentThread();
if (firstReader == current) { // 第一个获取读锁的线程
if (firstReaderHoldCount == 1)
firstReader = null;
else
firstReaderHoldCount--;
} else { // readHolds中次数-1
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 (;;) { // state
int c = getState();
int nextc = c - SHARED_UNIT;
if (compareAndSetState(c, nextc))
// Releasing the read lock has no effect on readers,
// but it may allow waiting writers to proceed if
// both read and write locks are now free.
return nextc == 0;
}
}