// 這是一個關(guān)于緩存操作的故事
class CachedData {
    Object data;
    volatile boolean cacheValid;
    // 讀寫鎖實例
    final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();

    void processCachedData() {
        // 獲取讀鎖
        rwl.readLock().lock();
        if (!cacheValid) { // 如果緩存過期了，或者為 null
            // 釋放掉讀鎖，然后獲取寫鎖 (后面會看到，沒釋放掉讀鎖就獲取寫鎖，會發(fā)生死鎖情況)
            rwl.readLock().unlock();
            rwl.writeLock().lock();
            
            try {
                if (!cacheValid) { // 重新判斷，因為在等待寫鎖的過程中，可能前面有其他寫線程執(zhí)行過了
                    data = ...
                    cacheValid = true;
                }
                // 獲取讀鎖 (持有寫鎖的情況下，是允許獲取讀鎖的，稱為 “鎖降級”，反之不行。)
                rwl.readLock().lock();
            } finally {
                // 釋放寫鎖，此時還剩一個讀鎖
                rwl.writeLock().unlock(); // Unlock write, still hold read
            }
        }

        try {
            use(data);
        } finally {
            // 釋放讀鎖
            rwl.readLock().unlock();
        }
    }
}

abstract static class Sync extends AbstractQueuedSynchronizer {
    // 下面這塊說的就是將 state 一分為二，高 16 位用于共享模式，低16位用于獨(dú)占模式
    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;
    // 取 c 的高 16 位值，代表讀鎖的獲取次數(shù)(包括重入)
    static int sharedCount(int c)    { return c >>> SHARED_SHIFT; }
    // 取 c 的低 16 位值，代表寫鎖的重入次數(shù)，因為寫鎖是獨(dú)占模式
    static int exclusiveCount(int c) { return c & EXCLUSIVE_MASK; }

    // 這個嵌套類的實例用來記錄每個線程持有的讀鎖數(shù)量(讀鎖重入)
    static final class HoldCounter {
        // 持有的讀鎖數(shù)
        int count = 0;
        // 線程 id
        final long tid = getThreadId(Thread.currentThread());
    }

    // ThreadLocal 的子類
    static final class ThreadLocalHoldCounter
        extends ThreadLocal<HoldCounter> {
        public HoldCounter initialValue() {
            return new HoldCounter();
        }
    }
    /**
      * 組合使用上面兩個類，用一個 ThreadLocal 來記錄當(dāng)前線程持有的讀鎖數(shù)量
      */ 
    private transient ThreadLocalHoldCounter readHolds;

    // 用于緩存，記錄"最后一個獲取讀鎖的線程"的讀鎖重入次數(shù)，
    // 所以不管哪個線程獲取到讀鎖后，就把這個值占為已用，這樣就不用到 ThreadLocal 中查詢 map 了
    // 算不上理論的依據(jù)：通常讀鎖的獲取很快就會伴隨著釋放，
    //   顯然，在 獲取->釋放 讀鎖這段時間，如果沒有其他線程獲取讀鎖的話，此緩存就能幫助提高性能
    private transient HoldCounter cachedHoldCounter;
    
    // 第一個獲取讀鎖的線程(并且其未釋放讀鎖)，以及它持有的讀鎖數(shù)量
    private transient Thread firstReader = null;
    private transient int firstReaderHoldCount;

    Sync() {
        // 初始化 readHolds 這個 ThreadLocal 屬性
        readHolds = new ThreadLocalHoldCounter();
        // 為了保證 readHolds 的內(nèi)存可見性
        setState(getState()); // ensures visibility of readHolds
    }
    ...
}

// ReadLock
public void lock() {
    sync.acquireShared(1);
}
// AQS
public final void acquireShared(int arg) {
    if (tryAcquireShared(arg) < 0)
        doAcquireShared(arg);
}

