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

public class ReentrantReadWriteLock
        implements ReadWriteLock, java.io.Serializable {
    private static final long serialVersionUID = -6992448646407690164L;
    /** Inner class providing readlock */
    private final ReentrantReadWriteLock.ReadLock readerLock;
    /** Inner class providing writelock */
    private final ReentrantReadWriteLock.WriteLock writerLock;
    /** Performs all synchronization mechanics */
    final Sync sync;
    public ReentrantReadWriteLock() {
        this(false);
    }
    public ReentrantReadWriteLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
        readerLock = new ReadLock(this);
        writerLock = new WriteLock(this);
    }
    public ReentrantReadWriteLock.WriteLock writeLock() { return writerLock; }
    public ReentrantReadWriteLock.ReadLock  readLock()  { return readerLock; }

private ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
private Lock r = readWriteLock.readLock();
private Lock w = readWriteLock.writeLock();
// 讀操作上讀鎖
public Data get(String key) {
  r.lock();
  try { 
      // TODO 業(yè)務(wù)邏輯
  }finally { 
       r.unlock(); 
   }
}
// 寫操作上寫鎖
public Data put(String key, Data value) {
  w.lock();
  try { 
      // TODO 業(yè)務(wù)邏輯
  }finally { 
       w.unlock(); 
   }

public class Cache {
    static Map<String, Object> map = new HashMap<String, Object>();
    static ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
    static Lock r = rwl.readLock();
    static Lock w = rwl.writeLock();
    // 獲取一個(gè)key對(duì)應(yīng)的value
    public static final Object get(String key) {
        r.lock();
        try {
            return map.get(key);
        } finally {
            r.unlock();
        }
    }
    // 設(shè)置key對(duì)應(yīng)的value，并返回舊的value
    public static final Object put(String key, Object value) {
        w.lock();
        try {
            return map.put(key, value);
        } finally {
            w.unlock();
        }
    }
    // 清空所有的內(nèi)容
    public static final void clear() {
        w.lock();
        try {
            map.clear();
        } finally {
            w.unlock();
        }
    }

private final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
private final Lock r = rwl.readLock();
private final Lock w = rwl.writeLock();
private volatile boolean update = false;
public void processData() {
    readLock.lock();
    if (!update) {
        // 必須先釋放讀鎖
        readLock.unlock();
        // 鎖降級(jí)從寫鎖獲取到開始
        writeLock.lock();
        try {
            if (!update) {
                // TODO 準(zhǔn)備數(shù)據(jù)的流程（略）  
                update = true;
            }
            readLock.lock();
        } finally {
            writeLock.unlock();
        }
        // 鎖降級(jí)完成，寫鎖降級(jí)為讀鎖
    }
    try {
        //TODO  使用數(shù)據(jù)的流程（略）
    } finally {
        readLock.unlock();
    }
}

abstract static class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = 6317671515068378041L;
        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;
        static int sharedCount(int c)    { return c >>> SHARED_SHIFT; }
        static int exclusiveCount(int c) { return c & EXCLUSIVE_MASK; }

  static final class HoldCounter {
            int count = 0;
            final long tid = getThreadId(Thread.currentThread());
        }
        static final class ThreadLocalHoldCounter
            extends ThreadLocal<HoldCounter> {
            public HoldCounter initialValue() {
                return new HoldCounter();
            }
        }

protected final boolean tryAcquire(int acquires) {
    //當(dāng)前線程
    Thread current = Thread.currentThread();
    //獲取state狀態(tài)   存在讀鎖或者寫鎖，狀態(tài)就不為0
    int c = getState();
    //獲取寫鎖的重入數(shù)
    int w = exclusiveCount(c);
    //當(dāng)前同步狀態(tài)state != 0，說明已經(jīng)有其他線程獲取了讀鎖或?qū)戞i
    if (c != 0) {
        // c!=0 && w==0 表示存在讀鎖
        // 當(dāng)前存在讀鎖或者寫鎖已經(jīng)被其他寫線程獲取，則寫鎖獲取失敗
        if (w == 0 || current != getExclusiveOwnerThread())
            return false;
        // 超出最大范圍  65535
        if (w + exclusiveCount(acquires) > MAX_COUNT)
            throw new Error("Maximum lock count exceeded");
        //同步state狀態(tài)
        setState(c + acquires);
        return true;
    }
    // writerShouldBlock有公平與非公平的實(shí)現(xiàn), 非公平返回false，會(huì)嘗試通過cas加鎖
    //c==0 寫鎖未被任何線程獲取，當(dāng)前線程是否阻塞或者cas嘗試獲取鎖 
    if (writerShouldBlock() ||
        !compareAndSetState(c, c + acquires))
        return false;
    //設(shè)置寫鎖為當(dāng)前線程所有
    setExclusiveOwnerThread(current);
    return true;

protected final boolean tryRelease(int releases) {
    //若鎖的持有者不是當(dāng)前線程，拋出異常
    if (!isHeldExclusively())
        throw new IllegalMonitorStateException();
    int nextc = getState() - releases;
    //當(dāng)前寫狀態(tài)是否為0，為0則釋放寫鎖
    boolean free = exclusiveCount(nextc) == 0;
    if (free)
        setExclusiveOwnerThread(null);
    setState(nextc);
    return free;

protected final int tryAcquireShared(int unused) {
    Thread current = Thread.currentThread();
    int c = getState();
    // 如果寫鎖已經(jīng)被獲取并且獲取寫鎖的線程不是當(dāng)前線程，當(dāng)前線程獲取讀鎖失敗返回-1   判斷鎖降級(jí)
    if (exclusiveCount(c) != 0 &&
        getExclusiveOwnerThread() != current)
        return -1;
    //計(jì)算出讀鎖的數(shù)量
    int r = sharedCount(c);
    /**
    * 讀鎖是否阻塞    readerShouldBlock()公平與非公平的實(shí)現(xiàn)
    * r < MAX_COUNT： 持有讀鎖的線程小于最大數(shù)（65535）
    *  compareAndSetState(c, c + SHARED_UNIT) cas設(shè)置獲取讀鎖線程的數(shù)量
    */
    if (!readerShouldBlock() &&
        r < MAX_COUNT &&
        compareAndSetState(c, c + SHARED_UNIT)) {   //當(dāng)前線程獲取讀鎖
        
        if (r == 0) {  //設(shè)置第一個(gè)獲取讀鎖的線程
            firstReader = current; 
            firstReaderHoldCount = 1;  //設(shè)置第一個(gè)獲取讀鎖線程的重入數(shù)
        } else if (firstReader == current) { // 表示第一個(gè)獲取讀鎖的線程重入
            firstReaderHoldCount++;
        } else { // 非第一個(gè)獲取讀鎖的線程
            HoldCounter rh = cachedHoldCounter;
            if (rh == null || rh.tid != getThreadId(current))
                cachedHoldCounter = rh = readHolds.get();
            else if (rh.count == 0)
                readHolds.set(rh);
            rh.count++;  //記錄其他獲取讀鎖的線程的重入次數(shù)
        }
        return 1;
    }
    // 嘗試通過自旋的方式獲取讀鎖,實(shí)現(xiàn)了重入邏輯
    return fullTryAcquireShared(current);

protected final boolean tryReleaseShared(int unused) {
    Thread current = Thread.currentThread();
    //如果當(dāng)前線程是第一個(gè)獲取讀鎖的線程
    if (firstReader == current) {
        // assert firstReaderHoldCount > 0;
        if (firstReaderHoldCount == 1)
            firstReader = null;
        else
            firstReaderHoldCount--; //重入次數(shù)減1
    } else {  //不是第一個(gè)獲取讀鎖的線程
        HoldCounter rh = cachedHoldCounter;  
        if (rh == null || rh.tid != getThreadId(current))
            rh = readHolds.get();
        int count = rh.count;
        if (count <= 1) {
            readHolds.remove();
            if (count <= 0)
                throw unmatchedUnlockException();
        }
        --rh.count;  //重入次數(shù)減1
    }
    for (;;) {  //cas更新同步狀態(tài)
        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;
    }