public interface ReadWriteLock {
    /**
     * Returns the lock used for reading.
     */
    Lock readLock();
    /**
     * Returns the lock used for writing.
     */
    Lock writeLock();
}

public class ReentrantReadWriteLock implements ReadWriteLock, java.io.Serializable {
    abstract static class Sync extends AbstractQueuedSynchronizer {
      	static final class HoldCounter
        static final class ThreadLocalHoldCounter extends ThreadLocal<HoldCounter> 
    }
    static final class NonfairSync extends Sync
    static final class FairSync extends Sync
    public static class ReadLock implements Lock, java.io.Serializable
    public static class WriteLock implements Lock, java.io.Serializable
}

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

static final class ThreadLocalHoldCounter extends ThreadLocal<HoldCounter> {
    public HoldCounter initialValue() {
        return new HoldCounter();
    }
}

abstract static class Sync extends AbstractQueuedSynchronizer {
		// 高16位為讀鎖，低16位為寫鎖
    static final int SHARED_SHIFT   = 16;
    // 讀鎖單位
    static final int SHARED_UNIT    = (1 << SHARED_SHIFT);  // 1 * 2^16 = 65536
    // 讀鎖最大數(shù)量
    static final int MAX_COUNT      = (1 << SHARED_SHIFT) - 1;  // 2^16 - 1
    // 寫鎖最大數(shù)量
    static final int EXCLUSIVE_MASK = (1 << SHARED_SHIFT) - 1;   // 2^16 - 1 獨(dú)占標(biāo)記
    // 當(dāng)前線程讀鎖重入次數(shù)。當(dāng)持有讀鎖的線程數(shù)量下降到0時刪除。
    private transient ThreadLocalHoldCounter readHolds;
    // 緩存對象，避免每次都去從 ThreadLocal 查找。
    private transient HoldCounter cachedHoldCounter;
		// 第一個獲取讀鎖線程
    private transient Thread firstReader;
    // 第一個讀鎖線程重入讀鎖的計(jì)數(shù)
    private transient int firstReaderHoldCount;
    // ...
}

Sync() {
		readHolds = new ThreadLocalHoldCounter(); 
    setState(getState()); // ensures visibility of readHolds
}

abstract static class Sync extends AbstractQueuedSynchronizer {
  	// 并發(fā)計(jì)數(shù)
    static int sharedCount(int c)
    static int exclusiveCount(int c)
		// 阻塞檢查
    abstract boolean readerShouldBlock();
    abstract boolean writerShouldBlock();
		// 獲取和釋放寫鎖
    @ReservedStackAccess
    protected final boolean tryRelease(int releases)
    @ReservedStackAccess
    protected final boolean tryAcquire(int acquires)
		// 獲取和釋放讀鎖
    @ReservedStackAccess
    protected final boolean tryReleaseShared(int unused)
    @ReservedStackAccess
    protected final int tryAcquireShared(int unused)
    final int fullTryAcquireShared(Thread current)
		// 嘗試加讀寫鎖
    @ReservedStackAccess
    final boolean tryWriteLock()
    @ReservedStackAccess
    final boolean tryReadLock()

    // ... 
}

/** 表示共享持有的數(shù)量。 */
static int sharedCount(int c)    { return c >>> SHARED_SHIFT; } // 無符號右移，高位補(bǔ) 0 
/** 表示獨(dú)占持有的數(shù)量。 */
static int exclusiveCount(int c) { return c & EXCLUSIVE_MASK; }

// 獲取和釋放對公平鎖和非公平鎖使用相同的代碼，不同點(diǎn)在于但在隊(duì)列非空時是否/如何允許碰撞。

// 如果當(dāng)前線程在嘗試獲取讀鎖時，并且在其他符合條件的線程也在嘗試獲取讀鎖，由于策略其他等待線程占用了讀鎖，當(dāng)前線程應(yīng)該阻塞，則返回true。
abstract boolean readerShouldBlock();