protected final int tryAcquireShared(int unused) {

    Thread current = Thread.currentThread();
    int c = getState();
    
    // exclusiveCount(c) 不等于 0，說明有線程持有寫鎖，
    //    而且不是當(dāng)前線程持有寫鎖，那么當(dāng)前線程獲取讀鎖失敗
    // 		（另，如果持有寫鎖的是當(dāng)前線程，是可以繼續(xù)獲取讀鎖的）
    if (exclusiveCount(c) != 0 &&
        getExclusiveOwnerThread() != current)
        return -1;
    
    // 讀鎖的獲取次數(shù)
    int r = sharedCount(c);
    
    // 讀鎖獲取是否需要被阻塞，稍后細(xì)說。為了進(jìn)去下面的分支，假設(shè)這里不阻塞就好了
    if (!readerShouldBlock() &&
        // 判斷是否會溢出 (2^16-1，沒那么容易溢出的)
        r < MAX_COUNT &&
        // 下面這行 CAS 是將 state 屬性的高 16 位加 1，低 16 位不變，如果成功就代表獲取到了讀鎖
        compareAndSetState(c, c + SHARED_UNIT)) {
        
        // =======================
        //   進(jìn)到這里就是獲取到了讀鎖
        // =======================
       
        if (r == 0) {
            // r == 0 說明此線程是第一個獲取讀鎖的，或者說在它前面獲取讀鎖的都走光光了，它也算是第一個吧
            //  記錄 firstReader 為當(dāng)前線程，及其持有的讀鎖數(shù)量：1
            firstReader = current;
            firstReaderHoldCount = 1;
        } else if (firstReader == current) {
            // 進(jìn)來這里，說明是 firstReader 重入獲取讀鎖（這非常簡單，count 加 1 結(jié)束）
            firstReaderHoldCount++;
        } else {
            // 前面我們說了 cachedHoldCounter 用于緩存最后一個獲取讀鎖的線程
            // 如果 cachedHoldCounter 緩存的不是當(dāng)前線程，設(shè)置為緩存當(dāng)前線程的 HoldCounter
            HoldCounter rh = cachedHoldCounter;
            if (rh == null || rh.tid != getThreadId(current))
                cachedHoldCounter = rh = readHolds.get();
            else if (rh.count == 0) 
                // 到這里，那么就是 cachedHoldCounter 緩存的是當(dāng)前線程，但是 count 為 0，
                // 大家可以思考一下：這里為什么要 set ThreadLocal 呢？(當(dāng)然，答案肯定不在這塊代碼中)
                //   既然 cachedHoldCounter 緩存的是當(dāng)前線程，
                //   當(dāng)前線程肯定調(diào)用過 readHolds.get() 進(jìn)行初始化 ThreadLocal
                readHolds.set(rh);
            
            // count 加 1
            rh.count++;
        }
        // return 大于 0 的數(shù)，代表獲取到了共享鎖
        return 1;
    }
    // 往下看
    return fullTryAcquireShared(current);
}

/**
 * 1. 剛剛我們說了可能是因為 CAS 失敗，如果就此返回，那么就要進(jìn)入到阻塞隊列了，
 *    想想有點不甘心，因為都已經(jīng)滿足了 !readerShouldBlock()，也就是說本來可以不用到阻塞隊列的，
 *    所以進(jìn)到這個方法其實是增加 CAS 成功的機(jī)會
 * 2. 在 NonFairSync 情況下，雖然 head.next 是獲取寫鎖的，我知道它等待很久了，我沒想和它搶，
 *    可是如果我是來重入讀鎖的，那么只能表示對不起了
 */
