1、細說AQS

在深入分析AQS之前，我想先從AQS的功能上說明下AQS，站在使用者的角度，AQS的功能可以分為兩類：獨佔鎖和共享鎖。它的所有子類中，要麼實現並使用了它獨佔鎖的API，要麼使用了共享鎖的API，而不會同時使用兩套API，即便是它最有名的子類ReentrantReadWriteLock，也是通過兩個內部類：讀鎖和寫鎖，分別實現的兩套API來實現的，到目前為止，我們只需要明白AQS在功能上有獨佔鎖和共享鎖兩種功能即可。

2、ReentrantLock的呼叫過程

AbstractQueuedSynchronizer中抽象了絕大多數Lock的功能，而只把tryAcquire方法延遲到子類中去實現。tryAcquire方法的語義在於用具體子類判斷請求執行緒是否可以獲得鎖，無論成功與否AbstractQueuedSynchronizer都將處理後面的流程。

3、獲取鎖的過程

簡單說來，AbstractQueuedSynchronizer會把所有的請求執行緒構成一個CLH佇列，當一個執行緒執行完畢（lock.unlock()）時會啟用自己的後繼節點，但正在執行的執行緒並不在佇列中，而那些等待執行的執行緒全部處於阻塞狀態。

4、非公平鎖的加鎖流程

(1). 首先我們分析非公平鎖的的請求過程。我們假設在這個時候，還沒有任務執行緒獲取鎖，這個時候，第一個執行緒過來了(我們使用的是非公平鎖)，那麼第一個執行緒thread1會去獲取鎖，這時它會呼叫下面的方法，通過CAS的操作，將當前AQS的state由0變成1，證明當前thread1已經獲取到鎖，並且將AQS的exclusiveOwnerThread設定成thread1，證明當前持有鎖的執行緒是thread1。：

/**
 * Performs lock.  Try immediate barge, backing up to normal
 * acquire on failure.
 */
final void lock() {
    // 如果鎖沒有被任何執行緒鎖定且加鎖成功則設定當前執行緒為鎖的擁有者
    if (compareAndSetState(0, 1))
        setExclusiveOwnerThread(Thread.currentThread());
    else
        acquire(1);
}

(2). 此時來了第二個執行緒thread2，並且我們假設thread1還沒有釋放鎖，因為我們使用的是非公平鎖，那麼thread2首先會進行搶佔式的去獲取鎖，呼叫NonFairSync.lock方法獲取鎖。NonFairSync.lock方法的第一個分支是通過CAS操作獲取鎖，很明顯，這一步肯定會失敗，因為此時thread1還沒有釋放鎖。那麼thread2將會走NonFairSync.lock方法的第二個分支，進行acquire(1)操作。acquire(1)其實是AQS的方法，acquire(1)方法內部首先呼叫tryAcquire方法，ReentrantLock.NonFairLock重寫了tryAcquire方法，並且ReentrantLock.NonFairLock的tryAcquire方法又呼叫了ReentrantLock.

