class CachedData {
   //被緩存的具體對象
   Object data;
   //當前對象是否可用，使用volatile來保證可見性
   volatile boolean cacheValid;
   //ReentrantReadWriteLock 
   final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
   //業(yè)務處理邏輯
   void processCachedData() {
     //要讀取數(shù)據(jù)時，先加讀鎖，如果加成功，說明此時沒有人在并發(fā)寫
     rwl.readLock().lock();
     //拿到讀鎖后，判斷當前對象是否有效
     if (!cacheValid) {
       // Must release read lock before acquiring write lock
       //這里的處理非常經(jīng)典，當你持有讀鎖之后，不能直接獲取寫鎖，
       //因為寫鎖是獨占鎖，如果直接獲取寫鎖，那代碼就在這里死鎖了
       //所以必須要先釋放讀鎖，然后手動獲取寫鎖
       rwl.readLock().unlock();
       rwl.writeLock().lock();
       try {
         // Recheck state because another thread might have
         // acquired write lock and changed state before we did.
         //經(jīng)典處理之二，在獨占鎖內(nèi)部要處理數(shù)據(jù)時，一定要做二次校驗
         //因為可能同時有多個線程全都在獲取寫鎖，
         //當時線程1釋放寫鎖之后，線程2馬上獲取到寫鎖，此時如果不做二次校驗那可能就導致某些操作做了多次
         if (!cacheValid) {
           data = ...
           //當緩存對象更新成功后，重置標記為true
           cacheValid = true;
         }
         // Downgrade by acquiring read lock before releasing write lock
         //這里有一個非常神奇的鎖降級操作，所謂降級是說當你持有寫鎖后，可以再次獲取讀鎖
         //這里之所以要獲取一次寫鎖是為了防止當前線程釋放寫鎖之后，其他線程馬上獲取到寫鎖，改變緩存對象
         //因為讀寫互斥，所以有了這個讀鎖之后，在讀鎖釋放之前，別的線程是無法修改緩存對象的
         rwl.readLock().lock();
       } finally {
         rwl.writeLock().unlock(); // Unlock write, still hold read
       }
     }
     try {
       use(data);
     } finally {
       rwl.readLock().unlock();
     }
   }
 }

class RWDictionary {
   //原來非并發(fā)安全的容器
   private final Map<String, Data> m = new TreeMap<String, Data>();
   private final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
   private final Lock r = rwl.readLock();
   private final Lock w = rwl.writeLock();
   public Data get(String key) {
     //讀數(shù)據(jù)，上讀鎖
     r.lock();
     try { return m.get(key); }
     finally { r.unlock(); }
   }
   public String[] allKeys() {
     //讀數(shù)據(jù)，上讀鎖
     r.lock();
     try { return m.keySet().toArray(); }
     finally { r.unlock(); }
   }
   public Data put(String key, Data value) {
     //寫數(shù)據(jù)，上寫鎖
     w.lock();
     try { return m.put(key, value); }
     finally { w.unlock(); }
   }
   public void clear() {
     //寫數(shù)據(jù)，上寫鎖
     w.lock();
     try { m.clear(); }
     finally { w.unlock(); }
   }
 }

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

public class ReentrantReadWriteLock implements ReadWriteLock, java.io.Serializable {}

abstract static class Sync extends AbstractQueuedSynchronizer {}

// 計數(shù)器
static final class HoldCounter {
    // 計數(shù)
    int count = 0;
    // Use id, not reference, to avoid garbage retention
    // 獲取當前線程的TID屬性的值
    final long tid = getThreadId(Thread.currentThread());
}

// 本地線程計數(shù)器
static final class ThreadLocalHoldCounter
    extends ThreadLocal<HoldCounter> {
    // 重寫初始化方法，在沒有進行set的情況下，獲取的都是該HoldCounter值
    public HoldCounter initialValue() {
        return new HoldCounter();
    }
}

abstract static class Sync extends AbstractQueuedSynchronizer {
    // 版本序列號
    private static final long serialVersionUID = 6317671515068378041L;        
    // 高16位為讀鎖，低16位為寫鎖
    static final int SHARED_SHIFT   = 16;
    // 讀鎖單位
    static final int SHARED_UNIT    = (1 << SHARED_SHIFT);
    // 讀鎖最大數(shù)量
    static final int MAX_COUNT      = (1 << SHARED_SHIFT) - 1;
    // 寫鎖最大數(shù)量
    static final int EXCLUSIVE_MASK = (1 << SHARED_SHIFT) - 1;
    // 本地線程計數(shù)器
    private transient ThreadLocalHoldCounter readHolds;
    // 緩存的計數(shù)器
    private transient HoldCounter cachedHoldCounter;
    // 第一個讀線程
    private transient Thread firstReader = null;
    // 第一個讀線程的計數(shù)
    private transient int firstReaderHoldCount;
}