final int fullTryAcquireShared(Thread current) {
    HoldCounter rh = null;
    // 別忘了這外層有個 for 循環(huán)
    for (;;) {
        int c = getState();
        // 如果其他線程持有了寫鎖，自然這次是獲取不到讀鎖了，乖乖到阻塞隊列排隊吧
        if (exclusiveCount(c) != 0) {
            if (getExclusiveOwnerThread() != current)
                return -1;
            // else we hold the exclusive lock; blocking here
            // would cause deadlock.
        } else if (readerShouldBlock()) {
            /**
              * 進(jìn)來這里，說明：
              *  1. exclusiveCount(c) == 0：寫鎖沒有被占用
              *  2. readerShouldBlock() 為 true，說明阻塞隊列中有其他線程在等待
              *
              * 既然 should block，那進(jìn)來這里是干什么的呢？
              * 答案：是進(jìn)來處理讀鎖重入的！
              * 
              */
            
            // firstReader 線程重入讀鎖，直接到下面的 CAS
            if (firstReader == current) {
                // assert firstReaderHoldCount > 0;
            } else {
                if (rh == null) {
                    rh = cachedHoldCounter;
                    if (rh == null || rh.tid != getThreadId(current)) {
                        // cachedHoldCounter 緩存的不是當(dāng)前線程
                        // 那么到 ThreadLocal 中獲取當(dāng)前線程的 HoldCounter
                        // 如果當(dāng)前線程從來沒有初始化過 ThreadLocal 中的值，get() 會執(zhí)行初始化
                        rh = readHolds.get();
                        // 如果發(fā)現(xiàn) count == 0，也就是說，純屬上一行代碼初始化的，那么執(zhí)行 remove
                        // 然后往下兩三行，乖乖排隊去
                        if (rh.count == 0)
                            readHolds.remove();
                    }
                }
                if (rh.count == 0)
                    // 排隊去。
                    return -1;
            }
            /**
              * 這塊代碼我看了蠻久才把握好它是干嘛的，原來只需要知道，它是處理重入的就可以了。
              * 就是為了確保讀鎖重入操作能成功，而不是被塞到阻塞隊列中等待
              *
              * 另一個信息就是，這里對于 ThreadLocal 變量 readHolds 的處理：
              *    如果 get() 后發(fā)現(xiàn) count == 0，居然會做 remove() 操作，
              *    這行代碼對于理解其他代碼是有幫助的
              */
        }
        
        if (sharedCount(c) == MAX_COUNT)
            throw new Error("Maximum lock count exceeded");
        
        if (compareAndSetState(c, c + SHARED_UNIT)) {
            // 這里 CAS 成功，那么就意味著成功獲取讀鎖了
            // 下面需要做的是設(shè)置 firstReader 或 cachedHoldCounter
            
            if (sharedCount(c) == 0) {
                // 如果發(fā)現(xiàn) sharedCount(c) 等于 0，就將當(dāng)前線程設(shè)置為 firstReader
                firstReader = current;
                firstReaderHoldCount = 1;
            } else if (firstReader == current) {
                firstReaderHoldCount++;
            } else {
                // 下面這幾行，就是將 cachedHoldCounter 設(shè)置為當(dāng)前線程
                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;
            }
            // 返回大于 0 的數(shù)，代表獲取到了讀鎖
            return 1;
        }
    }
}

// ReadLock
public void unlock() {
    sync.releaseShared(1);
}

// Sync
public final boolean releaseShared(int arg) {
    if (tryReleaseShared(arg)) {
        doReleaseShared(); // 這句代碼其實喚醒 獲取寫鎖的線程，往下看就知道了
        return true;
    }
    return false;
}

// Sync
protected final boolean tryReleaseShared(int unused) {
    Thread current = Thread.currentThread();
    if (firstReader == current) {
        if (firstReaderHoldCount == 1)
            // 如果等于 1，那么這次解鎖后就不再持有鎖了，把 firstReader 置為 null，給后來的線程用
            // 為什么不順便設(shè)置 firstReaderHoldCount = 0？因為沒必要，其他線程使用的時候自己會設(shè)值
            firstReader = null;
        else
            firstReaderHoldCount--;
    } else {
        // 判斷 cachedHoldCounter 是否緩存的是當(dāng)前線程，不是的話要到 ThreadLocal 中取
        HoldCounter rh = cachedHoldCounter;
        if (rh == null || rh.tid != getThreadId(current))
            rh = readHolds.get();
        
        int count = rh.count;
        if (count <= 1) {
            
            // 這一步將 ThreadLocal remove 掉，防止內(nèi)存泄漏。因為已經(jīng)不再持有讀鎖了
            readHolds.remove();
            
            if (count <= 0)
                // 就是那種，lock() 一次，unlock() 好幾次的逗比
                throw unmatchedUnlockException();
        }
        // count 減 1
        --rh.count;
    }
    
    for (;;) {
        int c = getState();
        // nextc 是 state 高 16 位減 1 后的值
        int nextc = c - SHARED_UNIT;
        if (compareAndSetState(c, nextc))
            // 如果 nextc == 0，那就是 state 全部 32 位都為 0，也就是讀鎖和寫鎖都空了
            // 此時這里返回 true 的話，其實是幫助喚醒后繼節(jié)點中的獲取寫鎖的線程
            return nextc == 0;
    }
}

