此处源码分析，主要是基于读锁，非公平机制，JDK1.8。
问题：
1、ReentrantReadWriteLock是如何创建读锁与写锁？
2、读锁与写锁的区别是什么？
3、锁的重入次数与获取锁的线程数分别是用哪种方式记录的？
4、当队列中出现多个共享模式的线程节点连续排列时，那么当第一个共享模式的线程拿到锁之后，后面的共享线程节点怎么获取锁？
一、创建ReadLock。
ReentrantReadWriteLock rrw = new ReentrantReadWriteLock();
public ReentrantReadWriteLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
readerLock = new ReadLock(this);
writerLock = new WriteLock(this);
}
rrw.readLock().lock();
1、当fair的值为false时，非公平的方式创建锁，当fair的值为true时，公平的方式创建锁。
2、初始化readerLock与writerLock，这两个变量是ReentrantReadWriteLock的内部变量。
3、sync执行非公平的锁。
二、lock()源码分析
2.1、sync.acquireShared(1)
public void lock() {
sync.acquireShared(1);
}
public final void acquireShared(int arg) {
if (tryAcquireShared(arg) < 0)
doAcquireShared(arg);
}
(1)tryAcquireShared的作用是当前线程获取读锁，当返回1时，表示获取成功，-1表示获取失败。
(2)doAcquireShared，表示获取失败的时候调用。将获取失败的线程加入到等待队列中，并调用LockSupport.park方法阻塞住，等待线程释放permit。
2.2、tryAcquireShared(arg)
protected final int tryAcquireShared(int unused) {
Thread current = Thread.currentThread();
// 获取到占有锁的线程数
int c = getState();
// 如果写锁被占领了且不是当前线程占领，那么直接返回 -1
if (exclusiveCount(c) != 0 &&
getExclusiveOwnerThread() != current)
return -1;
int r = sharedCount(c); // 占有共享锁的线程数
if (!readerShouldBlock() && // 如果队列的头节点的next节点是独享模式的线程节点即获取写锁的线程节点，返回true
r < MAX_COUNT && // 共享的数据不能超过65535
compareAndSetState(c, c + SHARED_UNIT)) { // cas设置state
if (r == 0) { // 线程来拿读锁，读锁和写锁没有被任何线程拥有，那么r==0
firstReader = current; //
firstReaderHoldCount = 1;
} else if (firstReader == current) { // 如果线程重复获取读锁，那么从这里开始重入
firstReaderHoldCount++;
} else { // 如果读锁被线程x占领，线程y也要来申请读锁，那么分支就走到这里了
// HoldCounter类中存储了两个属性，一个是count,用于记录线程的重入次数，一个是tid，记录当前线程的id
HoldCounter rh = cachedHoldCounter;
// 线程x拥有读锁之后，线程y第一次申请的时候会走到这里
//cachedHoldCounter 是一个缓存，保存当前操作线程的上一个线程的操作结果。线程y操作完之后，就会保存线程y的信息
// 如果另外一个线程z来获取到读锁的时候，虽然rh！=null，但是rh.tid != getThreadId(current),
//那么会创建一个默认的HoldCounter，并保存到cachedHoldCounter,并且默认的count=0
if (rh == null || rh.tid != getThreadId(current))
// readHolds.get(),查看源码可以知道，在这个方法中包含了数据初始化的过程，会调用ReentrantReadWriteLock.java
// 下面的方法
/**
* public HoldCounter initialValue() {
* return new HoldCounter();
* }
*/
cachedHoldCounter = rh = readHolds.get();
else if (rh.count == 0) // 这个分支也会来到，当线程释放锁，但是没有关闭，当再次调用线程时，readHolds中会存在HoldCounter，count=0
readHolds.set(rh);
rh.count++; // 计算重入的次数
}
return 1;
}
return fullTryAcquireShared(current);
}
请注意：
(1)ReentrantReadWriteLock中维持了一个类ThreadLocalHoldCounter，这个类会生成一个map,key是线程的id,value是HoldCounter对象，HoldCounter对象如下：
static final class HoldCounter {
int count = 0;
// Use id, not reference, to avoid garbage retention
final long tid = getThreadId(Thread.currentThread());
}
其中count就是线程的重入次数，tid就是当前线程的id。这个是与ReentrantLock区别的地方。
(2)ReentrantReadWriteLock使用32位int类型来表示占有锁的线程数，其中高16位是获取到读锁的线程数，低16位是获取到写锁的线程数,提供了计算线程数的方法。
static final int SHARED_SHIFT = 16;（1）
static final int SHARED_UNIT = (1 << SHARED_SHIFT);（2）
static final int MAX_COUNT = (1 << SHARED_SHIFT) - 1;（3）
static final int EXCLUSIVE_MASK = (1 << SHARED_SHIFT) - 1;（4）
/** Returns the number of shared holds represented in count */
static int sharedCount(int c) { return c >>> SHARED_SHIFT; }（5）
/** Returns the number of exclusive holds represented in count */
static int exclusiveCount(int c) { return c & EXCLUSIVE_MASK; }（6）
c + SHARED_UNIT
其中(1)是共享移动常量；(2)是共享添加的常量；（3）是最大线程数65535（也就是11111111 11111111）；（4）跟（3）一样；（5）计算共享线程数，把c的值向右移16为，并且高位补0； >>> 无符号右移,高位补0；（6）计算独享的线程数，把c的值与11111111 11111111 按位与，这样其实就是取到了写锁的线程数;（7）是共享线程+1。
源码分析：
2.2.1、readerShouldBlock()
这个方法的作用是把判断当前获取读锁的线程是否需要阻塞，条件是：在等待队列中头节点的下一个节点是独享模式的线程。
// 读锁应该被阻塞
final boolean readerShouldBlock() {
return apparentlyFirstQueuedIsExclusive();
}
/**
* Returns {@code true} if the apparent first queued thread, if one
* exists, is waiting in exclusive mode. If this method returns
* {@code true}, and the current thread is attempting to acquire in
* shared mode (that is, this method is invoked from {@link
* #tryAcquireShared}) then it is guaranteed that the current thread
* is not the first queued thread. Used only as a heuristic in
* ReentrantReadWriteLock.
*如果第一个入队列的线程节点存在，并且工作在独享模式下，那么返回true;
*如果这个方法返回true,并且当前线程以共享的模式获取锁，这个方法保证了它不是第一个入队列的
*（读锁与读锁都是共存的，所以不会入队，只有当队列中有独享模式的线程节点的时候，获取共享模式的线程才会加入到队列中。）
*/
final boolean apparentlyFirstQueuedIsExclusive() {
Node h, s;
// 头节点存在，并且存在下一个节点，下一个节点是独享模式，下一个节点的thread不是空，则返回true
return (h = head) != null &&
(s = h.next) != null &&
!s.isShared() &&
s.thread != null;
}
2.2.2、fullTryAcquireShared(current)
这个方法的作用与tryAcquireShared的作用很类似。
// 进入这个方法的条件，
/**条件1：!readerShouldBlock() && // 如果第一个入队列的线程节点存在，并且工作在独享模式下，那么返回true;
* 条件2：r < MAX_COUNT && // 共享的数据不能超过65535,读锁的线程数已经超过了65535
* 条件3：compareAndSetState(c, c + SHARED_UNIT) // 两个竞争读锁的线程都运行到这里，第一个竞争成功，那么第二个就会竞争失败，返回false
* 其实这个方法分别对这三种状态进行处理
*/
/**
* Full version of acquire for reads, that handles CAS misses
* and reentrant reads not dealt with in tryAcquireShared.
*/
final int fullTryAcquireShared(Thread current) {
/*
* This code is in part redundant with that in
* tryAcquireShared but is simpler overall by not
* complicating tryAcquireShared with interactions between
* retries and lazily reading hold counts.
*/
HoldCounter rh = null;
for (;;) {
int c = getState();
// 如果排他锁被别的线程拿了，直接返回-1
if (exclusiveCount(c) != 0) {
if (getExclusiveOwnerThread() != current)
return -1;
// else we hold the exclusive lock; blocking here
// would cause deadlock.
} else if (readerShouldBlock()) { // 这里是对条件1的处理
// 如果队列的头的下一个节点是请求的排他锁的线程在等待，那么就返回true
// Make sure we're not acquiring read lock reentrantly
if (firstReader == current) {
// assert firstReaderHoldCount > 0;
} else {
if (rh == null) {
rh = cachedHoldCounter;
if (rh == null || rh.tid != getThreadId(current)) {
rh = readHolds.get();
// 如果当前线程的count==0，也就是说当前线程才进来，没有获取到锁，那么直接把它从readHolds中移除
if (rh.count == 0)
// 移除当前线程的HoldCounter
readHolds.remove();
}
}
// 移除之后，返回-1
if (rh.count == 0)
return -1;
}
}
// 这里是对条件2的处理，直接抛出错误！
if (sharedCount(c) == MAX_COUNT)
throw new Error("Maximum lock count exceeded");
// 这里是对条件3的处理，竞争设置state，如果竞争还是失败，那么就要再循环一次，直到死循环能够跳出去
if (compareAndSetState(c, c + SHARED_UNIT)) {
// 如果共享锁的数量为0
if (sharedCount(c) == 0) {
// 设置第一个线程为当前的线程
firstReader = current;
// 设置HoldCount =1
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;
}
}
}