// 如果當(dāng)前線程在嘗試獲取寫鎖時，并且在其他符合條件的線程也在嘗試獲取寫鎖，由于策略其他等待線程占用了寫鎖，當(dāng)前線程應(yīng)該阻塞，則返回true。
abstract boolean writerShouldBlock();

    // 非公平策略
		static final class NonfairSync extends Sync {
        private static final long serialVersionUID = -8159625535654395037L;
        final boolean writerShouldBlock() {
            return false; // 正在持有寫鎖的線程永不阻塞
        }
        final boolean readerShouldBlock() {
            return apparentlyFirstQueuedIsExclusive(); 
        }
    }
		// 公平策略
    static final class FairSync extends Sync {
        private static final long serialVersionUID = -2274990926593161451L;
      
        final boolean writerShouldBlock() {
            return hasQueuedPredecessors();
        }
        final boolean readerShouldBlock() {
            return hasQueuedPredecessors();
        }
    }

    final boolean apparentlyFirstQueuedIsExclusive() {
        Node h = head, s = head.next;
        return h != null && s != null && !(s instanceof SharedNode) && s.waiter != null;
    }

    public final boolean hasQueuedPredecessors() {
        Thread first = null; Node h = head, s = h.next;
        if (h != null && (s == null || (first = s.waiter) == null || s.prev == null))
            first = getFirstQueuedThread(); // retry via getFirstQueuedThread
        return first != null && first != Thread.currentThread();
    }

    public final Thread getFirstQueuedThread() {
        Thread first = null, w; Node h, s;
        if ((h = head) != null && ((s = h.next) == null || (first = s.waiter) == null || s.prev == null)) {
            // traverse from tail on stale reads
            for (Node p = tail, q; p != null && (q = p.prev) != null; p = q)
                if ((w = p.waiter) != null)
                    first = w;
        }
        return first;
    }

@ReservedStackAccess
protected final boolean tryRelease(int releases) {
		if (!isHeldExclusively()) // 不是獨(dú)占持有鎖的情況，直接拋出異常。
				throw new IllegalMonitorStateException();
		int nextc = getState() - releases; // AQS 當(dāng)前鎖狀態(tài) - releases = 新的鎖狀態(tài)
		boolean free = exclusiveCount(nextc) == 0; // 根據(jù)新的鎖狀態(tài)獲取到獨(dú)占寫鎖的數(shù)量 == 0
		if (free) 
				setExclusiveOwnerThread(null); // 持有寫鎖的線程數(shù)為0，更新當(dāng)前獨(dú)占線程引用
		setState(nextc); 	// 無論是不是解鎖了，都要更新鎖狀態(tài)
		return free;			// 最后返回鎖是否已經(jīng)可用了
}