// 構造函數(shù)
Sync() {
    // 本地線程計數(shù)器
    readHolds = new ThreadLocalHoldCounter();
    // 設置AQS的狀態(tài)
    setState(getState()); // ensures visibility of readHolds
}

public class ReentrantReadWriteLock
        implements ReadWriteLock, java.io.Serializable {
    // 版本序列號    
    private static final long serialVersionUID = -6992448646407690164L;    
    // 讀鎖
    private final ReentrantReadWriteLock.ReadLock readerLock;
    // 寫鎖
    private final ReentrantReadWriteLock.WriteLock writerLock;
    // 同步隊列
    final Sync sync;
    private static final sun.misc.Unsafe UNSAFE;
    // 線程ID的偏移地址
    private static final long TID_OFFSET;
    static {
        try {
            UNSAFE = sun.misc.Unsafe.getUnsafe();
            Class<?> tk = Thread.class;
            // 獲取線程的tid字段的內(nèi)存地址
            TID_OFFSET = UNSAFE.objectFieldOffset
                (tk.getDeclaredField("tid"));
        } catch (Exception e) {
            throw new Error(e);
        }
    }
}

public ReentrantReadWriteLock() {
    this(false);
}

public ReentrantReadWriteLock(boolean fair) {
    // 公平策略或者是非公平策略
    sync = fair ? new FairSync() : new NonfairSync();
    // 讀鎖
    readerLock = new ReadLock(this);
    // 寫鎖
    writerLock = new WriteLock(this);
}

static int sharedCount(int c)    { return c >>> SHARED_SHIFT; }

static int exclusiveCount(int c) { return c & EXCLUSIVE_MASK; }

static final int EXCLUSIVE_MASK = (1 << SHARED_SHIFT) - 1;

protected final boolean tryAcquire(int acquires) {
    /*
        * Walkthrough:
        * 1. If read count nonzero or write count nonzero
        *    and owner is a different thread, fail.
        * 2. If count would saturate, fail. (This can only
        *    happen if count is already nonzero.)
        * 3. Otherwise, this thread is eligible for lock if
        *    it is either a reentrant acquire or
        *    queue policy allows it. If so, update state
        *    and set owner.
        */
    // 獲取當前線程
    Thread current = Thread.currentThread();
    // 獲取狀態(tài)
    int c = getState();
    // 寫線程數(shù)量
    int w = exclusiveCount(c);
    if (c != 0) { // 狀態(tài)不為0
        // (Note: if c != 0 and w == 0 then shared count != 0)
        if (w == 0 || current != getExclusiveOwnerThread()) // 寫線程數(shù)量為0或者當前線程沒有占有獨占資源
            return false;
        if (w + exclusiveCount(acquires) > MAX_COUNT) // 判斷是否超過最高寫線程數(shù)量
            throw new Error("Maximum lock count exceeded");
        // Reentrant acquire
        // 設置AQS狀態(tài)
        setState(c + acquires);
        return true;
    }
    if (writerShouldBlock() ||
        !compareAndSetState(c, c + acquires)) // 寫線程是否應該被阻塞
        return false;
    // 設置獨占線程
    setExclusiveOwnerThread(current);
    return true;
}

/*
* Note that tryRelease and tryAcquire can be called by
* Conditions. So it is possible that their arguments contain
* both read and write holds that are all released during a
* condition wait and re-established in tryAcquire.
*/
protected final boolean tryRelease(int releases) {
    // 判斷是否偽獨占線程
    if (!isHeldExclusively())
        throw new IllegalMonitorStateException();
    // 計算釋放資源后的寫鎖的數(shù)量
    int nextc = getState() - releases;
    boolean free = exclusiveCount(nextc) == 0; // 是否釋放成功
    if (free)
        setExclusiveOwnerThread(null); // 設置獨占線程為空
    setState(nextc); // 設置狀態(tài)
    return free;
}

