读锁的调用，最终委派给其内部类 Sync extends AbstractQueuedSynchronizer
/**
* 获取读锁，如果写锁不是由其他线程持有，则获取并立即返回；
* 如果写锁被其他线程持有，阻塞，直到读锁被获得。
*/
public void lock() {
sync.acquireShared(1);
}
/**
* 以共享模式获取对象，忽略中断。通过至少先调用一次 tryAcquireShared(int) 来实现此方法，并在成功时返回。
* 否则将线程加入队列,在阻塞和运行之间切换，重复调用tryAcquireShared直到成功
*（ possibly repeatedly blocking and unblocking, invoking tryAcquireShared until success）
*/
public final void acquireShared(int arg) {
if (tryAcquireShared(arg) < 0)
doAcquireShared(arg);
tryAcquireShared方法的逻辑：
整体思路如下，具体实现细节，请参考下面的源码分析
一 写锁被占用的情况
1 写锁被其他线程占用，获取失败
2 写锁被自己占用，表示“锁降级”，进入【循环cas取读锁】流程
二 写锁没有被占用的情况
1 根据读锁获取策略判断是否阻塞（readerShouldBlock方法）
（1） 公平锁策略：如果当前线程不是同步队列中的第一个节点，则阻塞
（2） 非公平锁策略：为了防止写线程饥饿，如果同步队列中的第一个节点是写线程，则阻塞当前线程。
2 如果需要阻塞，分以下2种情况：
（1）当前线程是读锁重入，则不需要阻塞，进入【循环cas取读锁】流程
（2）当前线程不是读锁重入，则获取失败
3 如果不需要阻塞，进入【循环cas取读锁】流程
三 【循环cas取读锁】
1 tryAcquireShared方法先进行了一次cas取锁操作，如果获取失败，则调用fullTryAcquireShared方法，循环获取。
2 什么是cas？请参考CAS
protected final int tryAcquireShared(int unused) {
Thread current = Thread.currentThread();
//c是锁状态为：高位16位表示共享锁的数量，低位16位表示独占锁的数量
int c = getState();
//exclusiveCount(c) 取低16位的值，也就是写锁状态位：不等于0表示写锁被占用
if (exclusiveCount(c) != 0 &&
getExclusiveOwnerThread() != current)
//写锁被其他线程占用，获取读锁失败
return -1;
//取高16位的值，读锁状态位
int r = sharedCount(c);
//readerShouldBlock()根据读锁获取策略，返回是否阻塞当前读锁获取操作。后面会详细说明此方法
if (!readerShouldBlock() &&
r < MAX_COUNT &&
//cas修改高16位的读锁状态，即获取读锁
compareAndSetState(c, c + SHARED_UNIT)) {
//首次获取读锁
if (r == 0) {
//缓存首次获取读锁的线程，及其读锁重入次数
firstReader = current;
firstReaderHoldCount = 1;
} else if (firstReader == current) {
firstReaderHoldCount++;
} else {
//cachedHoldCounter是最后获取锁的线程的读锁重入次数
HoldCounter rh = cachedHoldCounter;
if (rh == null || rh.tid != getThreadId(current))
//readHolds是缓存了当前线程的读锁重入次数的ThreadLocal
//当前线程自然是最后获取锁的线程，故将当前线程的holdCounter赋给cachedHoldCounter
cachedHoldCounter = rh = readHolds.get();
else if (rh.count == 0)
//缓存当前线程的holdCounter
//fullTryAcquireShared()方法中，
//获取读锁失败的线程会执行：readHolds.remove()，故此时需要重新设置
readHolds.set(rh);
rh.count++;
}
return 1;
}
//首次获取读锁失败后，重试获取
return fullTryAcquireShared(current);
}
/**
* Full version of acquire for reads, that handles CAS misses
* and reentrant reads not dealt with in tryAcquireShared.
*/
final int fullTryAcquireShared(Thread current) {
//rh表示当前线程的锁计数器
HoldCounter rh = null;
for (;;) {
int c = getState();
//写锁被占用
if (exclusiveCount(c) != 0) {
//如果其他线程占用，读锁获取失败。如果当前线程占用，表示“锁降级”。
if (getExclusiveOwnerThread() != current)
return -1;
} else if (readerShouldBlock()) {
//重入锁不需要阻塞。
// 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 != current.getId()) {
rh = readHolds.get();
if (rh.count == 0)
//线程阻塞之前，清空readHolds
readHolds.remove();
}
}
if (rh.count == 0)
//当前线程的锁计数器为0，非重入锁，需要阻塞。
return -1;
}
}
if (sharedCount(c) == MAX_COUNT)
throw new Error("Maximum lock count exceeded");
//cas设置读锁状态位
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 != current.getId())
rh = readHolds.get();
else if (rh.count == 0)
//锁计数器放入ThreadLocal
readHolds.set(rh);
rh.count++;
//此时rh就是最后获取读锁的线程的锁计数器
cachedHoldCounter = rh; // cache for release
}
return 1;
}
}
}
/**
* 非公平锁的读锁获取策略
*/
final boolean readerShouldBlock() {
//为了防止写线程饥饿
//如果同步队列中的第一个线程是以独占模式获取锁（写锁），
//那么当前获取读锁的线程需要阻塞，让队列中的第一个线程先执行
return apparentlyFirstQueuedIsExclusive();
}
/**
* 公平锁的读锁获取策略
*/
final boolean readerShouldBlock() {
//如果当前线程不是同步队列头结点的next节点（head.next)
//则阻塞当前线程
return hasQueuedPredecessors();
}
