AQS之ReentrantReadWriteLock寫鎖

1. 用法

1.1 定義一個安全的list集合

public class LockDemo  {
ArrayList<Integer> arrayList = new ArrayList<>();//定義一個集合
// 定義讀鎖
ReentrantReadWriteLock.ReadLock readLock = new    ReentrantReadWriteLock(true).readLock();
// 定義寫鎖
ReentrantReadWriteLock.WriteLock writeLock = new ReentrantReadWriteLock(true).writeLock();

public void addEle(Integer ele) {
writeLock.lock(); // 獲取寫鎖
arrayList.add(ele);
writeLock.unlock(); // 釋放寫鎖
}
public Integer getEle(Integer index) {
try{
readLock.lock(); // 獲取讀鎖
Integer res = arrayList.get(index);
return res;
} finally{
readLock.unlock();// 釋放讀鎖
}
}
}

1.2 Sync 源碼中的屬性與方法在上一篇文章中已經講過了

2. 獲取寫鎖源碼分析

       ReentrantReadWriteLock中的lock方法

public void lock() {
sync.acquire(1);
}

       AbstractQueuedSynchronizer中的acquire方法

public final void acquire(int arg) {
    // 獲取鎖失敗則進入阻塞隊列
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}

       acquireQueued(addWaiter(Node.EXCLUSIVE), arg))**，中的acquireQueued方法和addWaiter方法在前面的文章中都已經進行了詳細的解釋說明。**

       ReentrantReadWriteLock中的tryAcquire方法

protected final boolean tryAcquire(int acquires) {
    // 獲取當前線程
    Thread current = Thread.currentThread();
    //  獲取狀態
    int c = getState();
    // 計算寫線程數量就是獨佔鎖的可從入數量
    int w = exclusiveCount(c);
    // 當前同步狀態state != 0，說明已經有其餘線程獲取了讀鎖或寫鎖
    if (c != 0) {
       // 當前state不爲0，此時：若是寫鎖狀態爲0說明讀鎖此時被佔用返回false；
       // 若是寫鎖狀態不爲0且寫鎖沒有被當前線程持有返回false
        if (w == 0 || current != getExclusiveOwnerThread())
            return false;
       // 判斷同一線程獲取寫鎖是否超過最大次數（65535），支持可重入     
        if (w + exclusiveCount(acquires) > MAX_COUNT)
            throw new Error("Maximum lock count exceeded");
         //更新狀態
         //此時當前線程已持有寫鎖，如今是重入，因此只須要修改鎖的數量便可
        setState(c + acquires);
        return true;
    }
      //到這裏說明此時c=0,讀鎖和寫鎖都沒有被獲取
      //writerShouldBlock表示是否阻塞
    if (writerShouldBlock() ||
        !compareAndSetState(c, c + acquires))
        return false;
        // 設置鎖爲當前線程全部
    setExclusiveOwnerThread(current);
    return true;
}
static final class FairSync extends Sync {
// 寫鎖是否應該被阻塞
    final boolean writerShouldBlock() {
return hasQueuedPredecessors();
}
}

3. 獲取寫鎖流程圖

3.1 流程圖獲取寫鎖過程

3.2 流程圖獲取寫鎖過程解析

寫鎖的獲取過程以下：

1. 首先獲取c、w。c表示當前鎖狀態；w表示寫線程數量。而後判斷同步狀態state是否爲0。若是state!=0，說明已經有其餘線程獲取了讀鎖或寫鎖。
2. 若是鎖狀態不爲零（c != 0），而寫鎖的狀態爲0（w = 0），說明讀鎖此時被其餘線程佔用，因此當前線程不能獲取寫鎖，天然返回false。或者鎖狀態不爲零，而寫鎖的狀態也不爲0，可是獲取寫鎖的線程不是當前線程，則當前線程也不能獲取寫鎖。
3. 判斷當前線程獲取寫鎖是否超過最大次數，若超過，拋異常，反之更新同步狀態（此時當前線程已獲取寫鎖，更新是線程安全的），返回true。
4. 若是state爲0，此時讀鎖或寫鎖都沒有被獲取，判斷是否須要阻塞（公平和非公平方式實現不一樣），在非公平策略下老是不會被阻塞，在公平策略下會進行判斷（判斷同步隊列中是否有等待時間更長的線程，若存在，則須要被阻塞，不然，無需阻塞），若是不須要阻塞，則CAS更新同步狀態，若CAS成功則返回true，失敗則說明鎖被別的線程搶去了，返回false。若是須要阻塞則也返回false。
5. 成功獲取寫鎖後，將當前線程設置爲佔有寫鎖的線程，返回true。
6. 獲取鎖失敗的話，將當前線程進行放入阻塞隊列中。

   4. 釋放寫鎖源碼分析

       ReentrantReadWriteLock中的unlock方法

