硬核剖析Java鎖底層AQS原始碼，深入理解底層架構設計-有解無憂

我們常見的并發鎖ReentrantLock、CountDownLatch、Semaphore、CyclicBarrier都是基于AQS實作的，所以說不懂AQS實作原理的，就不能說了解Java鎖，

上篇文章講了AQS的加鎖流程，這篇文章再一塊看一下AQS具體原始碼實作，

先回顧一下AQS的加鎖流程

1. AQS加鎖流程

AQS的加鎖流程并不復雜，只要理解了同步佇列和條件佇列，以及它們之間的資料流轉，就算徹底理解了AQS，

當多個執行緒競爭AQS鎖時，如果有個執行緒獲取到鎖，就把ower執行緒設定為自己
沒有競爭到鎖的執行緒，在同步佇列中阻塞（同步佇列采用雙向鏈表，尾插法），
持有鎖的執行緒呼叫await方法，釋放鎖，追加到條件佇列的末尾（條件佇列采用單鏈表，尾插法），
持有鎖的執行緒呼叫signal方法，喚醒條件佇列的頭節點，并轉移到同步佇列的末尾，
同步佇列的頭節點優先獲取到鎖

了解AQS加鎖流程之后，再去看原始碼就容易理解了，

2. AQS的資料結構

// 繼承自AbstractOwnableSynchronizer，為了記錄哪個執行緒占用鎖
public abstract class AbstractQueuedSynchronizer extends AbstractOwnableSynchronizer {
  
    // 同步狀態，0表示無鎖，每次加鎖+1，釋放鎖-1
    private volatile int state;

    // 同步佇列的頭尾節點
    private transient volatile Node head;
    private transient volatile Node tail;

    // Node節點，用來包裝執行緒，放到佇列中
    static final class Node {
        // 節點中的執行緒
        volatile Thread thread;

        // 節點狀態
        volatile int waitStatus;

        // 同步佇列的前驅節點和后繼節點
        volatile Node prev;
        volatile Node next;

        // 條件佇列的后繼節點
        Node nextWaiter;
    }

    // 條件佇列
    public class ConditionObject implements Condition {
        // 條件佇列的頭尾節點
        private transient Node firstWaiter;
        private transient Node lastWaiter;
    }
}

首先AQS繼承自AbstractOwnableSynchronizer，其實是為了記錄哪個執行緒正在占用鎖，

public abstract class AbstractOwnableSynchronizer {

    private transient Thread exclusiveOwnerThread;

    // 設定占用鎖的執行緒
    protected final void setExclusiveOwnerThread(Thread thread) {
        exclusiveOwnerThread = thread;
    }

    protected final Thread getExclusiveOwnerThread() {
        return exclusiveOwnerThread;
    }
}

無論是同步佇列還是條件佇列中執行緒都需要包裝成Node節點，

雖然同步佇列和條件佇列都是由Node節點組成的，但是同步佇列中是使用prev和next組成雙向鏈表，nextWaiter只用來表示是共享模式還是排他模式，

條件佇列沒有使用到Node中prev和next屬性，而是使用nextWaiter組成單鏈表，

這個復用物件的設計思想值得我們學習，

同步佇列head節點是個啞節點，里面并沒有存盤執行緒物件，當然head節點也可以看成是給當前持有鎖的執行緒使用的，

Node節點的狀態（waitStatus）共有5種：

1 cancelled：表示執行緒已經被取消
0 初始化：Node節點的默認值
-1 signal: 表示節點執行緒在釋放鎖后要喚醒同步佇列中的下一個節點執行緒
-2 condition: 當前節點在條件佇列中
-3 propagate: 釋放共享資源的時候會向后傳播釋放其他共享節點(用于共享模式)

3. AQS方法概覽

AQS支持獨占和共享兩種訪問資源的模式（獨占模式又叫排他模式），

獨占模式的方法：

// 加鎖
acquire();
// 加可中斷的鎖
acquireInterruptibly();
// 一段時間內，加鎖不成功，就不加了
tryAcquireNanos(int arg, long nanosTimeout);
// 釋放鎖
release();

共享模式的方法：

// 加鎖
acquireShared();
// 加可中斷的鎖
acquireSharedInterruptibly();
// 一段時間內，加鎖不成功，就不加了
tryAcquireSharedNanos(int arg, long nanosTimeout);
// 釋放鎖
releaseShared();

獨占模式和共享模式的方法并沒有實作具體的加鎖、釋放鎖邏輯，AQS中只是定義了加鎖、釋放鎖的抽象方法，

留給子類實作的抽象方法：

// 加獨占鎖
protected boolean tryAcquire(int arg) {
    throw new UnsupportedOperationException();
}
// 釋放獨占鎖
protected boolean tryRelease(int arg) {
    throw new UnsupportedOperationException();
}

// 加共享鎖
protected int tryAcquireShared(int arg) {
    throw new UnsupportedOperationException();
}
// 釋放共享鎖
protected boolean tryReleaseShared(int arg) {
    throw new UnsupportedOperationException();
}

// 判斷是否是當前執行緒正在持有鎖
protected boolean isHeldExclusively() {
    throw new UnsupportedOperationException();
}