private IllegalMonitorStateException unmatchedUnlockException() {
    return new IllegalMonitorStateException(
        "attempt to unlock read lock, not locked by current thread");
}
// 共享模式下獲取資源
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();
    // 獲取狀態(tài)
    int c = getState();
    if (exclusiveCount(c) != 0 &&
        getExclusiveOwnerThread() != current) // 寫線程數(shù)不為0并且占有資源的不是當前線程
        return -1;
    // 讀鎖數(shù)量
    int r = sharedCount(c);
    if (!readerShouldBlock() &&
        r < MAX_COUNT &&
        compareAndSetState(c, c + SHARED_UNIT)) { // 讀線程是否應該被阻塞、并且小于最大值、并且比較設置成功
        if (r == 0) { // 讀鎖數(shù)量為0
            // 設置第一個讀線程
            firstReader = current;
            // 讀線程占用的資源數(shù)為1
            firstReaderHoldCount = 1;
        } else if (firstReader == current) { // 當前線程為第一個讀線程
            // 占用資源數(shù)加1
            firstReaderHoldCount++;
        } else { // 讀鎖數(shù)量不為0并且不為當前線程
            // 獲取計數(shù)器
            HoldCounter rh = cachedHoldCounter;
            if (rh == null || rh.tid != getThreadId(current)) // 計數(shù)器為空或者計數(shù)器的tid不為當前正在運行的線程的tid
                // 獲取當前線程對應的計數(shù)器
                cachedHoldCounter = rh = readHolds.get();
            else if (rh.count == 0) // 計數(shù)為0
                // 設置
                readHolds.set(rh);
            rh.count++;
        }
        return 1;
    }
    return fullTryAcquireShared(current);
}

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 (;;) { // 無限循環(huán)
        // 獲取狀態(tài)
        int c = getState();
        if (exclusiveCount(c) != 0) { // 寫線程數(shù)量不為0
            if (getExclusiveOwnerThread() != current) // 不為當前線程
                return -1;
            // else we hold the exclusive lock; blocking here
            // would cause deadlock.
        } else if (readerShouldBlock()) { // 寫線程數(shù)量為0并且讀線程被阻塞
            // Make sure we're not acquiring read lock reentrantly
            if (firstReader == current) { // 當前線程為第一個讀線程
                // assert firstReaderHoldCount > 0;
            } else { // 當前線程不為第一個讀線程
                if (rh == null) { // 計數(shù)器不為空
                    // 
                    rh = cachedHoldCounter;
                    if (rh == null || rh.tid != getThreadId(current)) { // 計數(shù)器為空或者計數(shù)器的tid不為當前正在運行的線程的tid
                        rh = readHolds.get();
                        if (rh.count == 0)
                            readHolds.remove();
                    }
                }
                if (rh.count == 0)
                    return -1;
            }
        }
        if (sharedCount(c) == MAX_COUNT) // 讀鎖數(shù)量為最大值，拋出異常
            throw new Error("Maximum lock count exceeded");
        if (compareAndSetState(c, c + SHARED_UNIT)) { // 比較并且設置成功
            if (sharedCount(c) == 0) { // 讀線程數(shù)量為0
                // 設置第一個讀線程
                firstReader = current;
                // 
                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;
        }
    }
}

protected final boolean tryReleaseShared(int unused) {
    // 獲取當前線程
    Thread current = Thread.currentThread();
    if (firstReader == current) { // 當前線程為第一個讀線程
        // assert firstReaderHoldCount > 0;
        if (firstReaderHoldCount == 1) // 讀線程占用的資源數(shù)為1
            firstReader = null;
        else // 減少占用的資源
            firstReaderHoldCount--;
    } else { // 當前線程不為第一個讀線程
        // 獲取緩存的計數(shù)器
        HoldCounter rh = cachedHoldCounter;
        if (rh == null || rh.tid != getThreadId(current)) // 計數(shù)器為空或者計數(shù)器的tid不為當前正在運行的線程的tid
            // 獲取當前線程對應的計數(shù)器
            rh = readHolds.get();
        // 獲取計數(shù)
        int count = rh.count;
        if (count <= 1) { // 計數(shù)小于等于1
            // 移除
            readHolds.remove();
            if (count <= 0) // 計數(shù)小于等于0，拋出異常
                throw unmatchedUnlockException();
        }
        // 減少計數(shù)
        --rh.count;
    }
    for (;;) { // 無限循環(huán)
        // 獲取狀態(tài)
        int c = getState();
        // 獲取狀態(tài)
        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;
    }
}

void processCachedData() {
    rwl.readLock().lock();
    if (!cacheValid) {
        // Must release read lock before acquiring write lock
        rwl.readLock().unlock();
        rwl.writeLock().lock();
        try {
            // Recheck state because another thread might have
            // acquired write lock and changed state before we did.
            if (!cacheValid) {
                data = ...
        cacheValid = true;
      }
      // Downgrade by acquiring read lock before releasing write lock
      rwl.readLock().lock();
    } finally {
      rwl.writeLock().unlock(); // Unlock write, still hold read
    }
  }
  try {
    use(data);
  } finally {
    rwl.readLock().unlock();
  }
}

public class Cache {
    private Map<String, Object> data = new HashMap<>();
    private ReadWriteLock lock = new ReentrantReadWriteLock();
    public Object get(String key) {
        lock.readLock().lock();
        try {
            return data.get(key);
        } finally {
            lock.readLock().unlock();
        }
    }
    public void put(String key, Object value) {
        lock.writeLock().lock();
        try {
            data.put(key, value);
        } finally {
            lock.writeLock().unlock();
        }
    }
}

public class Counter {
    private int count = 0;
    private StampedLock lock = new StampedLock();
    public int getCount() {
        long stamp = lock.tryOptimisticRead();
        int value = count;
        if (!lock.validate(stamp)) {
            stamp = lock.readLock();
            try {
                value = count;
            } finally {
                lock.unlockRead(stamp);
            }
        }
        return value;
    }
    public void increment() {
        long stamp = lock.writeLock();
        try {
            count++;
        } finally {
            lock.unlockWrite(stamp);
        }
    }
}