话说 ReadWriteLock 第二篇

 if (!readerShouldBlock() && 

// ReentrantReadWriteLock.FairSync#readerShouldBlock
final boolean readerShouldBlock() {  
    return hasQueuedPredecessors();
}
// 判断
// 如果有线程在当前线程获取锁之前排队 也就是队列已经有元素了 但不是自己 返回true (有人排队)
// 其他情况 返回false（没人排队）
public final boolean hasQueuedPredecessors() {
        Node t = tail; // 队列尾指针
        Node h = head;// 队列头指针
        Node s;// 临时变量  
        return h != t && // 比较head tail 如果队列为空 h != t 为 false  
            ((s = h.next) == null || // head的next为空 证明队列为空 
             s.thread != Thread.currentThread() // 如果head有next 也就是第一个等待线程 判断是不是自己 如果是自己 那嘿嘿
            );
    }

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)
        readHolds.set(rh);
    rh.count++;
}

private transient Thread firstReader = null;// 线程
private transient int firstReaderHoldCount;// 数量

static final class HoldCounter {
    int count = 0;
    // Use id, not reference, to avoid garbage retention
    final long tid = getThreadId(Thread.currentThread());
}

static final class ThreadLocalHoldCounte
    extends ThreadLocal<HoldCounter> {
    // 这里定义了initialValue 
    // ThreadLocal第一次初始化map会调用这个函数
    public HoldCounter initialValue() {
        return new HoldCounter();
    }
}

ReadWriteLock rw = new ReentrantReadWriteLock();
rw.readLock().unlock();

// AQS#releaseShared
public final boolean releaseShared(int arg) {
    if (tryReleaseShared(arg)) {
        // 如果返回true 也就是释放完锁后 当前线程的读锁已经没有了 
        // 没有的话 做一个doReleaseShared操作 可以简单理解为唤醒其他等待线程（队列里下一个等待的线程）
        doReleaseShared();
        return true;
    }
    return false;
}
protected final boolean tryReleaseShared(int unused) {
    // 获取当前线程 
    Thread current = Thread.currentThread();
    // 查看firstReader是不是当前线程  firstReader在这里用到了
    if (firstReader == current) {
        // assert firstReaderHoldCount > 0;
        // 判断firstReaderHoldCount如果等于1 把firstReader置空
        // 也就是获取过一次锁 
        if (firstReaderHoldCount == 1)
            firstReader = null;
        else 
            // 否则 就 减1
            firstReaderHoldCount--;
    } else {
        // 如果不是首个获取读锁的线程 
        HoldCounter rh = cachedHoldCounter;
        // 判断cachedHoldCounter是不是当前线程的持有器  如果不是那就从readHolds(ThreadLocal)中获取
        if (rh == null || rh.tid != getThreadId(current))
            rh = readHolds.get();
        // 判断持有锁次数
        int count = rh.count;
        // <=1 移除ThreadLocal变量  记着 ThreadLocal最后一定要remove否则就是内存泄漏
        if (count <= 1) {
            readHolds.remove();
            if (count <= 0)
                throw unmatchedUnlockException();
        }
        // 如果持有次数很多  那就减1
        --rh.count;
    }
    // 
    for (;;) {
        // state-SHARED_UNIT 
        // SHARED_UNIT = (1 << SHARED_SHIFT) = 65536
        int c = getState();
        int nextc = c - SHARED_UNIT;
        // cas设置新值 
        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;
    }
}

// 
private void doReleaseShared() {
    // 
    for (;;) {
        Node h = head;
        // h != null && h != tail 如果为true 表示队列中有等待线程
        if (h != null && h != tail) {
            // 获取waitStatus waitStatus状态在之前文章中有提到过 是他后继线程给他的状态 
            int ws = h.waitStatus;
            // 如果状态是SIGNAL 需要唤醒 
            if (ws == Node.SIGNAL) {
                if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
                    continue;            // loop to recheck cases
                // 唤醒 
                unparkSuccessor(h);
            }
            // 如果状态是0 就是不需要唤醒  设置为PROPAGATE状态 接着往后唤醒需要唤醒的人
            else if (ws == 0 &&
                     !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
                continue;                // 如果cas失败了 接着循环 loop on failed CAS
        }
        // 如果head变换了 需要接着循环 
        if (h == head)                   // loop if head changed
            break;
    }
}