// WriteLock
public void lock() {
    sync.acquire(1);
}
// AQS
public final void acquire(int arg) {
    if (!tryAcquire(arg) &&
        // 如果 tryAcquire 失敗，那么進(jìn)入到阻塞隊列等待
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
}

// Sync
protected final boolean tryAcquire(int acquires) {

    Thread current = Thread.currentThread();
    int c = getState();
    int w = exclusiveCount(c);
    if (c != 0) {
        
        // 看下這里返回 false 的情況：
        //   c != 0 && w == 0: 寫鎖可用，但是有線程持有讀鎖(也可能是自己持有)
        //   c != 0 && w !=0 && current != getExclusiveOwnerThread(): 其他線程持有寫鎖
        //   也就是說，只要有讀鎖或?qū)戞i被占用，這次就不能獲取到寫鎖
        if (w == 0 || current != getExclusiveOwnerThread())
            return false;
        
        if (w + exclusiveCount(acquires) > MAX_COUNT)
            throw new Error("Maximum lock count exceeded");
        
        // 這里不需要 CAS，仔細(xì)看就知道了，能到這里的，只可能是寫鎖重入，不然在上面的 if 就攔截了
        setState(c + acquires);
        return true;
    }
    
    // 如果寫鎖獲取不需要 block，那么進(jìn)行 CAS，成功就代表獲取到了寫鎖
    if (writerShouldBlock() ||
        !compareAndSetState(c, c + acquires))
        return false;
    setExclusiveOwnerThread(current);
    return true;
}

static final class NonfairSync extends Sync {    // 如果是非公平模式，那么 lock 的時候就可以直接用 CAS 去搶鎖，搶不到再排隊    final boolean writerShouldBlock() {        return false; // writers can always barge    }    ...}static final class FairSync extends Sync {    final boolean writerShouldBlock() {        // 如果是公平模式，那么如果阻塞隊列有線程等待的話，就乖乖去排隊        return hasQueuedPredecessors();    }    ...}

WriteLockpublic void unlock() {    
sync.release(1);
}
AQSpublic final boolean release(int arg) {
    // 1. 釋放鎖    
    if (tryRelease(arg)) {        
        // 2. 如果獨(dú)占鎖釋放"完全"，喚醒后繼節(jié)點        
        Node h = head;        
        if (h != null && h.waitStatus != 0)            
        unparkSuccessor(h);        
        return true;    
        
    }    
    return false;
    
}
// Sync 
// 釋放鎖，是線程安全的，因為寫鎖是獨(dú)占鎖，具有排他性
// 實現(xiàn)很簡單，state 減 1 就是了
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);   
    // 如果 exclusiveCount(nextc) == 0，也就是說包括重入的，所有的寫鎖都釋放了，    
    // 那么返回 true，這樣會進(jìn)行喚醒后繼節(jié)點的操作。    
    return free;
    
}

protected final boolean tryAcquire(int acquires) {    
    Thread current = Thread.currentThread();   
    int c = getState();  
    int w = exclusiveCount(c);  
    if (c != 0) {      
        // 看下這里返回 false 的情況：    
        //   c != 0 && w == 0: 寫鎖可用，但是有線程持有讀鎖(也可能是自己持有) 
        //   c != 0 && w !=0 && current != getExclusiveOwnerThread(): 其他線程持有寫鎖       
        //   也就是說，只要有讀鎖或?qū)戞i被占用，這次就不能獲取到寫鎖      
        if (w == 0 || current != getExclusiveOwnerThread())          
        return false;       
        ...    
    }  
        ...
}