@ReservedStackAccess
protected final boolean tryAcquire(int acquires) {
            /*
             * 工作流程:
             * 1. 如果寫鎖計(jì)數(shù)非零或所有者是不同的線程，則失敗。
             * 2. 如果寫鎖計(jì)數(shù)超過最大數(shù)量，失敗（這只發(fā)生在計(jì)數(shù)非 0 的情況）。
             * 3. 否則，如果這個線程是可重入的獲取方式或者隊(duì)列策略允許的話，它就有資格獲得鎖。
             *    如果是，更新狀態(tài)并設(shè)置 owner。
             */
		Thread current = Thread.currentThread(); // 當(dāng)前線程
		int c = getState();											 // 當(dāng)前鎖狀態(tài)
		int w = exclusiveCount(c);							 // 計(jì)算擁有寫鎖的線程數(shù)量
		if (c != 0) { // 0 是鎖可用狀態(tài)，當(dāng)前狀態(tài)表面鎖狀態(tài)為被持有。
				if (w == 0 || current != getExclusiveOwnerThread()) // 對應(yīng) 【1】 的情況，寫線程數(shù)量為0或者當(dāng)前線程沒有占有獨(dú)占資源
						return false;
        if (w + exclusiveCount(acquires) > MAX_COUNT) // 對應(yīng)【2】的情況， 判斷是否超過最高寫線程數(shù)量
            throw new Error("Maximum lock count exceeded");
        // 重入獲取寫鎖
        setState(c + acquires);
        return true; 
		}
		if (writerShouldBlock() || !compareAndSetState(c, c + acquires)) // 是否應(yīng)該阻塞或更新狀態(tài)是否成功，失敗直接 return false;
				return false;
		setExclusiveOwnerThread(current); // 設(shè)置當(dāng)前為持有鎖的線程。
		return true;
}

        @ReservedStackAccess
        protected final boolean tryReleaseShared(int unused) {
            Thread current = Thread.currentThread(); // 當(dāng)前線程
            if (firstReader == current) { // 當(dāng)前線程是否是第一個讀線程
                // assert firstReaderHoldCount > 0;
                if (firstReaderHoldCount == 1) 
                    firstReader = null;  // 釋放線程引用
                else
                    firstReaderHoldCount--;  // 當(dāng)前線程重入次數(shù)自減
            } else {
                HoldCounter rh = cachedHoldCounter; // 獲取當(dāng)前線程的重入讀鎖的次數(shù)
                if (rh == null || rh.tid != LockSupport.getThreadId(current))
                    rh = readHolds.get();
                int count = rh.count;
                if (count <= 1) {
                    readHolds.remove();
                    if (count <= 0)
                        throw unmatchedUnlockException();
                }
                --rh.count;
            }
          	// 死循環(huán)直到更新狀態(tài)成功
            for (;;) {
                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;
            }
        }

        @ReservedStackAccess
        protected final int tryAcquireShared(int unused) {
            /*
             * Walkthrough:
             * 1. If write lock held by another thread, fail.
             * 2. Otherwise, this thread is eligible for
             *    lock wrt state, so ask if it should block
             *    because of queue policy. If not, try
             *    to grant by CASing state and updating count.
             *    Note that step does not check for reentrant
             *    acquires, which is postponed to full version
             *    to avoid having to check hold count in
             *    the more typical non-reentrant case.
             * 3. If step 2 fails either because thread
             *    apparently not eligible or CAS fails or count
             *    saturated, chain to version with full retry loop.
             */
            Thread current = Thread.currentThread();
            int c = getState();
            if (exclusiveCount(c) != 0 && getExclusiveOwnerThread() != current) // 當(dāng)獨(dú)占線程不是當(dāng)前線程
                return -1;
            int r = sharedCount(c); // 共享讀鎖的線程數(shù)量
          	// 檢查讀線程不應(yīng)該阻塞 and 持有讀鎖的線程數(shù)量小于 MAX_COUNT and 更新鎖狀態(tài)成功
            if (!readerShouldBlock() && r < MAX_COUNT && compareAndSetState(c, c + SHARED_UNIT)) {
                if (r == 0) {  // 第一個嘗試獲取讀鎖的線程
                    firstReader = current;
                    firstReaderHoldCount = 1;
                } else if (firstReader == current) {  // 第一個線程重入
                    firstReaderHoldCount++;
                } else {	
                    HoldCounter rh = cachedHoldCounter;
                  	// 無緩存 or 當(dāng)前線程不是計(jì)數(shù)器所在線程
                    if (rh == null || rh.tid != LockSupport.getThreadId(current)) 
                        cachedHoldCounter = rh = readHolds.get(); // 從 ThreadLocal 中讀取
                    else if (rh.count == 0) 
                        readHolds.set(rh);
                    rh.count++; // 當(dāng)前線程獲取讀鎖次數(shù) + 1
                }
                return 1;
            }
            return fullTryAcquireShared(current);
        }

        final int fullTryAcquireShared(Thread current) {
            /*
             * 這段代碼與 tryAcquireShared 中的部分代碼是冗余的，但總體上更簡單，因?yàn)樗粫?
             * tryAcquireShared 在重試和懶加載讀鎖計(jì)數(shù)之間的交互復(fù)雜化。
             */
            HoldCounter rh = null;
            for (;;) { // 死循環(huán)，不斷嘗試
                int c = getState();
                if (exclusiveCount(c) != 0) { // 獨(dú)占檢查是否是當(dāng)前線程
                    if (getExclusiveOwnerThread() != current)
                        return -1;
                // 否則我們持有獨(dú)占鎖;這里的阻塞將導(dǎo)致死鎖。
                } else if (readerShouldBlock()) {
                    // 確保我們不是重入式地獲取讀鎖
                    if (firstReader == current) {
                        // assert firstReaderHoldCount > 0;
                    } else {
                      	// 不是重入的情況下，更新 HoldCounter
                        if (rh == null) { 
                            rh = cachedHoldCounter;
                            if (rh == null || rh.tid != LockSupport.getThreadId(current)) {
                                rh = readHolds.get();
                                if (rh.count == 0)
                                    readHolds.remove();
                            }
                        }
                        if (rh.count == 0)
                            return -1;
                    }
                }
              	// 共享讀鎖 == 最大數(shù)量，拋出異常
                if (sharedCount(c) == MAX_COUNT) throw new Error("Maximum lock count exceeded");
              	// 是否能夠設(shè)置成功
                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 != LockSupport.getThreadId(current))
                            rh = readHolds.get();
                        else if (rh.count == 0)
                            readHolds.set(rh);
                        rh.count++;
                        cachedHoldCounter = rh; // cache for release
                    }
                    return 1;
                }
            }
        }