這里就用到了設計模式中的模板模式，父類AQS定義了加鎖、釋放鎖的流程，子類ReentrantLock、CountDownLatch、Semaphore、CyclicBarrier負責實作具體的加鎖、釋放鎖邏輯，

這不是個面試知識點嗎？

面試官再問你，你看過哪些框架原始碼使用到了設計模式？

你就可以回答AQS原始碼中用到了模板模式，巴拉巴拉，妥妥的加分項！

4. AQS原始碼剖析

整個加鎖流程如下：

先看一下加鎖方法的原始碼：

4.1 加鎖

// 加鎖方法，傳參是1
public final void acquire(int arg) {
    // 1. 首先嘗試獲取鎖，如果獲取成功，則設定state+1，exclusiveOwnerThread=currentThread（留給子類實作）
    if (!tryAcquire(arg) &&
            // 2. 如果沒有獲取成功，把執行緒組裝成Node節點，追加到同步佇列末尾
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) {
        // 3. 加入同步佇列后，將自己掛起
        selfInterrupt();
    }
}

再看一下addWaiter方法原始碼，作用就是把執行緒組裝成Node節點，追加到同步佇列末尾，

// 追加到同步佇列末尾，傳參是共享模式or排他模式
private Node addWaiter(Node mode) {
    // 1. 組裝成Node節點
    Node node = new Node(Thread.currentThread(), mode);
    Node pred = tail;
    if (pred != null) {
        node.prev = pred;
        // 2. 在多執行緒競爭不激烈的情況下，通過CAS方法追加到同步佇列末尾
        if (compareAndSetTail(pred, node)) {
            pred.next = node;
            return node;
        }
    }
    // 3. 在多執行緒競爭激烈的情況下，使用死回圈保證追加到同步佇列末尾
    enq(node);
    return node;
}

// 創建Node節點，傳參是執行緒，共享模式or排他模式
Node(Thread thread, Node mode) {
  	this.thread = thread;
    this.nextWaiter = mode;
}

// 通過死回圈的方式，追加到同步佇列末尾
private Node enq(final Node node) {
    for (; ; ) {
        Node t = tail;
        if (t == null) {
            if (compareAndSetHead(new Node()))
                tail = head;
        } else {
            node.prev = t;
            if (compareAndSetTail(t, node)) {
                t.next = node;
                return t;
            }
        }
    }
}

再看一下addWaiter方法外層的acquireQueued方法，作用就是：

在追加到同步佇列末尾后，再判斷一下前驅節點是不是頭節點，如果是，說明是第一個加入同步佇列的，就再去嘗試獲取鎖，
如果獲取鎖成功，就把自己設定成頭節點，
如果前驅節點不是頭節點，或者獲取鎖失敗，就逆序遍歷同步佇列，找到可以將自己喚醒的節點，
最后才放心地將自己掛起

