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 static void main(String[] args){
    // 1、構(gòu)建讀寫鎖對象
    ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();

    // 2、單獨獲取讀、寫鎖對象
    ReentrantReadWriteLock.ReadLock readLock = readWriteLock.readLock();
    ReentrantReadWriteLock.WriteLock writeLock = readWriteLock.writeLock();

    // 3、根據(jù)業(yè)務(wù)使用具體的鎖對象加鎖
    writeLock.lock();
    // try-finally的目的，是為了避免沒有及時釋放鎖資源導(dǎo)致死鎖的問題。
    try{
        // 4、業(yè)務(wù)操作…………
        System.out.println("寫操作");
    }finally {
        // 5、釋放鎖
        writeLock.unlock();
    }
}

static final int SHARED_SHIFT   = 16;
static final int EXCLUSIVE_MASK = (1 << SHARED_SHIFT) - 1;
00000000 00000000 11111111 11111111
/** 查看讀鎖的占用情況。 */
static int sharedCount(int state)    { return state >>> SHARED_SHIFT; }
/** Returns the number of exclusive holds represented in count  */
static int exclusiveCount(int state) { return state & EXCLUSIVE_MASK; }

00000000 00000000 00000000 00000000    int類型的數(shù)值的32個bit位。 

讀鎖占用情況：
00000000 00000011 00000000 00000000    state
>>> 16 
00000000 00000000 00000000 00000011    讀鎖被獲取了三次。

寫鎖占用情況。（這里之所以&這個么東西，是對后期的鎖降級有影響~）
00000000 00000000 00000000 00000001    state
&
00000000 00000000 11111111 11111111  
=
00000000 00000000 00000000 00000001    寫鎖被獲取了一次。

public class Demo {
    // 1、構(gòu)建讀寫鎖對象
    static ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();

    // 2、單獨獲取讀、寫鎖對象
    static ReentrantReadWriteLock.ReadLock readLock;
    static ReentrantReadWriteLock.WriteLock writeLock;

    static{
        // 2、單獨獲取讀、寫鎖對象
        readLock = readWriteLock.readLock();
        writeLock = readWriteLock.writeLock();
    }

    public static void main(String[] args){
        // 3、根據(jù)業(yè)務(wù)使用具體的鎖對象加鎖
        writeLock.lock();
        // try-finally的目的，是為了避免沒有及時釋放鎖資源導(dǎo)致死鎖的問題。
        try{
            // 4、業(yè)務(wù)操作…………調(diào)用其他方法
            xxx();
        }finally {
            // 5、釋放鎖
            writeLock.unlock();
        }
    }

    private static void xxx(){
        writeLock.lock();
        try{
            // 其他按業(yè)務(wù)
        }finally {
            writeLock.unlock();
        }
    }
}

// 這個方法，總結(jié)一句話。  
// AQS中有排隊的Node，并且head的next節(jié)點是一個有線程并且在等待寫鎖的Node
final boolean apparentlyFirstQueuedIsExclusive() {
    Node h, s;
    return (h = head) != null &&
        (s = h.next)  != null &&
        !s.isShared()         &&
        s.thread != null;
}

// 競爭讀鎖。
if (exclusiveCount(c) != 0 &&   // 這行代表某個線程持有寫鎖
    getExclusiveOwnerThread() != current)    // 這行代表持有寫鎖的不是當前線程
    // 退出競爭，無法獲取讀鎖
    return -1;  

// 獲取上次最后獲取讀鎖的線程
HoldCounter rh = cachedHoldCounter;
// 查看當前線程是否是之前的cachedHoldCounter
if (rh == null || rh.tid != getThreadId(current))
    // 說明不是，將當前獲取讀鎖的線程設(shè)置為cachedHoldCounter
    cachedHoldCounter = rh = readHolds.get();
// 這個判斷代表第一次獲取讀鎖才會進去
else if (rh.count == 0)
    // 如果是第一次獲取讀鎖，不是重入，還是需要扔到ThreadLocal里紀錄好，。
    readHolds.set(rh);
// 直接對獲取到的rh做++操作，代表獲取了一次讀鎖。
rh.count++;