Sync的nonfairTryAcquire方法，nonfairTryAcquire方法如下：

 /**
         * Performs non-fair tryLock.  tryAcquire is
         * implemented in subclasses, but both need nonfair
         * try for trylock method.
         */
        final boolean nonfairTryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {
                if (compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            else if (current == getExclusiveOwnerThread()) {
                int nextc = c + acquires;
                if (nextc < 0) // overflow
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
        }

這個方法的執行邏輯如下：

1. 獲取當前將要去獲取鎖的執行緒，在此時的情況下，也就是我們的thread2執行緒。

2. 獲取當前AQS的state的值。如果此時state的值是0，那麼我們就通過CAS操作獲取鎖，然後設定AQS的exclusiveOwnerThread為thread2。很明顯，在當前的這個執行情況下，state的值是1不是0，因為我們的thread1還沒有釋放鎖。

3. 如果當前將要去獲取鎖的執行緒等於此時AQS的exclusiveOwnerThread的執行緒，則此時將state的值加1，很明顯這是重入鎖的實現方式。在此時的執行狀態下，將要去獲取鎖的執行緒不是thread1，也就是說這一步不成立。

4. 以上操作都不成立的話，我們直接返回false。

既然返回了false，那麼之後就會呼叫addWaiter方法，這個方法負責把當前無法獲取鎖的執行緒包裝為一個Node新增到隊尾。通過下面的程式碼片段我們就知道呼叫邏輯：

public final void acquire(int arg) {
        if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }

我們進入到addWaiter方法內部去看：

private Node addWaiter(Node mode) {
        Node node = new Node(Thread.currentThread(), mode);
        // Try the fast path of enq; backup to full enq on failure
        Node pred = tail;
        if (pred != null) {
            node.prev = pred;
            if (compareAndSetTail(pred, node)) {
                pred.next = node;
                return node;
            }
        }
        enq(node);
        return node;
    }

很明顯在addWaiter內部：

第一步：將當前將要去獲取鎖的執行緒也就是thread2和獨佔模式封裝為一個node物件。並且我們也知道在當前的執行環境下，執行緒阻塞佇列是空的，因為thread1獲取了鎖，thread2也是剛剛來請求鎖，所以執行緒阻塞佇列裡面是空的。很明顯，這個時候佇列的尾部tail節點也是null，那麼將直接進入到enq方法。

第二步：我們首先看下enq方法的內部實現。首先內部是一個自懸迴圈。

private Node enq(final Node node) {
        for (;;) {
            Node t = tail;
            if (t == null) { // Must initialize
                if (compareAndSetHead(new Node()))
                    tail = head;
            } else {
                node.prev = t;
                if (compareAndSetTail(t, node)) {
                    t.next = node;
                    return t;
                }
            }
        }
    }

第一次迴圈：t為null，隨後我們new出了一個空的node節點，並且通過CAS操作設定了執行緒的阻塞佇列的head節點就是我們剛才new出來的那個空的node節點，其實這是一個“假節點”，那麼什麼是“假節點”呢？那就是節點中不包含執行緒。設定完head節點後，同時又將head節點賦值給尾部tail節點，到此第一次迴圈結束。此時的節點就是如下：

第二次迴圈：

現在判斷尾部tail已經不是null了，那麼就走第二個分支了。將尾部tail節點賦值給我們傳遞進來的節點Node的前驅節點，此時的結構如下：

然後再通過CAS的操作，將我們傳遞進來的節點node設定成尾部tail節點，並且將我們的node節點賦值給原來的老的那個尾部節點的後繼節點，此時的結構如下：

這個時候程式碼中使用了return關鍵字，也就是證明我們經過了2次迴圈跳出了這個自懸迴圈體系。

按照程式碼的執行流程，接下來將會呼叫acquireQueued方法，主要是判斷當前節點的前驅節點是不是head節點，如果是的話，就再去嘗試獲取鎖，如果不是，就掛起當前執行緒。這裡可能有人疑問了，為什麼判斷當前節點的前驅節點是head節點的話就去嘗試獲取鎖呢？因為我們知道head節點是一個假節點，如果當前的節點的前驅節點是頭節點即是假節點的話，那麼這個假節點的後繼節點就有可能有獲取鎖的機會，所以我們需要去嘗試。

現在我們看下acquireQueued方法內部，我們也可以清楚的看到，這個方法的內部也是一個自懸迴圈。：

final boolean acquireQueued(final Node node, int arg) {
        boolean failed = true;
        try {
            boolean interrupted = false;
            for (;;) {
                final Node p = node.predecessor();
                if (p == head && tryAcquire(arg)) {
                    setHead(node);
                    p.next = null; // help GC
                    failed = false;
                    return interrupted;
                }
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

第一次迴圈：獲取我們傳入node的前驅節點，判斷是否是head節點，現在我們的狀態是：

很明顯滿足當前node節點的前驅節點是head節點，那麼現在我們就要去呼叫tryAcquire方法，也就是NonfairSync類的tryAcquire方法，而這個方法又呼叫了ReentrantLock.Sync.nonfairTryAcquire方法。

很明顯此時thread2獲取鎖是失敗的，直接返回false。按照呼叫流程，現在進入了當前節點的前驅節點的shouldParkAfterFailedAcquire方法，檢查當前節點的前驅節點的waitstatus。shouldParkAfterFailedAcquire方法內部如下：

final boolean acquireQueued(final Node node, int arg) {
        boolean failed = true;
        try {
            boolean interrupted = false;
            for (;;) {
                final Node p = node.predecessor();
                if (p == head && tryAcquire(arg)) {
                    setHead(node);
                    p.next = null; // help GC
                    failed = false;
                    return interrupted;
                }
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

1. 如果前驅節點的waitStatus為-1，也就是SIGNAL，就返回true。

2. 如果當前節點的前驅節點的waitstatus大於0，也就是說被CANCEL掉了，這個時候我們會除掉這個節點。

3. 如果都不是以上的情況，就通過CAS操作將這個前驅節點設定成SIGHNAL。

很明顯，我們在這裡的情況是第3種情況，並且這個方法執行後返回false。

此時的結構如下，主要是head節點的waitStatus由0變成了-1。

第二次迴圈：獲取我們傳入node的前驅節點，判斷是否是head節點，現在我們的狀態是：

很明顯滿足當前node節點的前驅節點是head節點，那麼現在我們就要去呼叫tryAcquire方法，也就是NonfairSync類的tryAcquire方法，而這個方法又呼叫了ReentrantLock.Sync.nonfairTryAcquire方法。

很明顯此時thread2獲取鎖是失敗的，直接返回false。按照呼叫流程，現在進入了當前節點的前驅節點的shouldParkAfterFailedAcquire方法，檢查當前節點的前驅節點的waitstatus。此時waitstatus為-1，這個方法返回true。shouldParkAfterFailedAcquire返回true後，就會呼叫parkAndCheckInterrupt方法，直接將當前執行緒thread2阻塞。仔細看這個方法acquireQueued方法，是無限迴圈，感覺如果p == head && tryAcquire(arg)條件不滿足迴圈將永遠無法結束，在這裡，當然不會出現死迴圈。因為parkAndCheckInterrupt會把當前執行緒阻塞。分析到這裡，我們的thread2執行緒已經被阻塞了，這個執行緒不會再繼續執行下去了。

(3). 假設現在我們的thread1還沒有釋放鎖，而現在又來了一個執行緒thread3。

thread3首先呼叫lock方法獲取鎖，首先去搶佔鎖，因為我們知道thread1還沒有釋放鎖，這個時候thread3肯定搶佔失敗，於是又呼叫了acquire方法，接著又失敗。接著會去呼叫addWaiter方法，將當前執行緒thread3封裝成node加入到執行緒阻塞佇列的尾部。現在的結構如下：

addWaiter如下：

private Node addWaiter(Node mode) {
        Node node = new Node(Thread.currentThread(), mode);
        // Try the fast path of enq; backup to full enq on failure
        Node pred = tail;
        if (pred != null) {
            node.prev = pred;
            if (compareAndSetTail(pred, node)) {
                pred.next = node;
                return node;
            }
        }
        enq(node);
        return node;
    }

第一步：將當前將要去獲取鎖的執行緒也就是thread3和獨佔模式封裝為一個node物件。並且我們也知道在當前的執行環境下，執行緒阻塞佇列不是空的，因為thread2獲取了鎖，thread2已經加入了佇列。很明顯，這個時候佇列的尾部tail節點也不是null，那麼將直接進入到if分支。將尾部tail節點賦值給我們傳入的node節點的前驅節點。如下：

第二步：通過CAS將我們傳遞進來的node節點設定成tail節點，並且將新tail節點設定成老tail節點的後繼節點。

到此，addWaiter方法執行完畢，接著執行acquireQueued方法。這是一個自迴圈方法。

final boolean acquireQueued(final Node node, int arg) {
        boolean failed = true;
        try {
            boolean interrupted = false;
            for (;;) {
                final Node p = node.predecessor();
                if (p == head && tryAcquire(arg)) {
                    setHead(node);
                    p.next = null; // help GC
                    failed = false;
                    return interrupted;
                }
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

第一次迴圈：獲取我們傳入node的前驅節點，判斷是否是head節點，現在我們的狀態是：

我們傳入node的前驅節點不是head節點，那麼直接走第二個if分支，呼叫shouldParkAfterFailedAcquire方法。

1. 如果前驅節點的waitStatus為-1，也就是SIGNAL，就返回true。

2. 如果當前節點的前驅節點的waitstatus大於0，也就是說被CANCEL掉了，這個時候我們會除掉這個節點。

3. 如果都不是以上的情況，就通過CAS操作將這個前驅節點設定成SIGHNAL。

很明顯，我們在這裡的情況是第3種情況，並且這個方法執行後返回false。

此時的結構如下，主要是t節點的waitStatus由0變成了-1。

相關推薦