// 追加到同步佇列末尾后，再次嘗試獲取鎖
final boolean acquireQueued(final Node node, int arg) {
    boolean failed = true;
    try {
        boolean interrupted = false;
        for (; ; ) {
            // 1. 找到前驅節點
            final Node p = node.predecessor();
            // 2. 如果前驅節點是頭結點，就再次嘗試獲取鎖
            if (p == head && tryAcquire(arg)) {
                // 3. 獲取鎖成功后，把自己設定為頭節點
                setHead(node);
                p.next = null;
                failed = false;
                return interrupted;
            }
            // 4. 如果還是沒有獲取到鎖，找到可以將自己喚醒的節點
            if (shouldParkAfterFailedAcquire(p, node) &&
                    // 5. 最后才放心地將自己掛起
                    parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

再看一下shouldParkAfterFailedAcquire方法，是怎么找到將自己喚醒的節點的？為什么要找這個節點？

// 加入同步佇列后，找到能將自己喚醒的節點
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    int ws = pred.waitStatus;
    // 1. 如果前驅節點的狀態已經是SIGNAL狀態（釋放鎖后，需要喚醒后繼節點），就無需操作了
    if (ws == Node.SIGNAL)
        return true;
    // 2. 如果前驅節點的狀態是已取消，就繼續向前遍歷
    if (ws > 0) {
        do {
            node.prev = pred = pred.prev;
        } while (pred.waitStatus > 0);
        pred.next = node;
    } else {
        // 3. 找到了不是取消狀態的節點，把該節點狀態設定成SIGNAL
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
    }
    return false;
}

從代碼中可以很清楚的看到，目的就是為了找到不是取消狀態的節點，并把該節點的狀態設定成SIGNAL，

狀態是SIGNAL的節點，釋放鎖后，需要喚醒其后繼節點，

簡單理解就是：小弟初來乍到，特意來知會老大一聲，有好事，多通知小弟，

再看一下釋放鎖的邏輯，

4.2 釋放鎖

釋放鎖的流程如下：

釋放鎖的代碼邏輯比較簡單：

// 釋放鎖
public final boolean release(int arg) {
    // 1. 先嘗試釋放鎖，如果時候成功，則設定state-1，exclusiveOwnerThread=null（由子類實作）
    if (tryRelease(arg)) {
        Node h = head;
        // 2. 如果同步佇列中還有其他節點，就喚醒下一個節點
        if (h != null && h.waitStatus != 0)
            // 3. 喚醒其后繼節點
            unparkSuccessor(h);
        return true;
    }
    return false;
}

再看一下喚醒后繼節點的方法

// 喚醒后繼節點
private void unparkSuccessor(Node node) {
    int ws = node.waitStatus;
    // 1. 如果頭節點不是取消狀態，就重置成初始狀態
    if (ws < 0)
        compareAndSetWaitStatus(node, ws, 0);

    Node s = node.next;
    // 2. 如果后繼節點是null或者是取消狀態
    if (s == null || s.waitStatus > 0) {
        s = null;
        // 3. 從隊尾開始遍歷，找到一個有效狀態的節點
        for (Node t = tail; t != null && t != node; t = t.prev)
            if (t.waitStatus <= 0)
                s = t;
    }
    // 3. 喚醒這個有效節點
    if (s != null)
        LockSupport.unpark(s.thread);
}

4.3 await等待

await等待的流程：

持有鎖的執行緒可以呼叫await方法，作用是：釋放鎖，并追加到條件佇列末尾，

// 等待方法
public final void await() throws InterruptedException {
    // 如果執行緒已中斷，則中斷
    if (Thread.interrupted())
        throw new InterruptedException();
    // 1. 追加到條件佇列末尾
    Node node = addConditionWaiter();
    // 2. 釋放鎖
    int savedState = fullyRelease(node);
    int interruptMode = 0;
    // 3. 有可能剛加入條件佇列就被轉移到同步佇列了，如果還在條件佇列，就可以放心地掛起自己
    while (!isOnSyncQueue(node)) {
        LockSupport.park(this);
        if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
            break;
    }
    // 4. 如果已經轉移到同步佇列，就嘗試獲取鎖
    if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
        interruptMode = REINTERRUPT;
    if (node.nextWaiter != null)
        // 5. 清除條件佇列中已取消的節點
        unlinkCancelledWaiters();
    if (interruptMode != 0)
        reportInterruptAfterWait(interruptMode);
}

再看一下addConditionWaiter方法，是怎么追加到條件佇列末尾的？

// 追加到條件佇列末尾
private Node addConditionWaiter() {
    Node t = lastWaiter;
    // 1. 清除已取消的節點，找到有效節點
    if (t != null && t.waitStatus != Node.CONDITION) {
        unlinkCancelledWaiters();
        t = lastWaiter;
    }
    // 2. 創建Node節點，狀態是-2（表示處于條件佇列）
    Node node = new Node(Thread.currentThread(), Node.CONDITION);
    // 3. 追加到條件佇列末尾
    if (t == null)
        firstWaiter = node;
    else
        t.nextWaiter = node;
    lastWaiter = node;
    return node;
}

4.4 signal喚醒

signal喚醒的流程：

喚醒條件佇列的頭節點，并追加到同步佇列末尾，

// 喚醒條件佇列的頭節點
public final void signal() {
    // 1. 只有持有鎖的執行緒才能呼叫signal方法
    if (!isHeldExclusively())
        throw new IllegalMonitorStateException();
    // 2. 找到條件佇列的頭節點
    Node first = firstWaiter;
    if (first != null)
        // 3. 開始喚醒
        doSignal(first);
}

// 實際的喚醒方法
private void doSignal(Node first) {
    do {
        // 4. 從條件佇列中移除頭節點
        if ((firstWaiter = first.nextWaiter) == null)
            lastWaiter = null;
        first.nextWaiter = null;
        // 5. 使用死回圈，一定要轉移一個節點到同步佇列
    } while (!transferForSignal(first) &&
            (first = firstWaiter) != null);
}

到底是怎么轉移到同步佇列末尾的？

// 實際轉移方法
final boolean transferForSignal(Node node) {
    // 1. 把節點狀態從CONDITION改成0
    if (!compareAndSetWaitStatus(node, Node.CONDITION, 0))
        return false;

    // 2. 使用死回圈的方式，追加到同步佇列末尾（前面已經講過）
    Node p = enq(node);
    int ws = p.waitStatus;
    // 3. 把前驅節點狀態設定SIGNAL（通知他，別忘了喚醒老弟）
    if (ws > 0 || !compareAndSetWaitStatus(p, ws, Node.SIGNAL))
        LockSupport.unpark(node.thread);
    return true;
}

5. 總結

看完整個AQS的原始碼，是不是完全理解了AQS加鎖、釋放鎖、以及同步佇列和條件佇列資料流轉的邏輯了，

連AQS這么復雜的原始碼你都搞清楚了，下篇帶你一塊學習ReentrantLock原始碼，應該就輕松多了，

我是「一燈架構」，如果本文對你有幫助，歡迎各位小伙伴點贊、評論和關注，感謝各位老鐵，我們下期見

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/531788.html

標籤：Java

上一篇：《Go 語言并發之道》讀書筆記（一）

下一篇：每日演算法題之二叉樹的深度