public static class ReadLock implements Lock, java.io.Serializable {
    private static final long serialVersionUID = -5992448646407690164L;
    private final Sync sync;
    protected ReadLock(ReentrantReadWriteLock lock) {
        sync = lock.sync;
    }
    public void lock() {
        sync.acquireShared(1);
    }
    public void lockInterruptibly() throws InterruptedException {
        sync.acquireSharedInterruptibly(1);
    }
    public boolean tryLock() {
        return sync.tryReadLock();
    }
    public boolean tryLock(long timeout, TimeUnit unit)
        throws InterruptedException {
        return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));
    }
    public void unlock() {
        sync.releaseShared(1);
    }
    public Condition newCondition() {
        throw new UnsupportedOperationException();
    }
    // ... 
}

public static class WriteLock implements Lock, java.io.Serializable {
    private static final long serialVersionUID = -4992448646407690164L;
    private final Sync sync;
    protected WriteLock(ReentrantReadWriteLock lock) {
        sync = lock.sync;
    }
    public void lock() {
        sync.acquire(1);
    }
    public void lockInterruptibly() throws InterruptedException {
        sync.acquireInterruptibly(1);
    }
    public boolean tryLock() {
        return sync.tryWriteLock();
    }
    public boolean tryLock(long timeout, TimeUnit unit)
            throws InterruptedException {
        return sync.tryAcquireNanos(1, unit.toNanos(timeout));
    }
    public void unlock() {
        sync.release(1);
    }
    public Condition newCondition() {
        return sync.newCondition();
    }
    public String toString() {
        Thread o = sync.getOwner();
        return super.toString() + ((o == null) ? "[Unlocked]" : "[Locked by thread " + o.getName() + "]");
    }
   public boolean isHeldByCurrentThread() {
        return sync.isHeldExclusively();
    }
    public int getHoldCount() {
        return sync.getWriteHoldCount();
    }
}

public void processData() {
    readLock.lock();
    if (!update) {
        // 必須先釋放讀鎖
        readLock.unlock();
        // 鎖降級從寫鎖獲取到開始
        writeLock.lock();
        try {
            if (!update) {
                // 準(zhǔn)備數(shù)據(jù)的流程(略)
                update = true;
            }
            readLock.lock();
        } finally {
            writeLock.unlock();
        }
        // 鎖降級完成，寫鎖降級為讀鎖
    }
    try {
        // 使用數(shù)據(jù)的流程(略)
    } finally {
        readLock.unlock();
    }
}