前言

AQS 全稱 AbstractQueuedSynchronizer（抽象隊列同步器），旨在作為創建鎖和其他同步機制的基礎，常見的同步鎖 ReentrantLock、CountDownLatch、Semaphore、CyclicBarrier等都是基于 AQS 實現的。所以只有了解了AQS的實現原理，才能更好學習使用其他同步鎖。vZo28資訊網——每日最新資訊28at.com

AQS的源碼邏輯比較復雜，很多開發者看見就頭疼，邏輯眾多，無法梳理清楚。原因就是開發者梳理源碼的步驟出錯了，剛開始就看AQS的加鎖、釋放鎖邏輯，陷入細節中不能自拔。正確的做法是，先整體后局部，先框架后細節。下面就帶著大家一下分析AQS源碼，保證清晰易懂。vZo28資訊網——每日最新資訊28at.com

AQS加鎖流程

為什么一上來先看AQS的加鎖流程，先要理解AQS的框架設計，才能去看具體的源碼。vZo28資訊網——每日最新資訊28at.com

問個問題，如果讓你設計一個同步鎖，你會怎么設計？vZo28資訊網——每日最新資訊28at.com

肯定先要梳理一下需求，需求沒有梳理清楚，就別談開發了。vZo28資訊網——每日最新資訊28at.com

我理解的設計一個同步鎖，需要滿足以下需求：vZo28資訊網——每日最新資訊28at.com

1. 當多個線程競爭同一個臨界資源的時候，只有一個線程可以獲取到臨界資源，其他線程只能等待。所以這里我們需要一個狀態state用來記錄臨界資源是否被加鎖和加鎖的次數，還需要記錄一下這個資源是被哪個線程持有，字段名叫做exclusiveOwnerThread。還需要一個隊列，用來存儲等待獲取資源的線程，這個隊列我們叫做同步隊列。
2. 持有資源的線程可以主動掛起自己（調用await()方法），并且釋放鎖，然后等待被其他線程喚醒。所以這里需要一個隊列存儲需要被喚醒的線程，這個隊列我們叫做條件隊列。
3. 在條件隊列中線程被喚醒后，并不能立即獲取到鎖，還需要跟同步隊列中線程一起競爭鎖。所以在條件隊列中被喚醒的線程，需要轉移到同步隊列。

至此，我們梳理清楚了AQS的加鎖需求，而實際上AQS的加鎖流程跟上面的需求完全一致，下面用一張圖來表示。vZo28資訊網——每日最新資訊28at.com

圖片vZo28資訊網——每日最新資訊28at.com

AQS的數據結構

看一下AQS內部的架構設計和包含的屬性。vZo28資訊網——每日最新資訊28at.com

// 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，其實是為了記錄哪個線程正在占用鎖。vZo28資訊網——每日最新資訊28at.com