public void unlock() {
    sync.release(1);
}

       AbstractQueuedSynchronizer中的release方法

public final boolean release(int arg) {
    // 若是返回true 那麼釋放成功了
    if (tryRelease(arg)) {
        Node h = head;
        // 若是頭部不爲空，而且頭節點的waitStatus是喚醒狀態那麼喚醒後繼線程
        if (h != null && h.waitStatus != 0)
         // 喚醒後繼線程
            unparkSuccessor(h);
        return true;
    }
    return false;
}

       ReentrantReadWriteLock中tryRelease方法

protected final boolean tryRelease(int releases) {
// 若鎖的持有者不是當前線程，拋出異常
    if (!isHeldExclusively())
     // 非法的監控器異常
        throw new IllegalMonitorStateException();
        // 計算寫鎖的新線程數
    int nextc = getState() - releases;
    // 若是獨佔模式重入數爲0了，說明獨佔模式被釋放
    boolean free = exclusiveCount(nextc) == 0;
    if (free)
     // 設置獨佔線程爲空
        setExclusiveOwnerThread(null);
    // 設置寫鎖的新線程數
    // 無論獨佔模式是否被釋放，更新獨佔重入數
    setState(nextc);
    return free;
}
protected final boolean isHeldExclusively() {
    // 若當前線程是當前鎖的持有線程那麼返回true
    return getExclusiveOwnerThread() == Thread.currentThread();
}

5. 釋放寫鎖流程圖

5.1 流程圖釋放過程

5.2 流程圖釋放過程解析

寫鎖的釋放過程：

1. 首先查看當前線程是否爲寫鎖的持有者，若是不是拋出異常。而後檢查釋放後寫鎖的線程數是否爲0，若是爲0則表示寫鎖空閒了，釋放鎖資源將鎖的持有線程設置爲null，不然釋放僅僅只是一次重入鎖而已，並不能將寫鎖的線程清空。
2. 說明：此方法用於釋放寫鎖資源，首先會判斷該線程是否爲獨佔線程，若不爲獨佔線程，則拋出異常，不然，計算釋放資源後的寫鎖的數量，若爲0，表示成功釋放，資源不將被佔用，不然，表示資源還被佔用。

   6. 總結

   6.1 state 解析

private volatile int state;

       int 類型佔有 4個字節一個字節8位,因此 state 一個 32 位,高 16 位 表明讀鎖 低 16 位表明 寫鎖。

// 0x0000FFFF 16 進制
// 1111111111111111 2 進制
// 65535 10 進制
static final int SHARED_SHIFT   = 16;
static final int SHARED_UNIT    = (1 << SHARED_SHIFT); // 65536
static final int MAX_COUNT      = (1 << SHARED_SHIFT) - 1; //65535  
// 1111111111111111
static final int EXCLUSIVE_MASK = (1 << SHARED_SHIFT) - 1; // 65535 
// 1111111111111111

       若是此時同步狀態位 c 那麼獲取寫狀態 c & EXCLUSIVE_MASK
       若是此時同步狀態位 c 那麼獲取讀狀態 c >>>16 無符號補0，右移16位

6.2 注意

       *以上即是ReentrantReadWriteLock中寫鎖的分析，下一篇文章將是***Condition**的分析，若有錯誤之處，幫忙指出及時更正,謝謝，若是喜歡謝謝點贊加收藏加轉發（轉發註明出處謝謝！！！）