public abstract class AbstractOwnableSynchronizer {    // 正在占用鎖的線程    private transient Thread exclusiveOwnerThread;    // 設置占用鎖的線程    protected final void setExclusiveOwnerThread(Thread thread) {        exclusiveOwnerThread = thread;    }    protected final Thread getExclusiveOwnerThread() {        return exclusiveOwnerThread;    }}

無論是同步隊列還是條件隊列中線程都需要包裝成Node節點。vZo28資訊網——每日最新資訊28at.com

圖片vZo28資訊網——每日最新資訊28at.com

同步隊列：是帶有頭尾節點的雙鏈表，由Node節點組成，使用prev和next組成雙向鏈表，nextWaiter只用來表示是共享模式還是排他模式。條件隊列：是帶有頭尾節點的單鏈表。同樣由Node節點組成，沒有使用到Node中prev和next屬性，而是使用nextWaiter組成單鏈表。 這個復用對象的設計思想值得我們學習。 同步隊列head節點是個啞節點，里面并沒有存儲線程對象。當然head節點也可以看成是給當前持有鎖的線程使用的。 Node節點的節點狀態（waitStatus）共有5種：vZo28資訊網——每日最新資訊28at.com

• 1 cancelled：表示節點的線程已經被取消
• 0 初始化：Node節點的默認值
• -1 signal: 表示節點線程在釋放鎖后要喚醒同步隊列中的后繼節點
• -2 condition: 當前節點在條件隊列中
• -3 propagate: 釋放共享資源的時候會向后傳播釋放其他共享節點（用于共享模式）

節點狀態（waitStatus）流轉過程如下：vZo28資訊網——每日最新資訊28at.com

圖片vZo28資訊網——每日最新資訊28at.com

AQS方法概覽

AQS支持排他模式和共享模式兩種訪問資源的模式（排他模式又叫獨占模式）。 排他模式的方法：vZo28資訊網——每日最新資訊28at.com

// 加鎖acquire(int arg);// 加可中斷的鎖acquireInterruptibly(int arg);// 加鎖，帶超時時間（如果指定時間內加鎖不成功，就返回false）tryAcquireNanos(int arg, long nanosTimeout);// 釋放鎖release(int arg);

共享模式的方法：vZo28資訊網——每日最新資訊28at.com

// 加鎖acquireShared(int arg);// 加可中斷的鎖acquireSharedInterruptibly(int arg);// 加鎖，帶超時時間（如果指定時間內加鎖不成功，就返回false）tryAcquireSharedNanos(int arg, long nanosTimeout);// 釋放鎖releaseShared(int arg);

排他模式和共享模式的方法并沒有實現具體的加鎖、釋放鎖邏輯，AQS中只是定義了加鎖、釋放鎖的抽象方法。 留給子類實現的抽象方法：vZo28資訊網——每日最新資訊28at.com

public abstract class AbstractQueuedSynchronizer        extends AbstractOwnableSynchronizer        implements java.io.Serializable {    // 加排他鎖    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源碼中用到了模板模式，巴拉巴拉，妥妥的加分項！vZo28資訊網——每日最新資訊28at.com

條件隊列的方法

條件隊列中常用的方法如下：vZo28資訊網——每日最新資訊28at.com

// 等待方法，并釋放鎖public final void await() throws InterruptedException { ……}// 等待指定時間public final boolean await(long time, TimeUnit unit) throws InterruptedException { ……}// 喚醒條件隊列中的單個線程public final void signal() { ……}// 喚醒條件隊列中的所有線程public final void signalAll() { ……}

排它鎖

1. 加鎖

整個加鎖流程如下：vZo28資訊網——每日最新資訊28at.com

圖片vZo28資訊網——每日最新資訊28at.com

再看一下加鎖方法的源碼：vZo28資訊網——每日最新資訊28at.com

// 加鎖方法，傳參是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節點，追加到同步隊列末尾。vZo28資訊網——每日最新資訊28at.com

// 追加到同步隊列末尾，傳參mode表示是共享模式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;}// 通過死循環的方式，追加到同步隊列末尾private Node enq(final Node node) {    for (; ; ) {        Node t = tail;        if (t == null) {            // 如果同步隊列為空，先初始化頭節點（頭節點是空節點）            if (compareAndSetHead(new Node()))                tail = head;        } else {            // 再使用CAS追加到同步隊列末尾            node.prev = t;            if (compareAndSetTail(t, node)) {                t.next = node;                return t;            }        }    }}// 創建Node節點，傳參thread表示當前線程，mode表示共享模式or排他模式Node(Thread thread, Node mode) {   this.thread = thread;    this.nextWaiter = mode;}

再看一下addWaiter()方法外層的acquireQueued()方法，作用就是：vZo28資訊網——每日最新資訊28at.com

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

// 追加到同步隊列末尾后，再次嘗試獲取鎖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()方法，是怎么找到將自己喚醒的節點的？為什么要找這個節點？vZo28資訊網——每日最新資訊28at.com

// 加入同步隊列后，找到能將自己喚醒的節點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的節點，釋放鎖后，需要喚醒其后繼節點。 簡單理解就是：小弟初來乍到，特意來知會老大一聲，有好事，多通知小弟。 再看一下釋放鎖的邏輯。vZo28資訊網——每日最新資訊28at.com

2. 釋放鎖

釋放鎖的流程如下：vZo28資訊網——每日最新資訊28at.com

圖片vZo28資訊網——每日最新資訊28at.com

釋放鎖的代碼邏輯比較簡單：vZo28資訊網——每日最新資訊28at.com

// 釋放鎖，傳參是1，表示釋放鎖一次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;}

再看一下喚醒后繼節點的方法，作用就是重置頭節點狀態，然后找到一個有效的后繼節點并喚醒。vZo28資訊網——每日最新資訊28at.com

// 喚醒后繼節點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);}

3. await等待

await等待的流程：vZo28資訊網——每日最新資訊28at.com

圖片vZo28資訊網——每日最新資訊28at.com

持有鎖的線程可以調用await()方法，在ConditionObject類里面。作用是：釋放鎖，并追加到條件隊列末尾。vZo28資訊網——每日最新資訊28at.com

// 等待方法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方法，是怎么追加到條件隊列末尾的？vZo28資訊網——每日最新資訊28at.com

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

4. signal喚醒

signal喚醒的流程：vZo28資訊網——每日最新資訊28at.com

圖片vZo28資訊網——每日最新資訊28at.com

// 喚醒條件隊列的頭節點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);}

到底是怎么轉移到同步隊列末尾的？vZo28資訊網——每日最新資訊28at.com

// 實際轉移方法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;}

上篇文章講了AQS的架構設計和排它鎖的加鎖、釋放鎖流程，下篇文章接著講共享鎖的加鎖、釋放鎖流程。這篇文章開始講AQS的共享鎖加鎖和釋放鎖流程。vZo28資訊網——每日最新資訊28at.com

共享鎖

1. 加鎖

先看共享鎖的加鎖流程：vZo28資訊網——每日最新資訊28at.com

// 加鎖方法，傳參是1，表示加鎖一次public final void acquireShared(int arg) {    // 1. 首先嘗試獲取鎖，返回值小于0，表示獲取鎖失敗    if (tryAcquireShared(arg) < 0) {        // 2. 獲取鎖失敗后，執行的邏輯        doAcquireShared(arg);    }}// 獲取鎖失敗，執行的邏輯private void doAcquireShared(int arg) {    // 1. 把當前線程包裝成Node節點追加到同步隊列末尾（前面已經講過）    final Node node = addWaiter(Node.SHARED);    boolean failed = true;    try {        boolean interrupted = false;        for (; ; ) {            // 2. 找到前驅節點            final Node p = node.predecessor();            // 3. 如果前驅節點是頭結點，就再次嘗試獲取鎖            if (p == head) {                int r = tryAcquireShared(arg);                if (r >= 0) {                    // 3. 獲取鎖成功后，把自己設置為頭節點并向后傳播                    setHeadAndPropagate(node, r);                    p.next = null;                    // 4. 檢查中斷狀態                    if (interrupted) {                        selfInterrupt();                    }                    failed = false;                    return;                }            }            // 4. 如果獲取鎖失敗，把前驅節點狀態設置成SIGNAL，用來喚醒自己（前面講過）            if (shouldParkAfterFailedAcquire(p, node) &&                // 掛起并中斷當前線程                parkAndCheckInterrupt()) {                interrupted = true;            }        }    } finally {        // 5. 如果獲取鎖失敗，就取消當前節點        if (failed) {            cancelAcquire(node);        }    }}

看一下上面的第三步設置頭節點的邏輯，setHeadAndPropagate() 方法的作用就是：vZo28資訊網——每日最新資訊28at.com

1. 設置新的頭節點
2. 向后傳播共享鎖

這里就是共享鎖與排它鎖的區別，共享鎖的同步隊列中某個節點獲取到鎖時，會向后傳播，喚醒其他節點，也就是通知隊列中其他節點一起獲取鎖，。vZo28資訊網——每日最新資訊28at.com

// 設置頭節點，并向后傳播private void setHeadAndPropagate(Node node, int propagate) {    Node h = head;    setHead(node);    // propagate > 0 表示獲取到了共享鎖    // h == null || h.waitStatus < 0 表示當前頭節點已經不再是有效節點，可能是被取消或者已經釋放了鎖，需要進行傳播。    // 再次判斷頭節點，防止在設置頭節點的過程中發生競爭    if (propagate > 0 || h == null || h.waitStatus < 0 ||        (h = head) == null || h.waitStatus < 0) {        Node s = node.next;        // 判斷如果后繼節點為空或者是共享節點，就開始傳播共享鎖        if (s == null || s.isShared()) {            doReleaseShared();        }    }}

再看一下上面第五步，獲取鎖失敗后，取消當前節點的邏輯：vZo28資訊網——每日最新資訊28at.com

// 取消獲取鎖private void cancelAcquire(Node node) {    // 判空    if (node == null) {        return;    } // 1. 設置線程為null，不再持有鎖    node.thread = null;    // 2. 如果前驅節點是取消狀態，繼續向前遍歷，找到不是取消狀態的前驅節點    Node pred = node.prev;    while (pred.waitStatus > 0) {        node.prev = pred = pred.prev;    }    Node predNext = pred.next;    // 3. 把當前節點設置為取消狀態，不再獲取鎖    node.waitStatus = Node.CANCELLED;    // 4. 判斷如果當前節點是尾節點，就刪除當前節點    if (node == tail && compareAndSetTail(node, pred)) {        compareAndSetNext(pred, predNext, null);    } else {        // 5. 判斷后繼節點是否需要被喚醒        int ws;        if (pred != head &&            ((ws = pred.waitStatus) == Node.SIGNAL ||                (ws <= 0 && compareAndSetWaitStatus(pred, ws, Node.SIGNAL))) &&            pred.thread != null) {            Node next = node.next;            if (next != null && next.waitStatus <= 0) {                // 6. 刪除當前節點                compareAndSetNext(pred, predNext, next);            }        } else {            // 7. 喚醒后繼節點            unparkSuccessor(node);        }        node.next = node;    }}

2. 釋放鎖

看一下釋放鎖的邏輯：vZo28資訊網——每日最新資訊28at.com

// 釋放鎖，傳參是1，表示釋放鎖一次public final boolean releaseShared(int arg) {    // 先嘗試釋放鎖    if (tryReleaseShared(arg)) {        // 釋放鎖成功后，要執行的邏輯        doReleaseShared();        return true;    }    return false;}

再看一下釋放鎖成功后，要執行的 doReleaseShared() 方法的邏輯，作用是：vZo28資訊網——每日最新資訊28at.com

1. 傳播共享鎖
2. 喚醒同步隊列中線程

// 釋放鎖成功后，要執行的邏輯private void doReleaseShared() {    for (; ; ) {        Node h = head;        // 判斷是否等于尾節點，如果是尾節點，就不用傳播了        if (h != null && h != tail) {            // 判斷節點狀態，如果是SIGNAL，則需要被喚醒            int ws = h.waitStatus;            if (ws == Node.SIGNAL) {                // 重置head節點狀態，表示開始喚醒下個節點。如果重置失敗，說明發生了競爭，需要再次嘗試。                if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0)) {                    continue;                }                // 喚醒下一個節點                unparkSuccessor(h);                // 如果節點狀態是0，則需要設置成PROPAGATE，繼續傳播            } else if (ws == 0 && !compareAndSetWaitStatus(h, 0, Node.PROPAGATE)) {                continue;            }        }        // 如果頭節點沒變，表示循環中沒有進行頭節點的修改，說明已經處理完了需要喚醒的節點，可以退出循環。        if (h == head) {            break;        }    }}

本文鏈接：http://www.tebozhan.com/showinfo-26-75294-0.html沒看過AQS源碼，別說精通Java并發編程

聲明：本網頁內容旨在傳播知識，若有侵權等問題請及時與本網聯系，我們將在第一時間刪除處理。郵件：2376512515@qq.com

上一篇： Rust vs. Zig：究竟誰更勝一籌？性能、安全性等全面對決！

下一篇： 基于內存和 Redis 的兩級 Java 緩存框架