深入淺出AQS源碼解析

来源:https://www.cnblogs.com/pinxiong/archive/2020/07/13/13288201.html
-Advertisement-
Play Games

最近一直在研究AQS的源碼，希望可以更深刻的理解AQS的實現原理。雖然網上有很多關於AQS的源碼分析，但是看完以後感覺還是一知半解。於是，我將自己的整個理解過程記錄下來了，希望對大家有所幫助。 基本原理 AQS是Java中鎖的基礎，主要由兩個隊列組成。一個隊列是同步隊列，另一個是條件隊列。 同步隊列 ...


最近一直在研究AQS的源碼，希望可以更深刻的理解AQS的實現原理。雖然網上有很多關於AQS的源碼分析，但是看完以後感覺還是一知半解。於是，我將自己的整個理解過程記錄下來了，希望對大家有所幫助。

基本原理

AQS是Java中鎖的基礎，主要由兩個隊列組成。一個隊列是同步隊列，另一個是條件隊列。

同步隊列的原理

  • 同步隊列的隊列頭部是head，隊列尾部是tail節點，head節點是一個空節點，同步隊列是一個雙向鏈表，通過next和prev連接所有節點
  • 所有的線程在競爭鎖的時候都會創建一個Node節點，線程與節點綁定在一起，（如果是同步鎖和排他鎖不同之處是通過nextWaiter來區分的）並且添加到同步隊列的尾部
  • head的第一個節點獲取鎖，其餘節點都需要等待被喚醒
  • 同步隊列中的節點會存在取消和null的情況（如：線程超時中斷、線程更新節點的中間態），被取消和null的節點不能被喚醒，將會被視為無效節點
  • 一個線程只能被有效的前驅節點（取消和null的節點除外）喚醒
  • 持有鎖的線程只能是有一個，其他有效節點對應的線程都會被掛起

條件隊列的原理

  • 一個同步隊列可以對應多個條件隊列
  • 條件隊列是一個單向鏈表，通過nextWaiter來連接起來，條件隊列的頭節點是firstWaiter，尾節點是lastWaiter
  • 某個條件隊列中滿足條件的節點（被signal或signalAll方法喚醒的節點）才會被轉移到同步隊列
  • 條件隊列中的被轉移到同步隊列的節點是從頭節點開始，條件隊列中被阻塞的線程會添加到隊列的尾部

同步隊列的實現

首先，瞭解以下同步隊列中隊列的節點Node的數據結構

static final class Node {
        /** 共用鎖的標識 */
        static final Node SHARED = new Node();
        /** 排他鎖的標識 */
        static final Node EXCLUSIVE = null;

        /** 線程取消 */
        static final int CANCELLED =  1;
        /** 持有鎖的線程的後繼線程被掛起 */
        static final int SIGNAL    = -1;
        /** 條件隊列標識 */
        static final int CONDITION = -2;
        /**
         * 共用鎖情況下，通知所有其他節點
         */
        static final int PROPAGATE = -3;

        /**
         * waitStatus的取值如下:
         *   SIGNAL(-1): 當前節點的後繼節點應該被掛起
         *   CANCELLED(1): 當前節點被取消
         *   CONDITION(-2): 當前節點在條件隊列
         *   PROPAGATE(-3): 釋放共用鎖時需要通知所有節點
         *   0: 初始值
         *
         */
        volatile int waitStatus;

        /**
         * 前驅節點
         */
        volatile Node prev;

        /**
         * 後繼節點
         */
        volatile Node next;

        /**
         * 節點對應的線程
         */
        volatile Thread thread;

        /**
         * 在共用鎖的情況下，該節點的值為SHARED
         * 在排他鎖的情況下，該節點的值為EXCLUSIVE
         * 在條件隊列的情況下，鏈接的是下一個等待條件的線程
         */
        Node nextWaiter;
}

其次，我們來看一下同步隊列的鏈表結構
同步隊列鏈表

接著，我們根據同步隊列的原理來分析以下acquire和release需要做哪些事情：

實現acquire功能需要做的事情

  1. 創建一個Node節點node（該節點可能是排他鎖，也可以能是共用鎖）
  2. 將node添加到同步隊列尾部，如果同步隊列為空（初始情況下），需要先創建一個空的頭節點，然後再添加到隊列的尾部
  3. 如果node的前驅節點是head，說明node是第一個節點，能夠獲取鎖，需要將head修改成node，釋放前驅節點的資源
  4. 如果node的前驅節點不是head，說明獲取鎖失敗，需要檢測是否需要將node綁定的線程掛起，分以下幾種情況：
    • 如果node的waitStatus已經被設置為SIGNAL 表示需要被掛起
    • 如果node的waitStatus設置為CANCEL表示該節點已經被取消，需要被去掉，並修改 node的prev，直到鏈接上一個有效的節點為止
    • 否則將node的waitStatus設置為SIGNAL，表示即將要被掛起
  5. 如果需要將node綁定的線程掛起，則讓出CPU，直到當前驅節點來喚起node才會開始繼續從步驟3開始執行

與acquire功能相關的代碼

  • acquire方法：獲取排他鎖
public final void acquire(int arg) {
        if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }

  1. tryAcquire(arg)：對外提供的一個擴展方法，常用的鎖都要實現這個方法，具體實現與鎖相關

  2. addWaiter(Node.EXCLUSIVE)： 創建一個排他鎖節點，並將該節點添加到同步隊列尾部，代碼如下：

private Node addWaiter(Node mode) {
        // 創建一個node，EXCLUSIVE類型
        Node node = new Node(mode);

        for (;;) {
            // 獲取尾節點
            Node oldTail = tail;
            if (oldTail != null) {
                // 設置即將成為尾節點的前驅
                node.setPrevRelaxed(oldTail);
                // CAS操作設置尾節點
                if (compareAndSetTail(oldTail, node)) {
                    // 將新尾節點的前驅節點與新的尾節點關聯起來
                    oldTail.next = node;
                    // 返回添加的節點
                    // 這個節點現在不一定是尾節點，因為如果有多個線程調用這個方法時，
                    // 可能還有節點添加在這個節點後面
                    return node;
                }
            } else {
                // 如果隊列為空，初始化頭節點
                initializeSyncQueue();
            }
        }
    }
  1. acquireQueued：同步隊列中的節點獲取排他鎖
final boolean acquireQueued(final Node node, int arg) {
        try {
            // 線程是否中斷
            boolean interrupted = false;
            for (;;) {
                // 獲取前驅節點
                final Node p = node.predecessor();
                // 如果前驅節點是頭節點，獲取鎖
                if (p == head && tryAcquire(arg)) {
                    // 修改頭節點
                    setHead(node);
                    // 釋放頭節點的資源
                    p.next = null; // help GC
                    // 返回線程中斷的狀態
                    // 這也是該方法唯一的返回值
                    // 沒有獲取鎖的線程會一直執行該方法直到獲取鎖以後再返回
                    return interrupted;
                }
                // 獲取鎖失敗後是否需要將線程掛起
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt()) // 線程掛起並返回是否被中斷
                    interrupted = true;
            }
        } catch (Throwable t) {
            // 取消該節點
            cancelAcquire(node);
            throw t;
        }
    }
  1. shouldParkAfterFailedAcquire：檢測線程獲取鎖失敗以後是否需要被掛起
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
        // 前驅節點的狀態
        int ws = pred.waitStatus;
        if (ws == Node.SIGNAL)
            /*
             * 狀態已經設置成SIGNAL，可以直接掛起該節點
             */
            return true;
        // 節點被取消
        if (ws > 0) {
            /*
             * 找到pred第一個有效的前驅節點
             */
            do {
                node.prev = pred = pred.prev;
            } while (pred.waitStatus > 0);
            // pred可能是一個新的節點，需要將pred的next重寫設置為node
            pred.next = node;
        } else {
            /*
             * CAS操作將pred節點的狀態設置為SIGNAL
             */
            pred.compareAndSetWaitStatus(ws, Node.SIGNAL);
        }
        // 只有當pred節點的waitStatus已經是SIGNAL狀態時，才可以安全的掛起線程
        // 否則需要不能被掛起
        return false;
    }
  1. parkAndCheckInterrupt：將當前線程掛起，並檢測當前線程是否中斷
private final boolean parkAndCheckInterrupt() {
        // 線程掛起
        LockSupport.park(this);
        // 檢測線程是否中斷
        return Thread.interrupted();
    }
  1. cancelAcquire：取消節點
 private void cancelAcquire(Node node) {
        // 如果節點為空，什麼都不做
        if (node == null)
            return;
        // 釋放線程
        node.thread = null;

        // 從後往前過濾掉所有的被取消的節點
        Node pred = node.prev;
        while (pred.waitStatus > 0)
            node.prev = pred = pred.prev;

        // 有效前驅節點的nex節點
        Node predNext = pred.next;

        // 將node設置為CANCELLED
        node.waitStatus = Node.CANCELLED;

        // 如果是尾節點，設置新的尾節點
        if (node == tail && compareAndSetTail(node, pred)) {
            // 將新的尾節點的後續設置為null
            pred.compareAndSetNext(predNext, null);
        } else {
            // If successor needs signal, try to set pred's next-link
            // so it will get one. Otherwise wake it up to propagate.
            int ws;
            // 如果前驅節點的線程不為null並且waitStatus為SIGNAL
            if (pred != head &&
                ((ws = pred.waitStatus) == Node.SIGNAL ||
                 (ws <= 0 && pred.compareAndSetWaitStatus(ws, Node.SIGNAL))) &&
                pred.thread != null) {
                Node next = node.next;
                // 將node設置成pred的後繼節點
                if (next != null && next.waitStatus <= 0)
                    pred.compareAndSetNext(predNext, next);
            } else {
                // 喚起node節點的後繼節點
                // 因為node節點已經釋放鎖了
                unparkSuccessor(node);
            }

            node.next = node; // help GC
        }
    }
  1. unparkSuccessor：喚醒後繼節點
private void unparkSuccessor(Node node) {
        /*
         * 獲取node節點的waitStatus
         */
        int ws = node.waitStatus;
       // 用CSA操作將waitStatus設置成初始狀態
       // 不管設置是否成功，都無所謂，因為該節點即將被銷毀
        if (ws < 0)
            node.compareAndSetWaitStatus(ws, 0);
        /*
         * 獲取node的後繼節點
         */
        Node s = node.next;
        // 如果後繼節點為null或者被取消，
        // 通過從同步隊列的尾節點開始一直往前找到一個有效的後繼節點
        if (s == null || s.waitStatus > 0) {
            s = null;
            for (Node p = tail; p != node && p != null; p = p.prev)
                if (p.waitStatus <= 0)
                    s = p;
        }
        // 如果後繼節點不為空
        if (s != null)
            LockSupport.unpark(s.thread);// 喚醒後繼節點的線程
    }

與acquire方法類似的還有acquireInterruptibly、tryAcquireNanos、acquireShared、acquireSharedInterruptibly和tryAcquireSharedNanos，我們都一一分析以下

  • acquireInterruptibly方法：獲取可中斷的排他鎖
public final void acquireInterruptibly(int arg)
            throws InterruptedException {
        if (Thread.interrupted()) // 如果線程中斷，直接返回
            throw new InterruptedException();
        if (!tryAcquire(arg))
            doAcquireInterruptibly(arg); // 中斷式的獲取鎖
    }
  1. doAcquireInterruptibly：可中斷式的獲取鎖
private void doAcquireInterruptibly(int arg)
        throws InterruptedException {
       // 創建一個排他節點加入同步隊列
        final Node node = addWaiter(Node.EXCLUSIVE);
        try {
            for (;;) {
                // 獲取前驅節點
                final Node p = node.predecessor();
                // 如果前驅節點是頭節點，說明已經獲取的鎖
                if (p == head && tryAcquire(arg)) {
                    // 修改頭節點
                    setHead(node);
                    p.next = null; // help GC
                    return;
                }
                // 如果沒有獲取鎖，檢測是否需要掛起
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    throw new InterruptedException(); // 如果發現線程已經被中斷，需要拋出異常
            }
        } catch (Throwable t) {
            // 發生異常取消節點
            cancelAcquire(node);
            throw t;
        }
    }
  • tryAcquireNanos方法：超時中斷獲取排他鎖
public final boolean tryAcquireNanos(int arg, long nanosTimeout)
            throws InterruptedException {
        if (Thread.interrupted())
            throw new InterruptedException(); // 線程中斷直接返回
        return tryAcquire(arg) ||
            doAcquireNanos(arg, nanosTimeout); // 超時獲取排他鎖
    }
  1. doAcquireNanos：超時獲取排他鎖
private boolean doAcquireNanos(int arg, long nanosTimeout)
            throws InterruptedException {
        // 如果超時直接返回
        if (nanosTimeout <= 0L)
            return false;
        // 獲取超時時長
        final long deadline = System.nanoTime() + nanosTimeout;
        // 添加一個排他節點到同步隊列尾部
        final Node node = addWaiter(Node.EXCLUSIVE);
        try {
            for (;;) {
                 // 獲取前驅節點
                final Node p = node.predecessor();
                // 已經獲取鎖
                if (p == head && tryAcquire(arg)) {
                    setHead(node);
                    p.next = null; // help GC
                    return true;
                }
                nanosTimeout = deadline - System.nanoTime();
                // 如果超時了就取消
                if (nanosTimeout <= 0L) {
                    cancelAcquire(node);
                    return false;
                }
                // 檢測節點是否需要被掛起
                if (shouldParkAfterFailedAcquire(p, node) &&
                    nanosTimeout > SPIN_FOR_TIMEOUT_THRESHOLD)
                    // 如果需要掛起，且超時時長大於SPIN_FOR_TIMEOUT_THRESHOLD
                    // 線程掛起nanosTimeout時間
                    LockSupport.parkNanos(this, nanosTimeout); 
                if (Thread.interrupted())
                    throw new InterruptedException();
            }
        } catch (Throwable t) {
            // 發生異常取消節點
            cancelAcquire(node);
            throw t;
        }
    }
  • acquireShared方法：獲取共用鎖
public final void acquireShared(int arg) {
        // 對外提供的一個擴展方法，常用的鎖都要實現這個方法，
        // 該方法的實現與鎖的用途有關
        if (tryAcquireShared(arg) < 0) 
            doAcquireShared(arg); // 獲取共用鎖
    }
  1. doAcquireShared：獲取共用鎖
 private void doAcquireShared(int arg) {
        // 添加一個共用節點到同步隊列尾部
        final Node node = addWaiter(Node.SHARED);
        try {
            boolean interrupted = false;
            for (;;) {
                // 獲取前驅節點
                final Node p = node.predecessor();
                if (p == head) {
                    // 返回結果大於等於0表示獲取共用鎖
                    int r = tryAcquireShared(arg);
                    if (r >= 0) {
                        // 設置頭節點並廣播通知其他獲取共用鎖的節點
                        setHeadAndPropagate(node, r);
                        p.next = null; // help GC
                        // 如果線程被中斷，將該線程中斷
                        // 共用鎖會被多個線程獲取，如果需要中斷
                        // 所有獲取共用鎖的線程都要被中斷
                        if (interrupted)
                            selfInterrupt();
                        return;
                    }
                }
                // 檢測是否需要掛起
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt()) // 掛起並中斷
                    interrupted = true;
            }
        } catch (Throwable t) {
            // 發生異常取消節點
            cancelAcquire(node);
            throw t;
        }
    }
  1. setHeadAndPropagate：設置頭節點並廣播其他節點來獲取鎖
 private void setHeadAndPropagate(Node node, int propagate) {
        Node h = head; // 記錄舊的頭節點
        setHead(node);// 設置新的頭節點
        /*
         * 如果頭節點為null或者是不是取消狀態，嘗試喚醒後繼節點
         */
        if (propagate > 0 || h == null || h.waitStatus < 0 ||
            (h = head) == null || h.waitStatus < 0) {
            Node s = node.next;
            // node節點的next是SHARED，即共用鎖
            if (s == null || s.isShared())
                // 喚起獲取共用鎖的線程
                doReleaseShared();
        }
    }
  1. doReleaseShared：喚醒等待共用鎖的節點
 private void doReleaseShared() {
        /*
         * 喚醒時是從頭節點開始先喚醒第一個共用節點，
         * 第一個共用節點被喚醒後會在doAcquireShared方法里繼續執行（之前就是在這個方法里被掛起的）
         * 第一個共用節點如果獲取鎖會調用setHeadAndPropagate方法修改頭節點，然後再調用doReleaseShared方法
         * 喚醒第二個共用節點，以此類推，最後把所有的共用節點都喚醒
         */
        for (;;) {
            Node h = head;
            if (h != null && h != tail) {
                // 獲取頭節點的狀態
                int ws = h.waitStatus;
                // 如果頭節點是SIGNAL，需要將狀態設置為0，表示已經即將被喚醒
                if (ws == Node.SIGNAL) {
                    if (!h.compareAndSetWaitStatus(Node.SIGNAL, 0))
                        continue;            // 如果失敗了說明有其他線程在修改頭節點，需要繼續重試
                    unparkSuccessor(h); // 喚醒頭節點的後繼節點
                }
                else if (ws == 0 &&
                         !h.compareAndSetWaitStatus(0, Node.PROPAGATE))
                    continue;                // 將頭節點狀態從0設置成PROPAGATE，如果失敗了繼續，因為也有其他獲取共用鎖的線程在更改頭節點
            }
            // 如果頭節點未改變（因為沒有後繼節點需要等待共用鎖），跳出迴圈
            if (h == head)
                break;
        }
    }
  1. selfInterrupt：中斷當前線程
static void selfInterrupt() {
    Thread.currentThread().interrupt();
}
  • acquireSharedInterruptibly方法：可中斷的獲取共用鎖
public final void acquireSharedInterruptibly(int arg)
            throws InterruptedException {
        if (Thread.interrupted())
            throw new InterruptedException(); // 如果線程被中斷拋出異常
        if (tryAcquireShared(arg) < 0)
            doAcquireSharedInterruptibly(arg); // 可中斷的方式獲取共用鎖
    }
  1. doAcquireSharedInterruptibly：可中斷的方式後去共用鎖
 private void doAcquireSharedInterruptibly(int arg)
        throws InterruptedException {
        // 添加共用鎖節點到同步隊列尾部
        final Node node = addWaiter(Node.SHARED);
        try {
            for (;;) {
                // 獲取前驅節點
                final Node p = node.predecessor();
                if (p == head) {
                    int r = tryAcquireShared(arg);
                    if (r >= 0) {
                        // 獲取共用鎖以後修改頭節點，通知其他等待共用鎖的節點
                        setHeadAndPropagate(node, r);
                        p.next = null; // help GC
                        return;
                    }
                }
                // 線程獲取共用鎖失敗後需要掛起，並且發現線程被中斷，所以拋出異常
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    throw new InterruptedException();
            }
        } catch (Throwable t) {
            // 發生異常取消節點
            cancelAcquire(node);
            throw t;
        }
    }
  • tryAcquireSharedNanos方法：超時中斷獲取共用鎖
public final boolean tryAcquireSharedNanos(int arg, long nanosTimeout)
            throws InterruptedException {
        if (Thread.interrupted()) // 線程如果中斷了，直接拋出異常
            throw new InterruptedException();
        return tryAcquireShared(arg) >= 0 ||
            doAcquireSharedNanos(arg, nanosTimeout); // 超時獲取共用鎖
    }
  1. doAcquireSharedNanos：超時的方式獲取中斷鎖
private boolean doAcquireSharedNanos(int arg, long nanosTimeout)
            throws InterruptedException {
        // 超時直接返回
        if (nanosTimeout <= 0L)
            return false;
        final long deadline = System.nanoTime() + nanosTimeout;
        // 添加共用節點到同步隊列尾部
        final Node node = addWaiter(Node.SHARED);
        try {
            for (;;) {
                // 獲取前驅節點
                final Node p = node.predecessor();
                if (p == head) {
                    int r = tryAcquireShared(arg);
                    if (r >= 0) {
                        // 獲取鎖，修改頭節點，通知所有其他等待共用鎖的節點
                        setHeadAndPropagate(node, r);
                        p.next = null; // help GC
                        return true;
                    }
                }
                nanosTimeout = deadline - System.nanoTime();
                if (nanosTimeout <= 0L) {
                    // 超時取消節點
                    cancelAcquire(node);
                    return false;
                }
                if (shouldParkAfterFailedAcquire(p, node) &&
                    nanosTimeout > SPIN_FOR_TIMEOUT_THRESHOLD)
                    // 如果需要掛起，且超時時長大於SPIN_FOR_TIMEOUT_THRESHOLD
                    // 線程掛起nanosTimeout時間
                    LockSupport.parkNanos(this, nanosTimeout);
                if (Thread.interrupted())
                    throw new InterruptedException(); // 中斷了拋出異常
            }
        } catch (Throwable t) {
            // 發生異常取消節點
            cancelAcquire(node);
            throw t;
        }
    }

實現release功能需要做的事情

  1. 釋放當前獲取鎖的線程持有的資源
  2. 喚醒有效的一個後繼節點

與release功能相關的代碼

  • release方法：釋放排他鎖
    public final boolean release(int arg) {
        if (tryRelease(arg)) {
            Node h = head;
            // 頭節點不能是一個中間態
            if (h != null && h.waitStatus != 0)
                // 喚醒後繼節點
                unparkSuccessor(h);
            return true;
        }
        return false;
    }
  • release方法：釋放共用鎖
public final boolean releaseShared(int arg) {
        if (tryReleaseShared(arg)) {
            // 釋放共用鎖，從頭節點開始一個一個的釋放
            // 如果存在多個共用節點在同步隊列時，doReleaseShared方式其實是遞歸調用
            doReleaseShared();
            return true;
        }
        return false;
    }

至此，將所有獲取鎖和釋放鎖的方法相關的源碼全部分析完

條件隊列的實現

我們來看一下條件隊列的鏈表結構
條件隊列的鏈表結構

實現await功能需要做的事情

  1. 創建一個CONDITION類型的節點，將該節點添加到條件隊列
  2. 釋放已經獲取的鎖（因為只有當前線程先獲取了鎖才可能再調用Condition.await()方法）
  3. 如果無法獲取鎖，線程掛起

與await功能相關的代碼

  • await方法：等待條件
public final void await() throws InterruptedException {
            if (Thread.interrupted())
                throw new InterruptedException(); // 如果線程中斷，直接拋出異常
            // 創建一個CONDITION類型的節點，將該節點添加到條件隊列尾部
            Node node = addConditionWaiter();
            // 釋放鎖
            // 在調用await方法之前都會調用lock方法，這個時候已經獲取鎖了
            // 有時候鎖還是可重入的，所以需要將所有的資源都釋放掉
            int savedState = fullyRelease(node);
            int interruptMode = 0;
            // 如果節點不再同步隊列，全部都要掛起
            while (!isOnSyncQueue(node)) {
                LockSupport.park(this);
                // 如果在等待期間發生過中斷（不管是調用signal之前還是之後），直接退出
                if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
                    break;
            }
            // 讓線程嘗試去獲取鎖，如果無法獲取鎖就掛起
            if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
                interruptMode = REINTERRUPT;
            // 清除所有在條件隊列中是取消狀態的節點
            if (node.nextWaiter != null) // clean up if cancelled
                unlinkCancelledWaiters();
            // 發生中斷，上報中斷情況
            if (interruptMode != 0)
                reportInterruptAfterWait(interruptMode);
        }
  1. addConditionWaiter：在條件隊列中添加一個節點
 private Node addConditionWaiter() {
            Node t = lastWaiter;
            // 清除條件隊列中無效的節點
            if (t != null && t.waitStatus != Node.CONDITION) {
                unlinkCancelledWaiters();
                t = lastWaiter;
            }
            // 創建一個節點
            Node node = new Node(Node.CONDITION);
            // 添加到條件隊列尾部
            if (t == null)
                firstWaiter = node;
            else
                t.nextWaiter = node;
            lastWaiter = node;
            return node;
        }
  1. unlinkCancelledWaiters：清除在條件隊列中被取消的節點
private void unlinkCancelledWaiters() {
            Node t = firstWaiter;
            Node trail = null;
            // 遍歷條件隊列將所有不是CONDITION狀態的節點全部清除掉
            // 這些節點都是取消狀態的節點
            while (t != null) {
                Node next = t.nextWaiter;
                if (t.waitStatus != Node.CONDITION) {
                    t.nextWaiter = null;
                    if (trail == null)
                        firstWaiter = next;
                    else
                        trail.nextWaiter = next;
                    if (next == null)
                        lastWaiter = trail;
                }
                else
                    trail = t;
                t = next;
            }
        }
  1. fullyRelease：釋放線程持有的所有鎖資源
final int fullyRelease(Node node) {
        try {
            int savedState = getState();
            // 釋放所有的資源
            // 如果是可重入鎖，savedState就是重入的次數
            if (release(savedState))
                return savedState;
            throw new IllegalMonitorStateException();
        } catch (Throwable t) {
            // 發生異常就取消該節點
            node.waitStatus = Node.CANCELLED;
            throw t;
        }
    }
  1. isOnSyncQueue：判斷節點是否在同步隊列
final boolean isOnSyncQueue(Node node) {
        // waitStatus是CONDITION或者node沒有前驅節點，說明node不在同步隊列
        if (node.waitStatus == Node.CONDITION || node.prev == null)
            return false;
        if (node.next != null) // 有後繼節點一定在同步隊列
            return true;
        /*
         * 在同步隊列中查找node，看是否在同步隊列中
         */
        return findNodeFromTail(node);
    }
  1. findNodeFromTail：在同步隊列中查找節點
private boolean findNodeFromTail(Node node) {
        // 從尾節點開始查找
        for (Node p = tail;;) {
            if (p == node) // 找到了
                return true;
            if (p == null) // 找到頭了還沒找到
                return false;
            p = p.prev;
        }
    }
  1. checkInterruptWhileWaiting：檢測中斷的情況
private int checkInterruptWhileWaiting(Node node) {
            // 沒有發生中斷返回0
            // 調用signal之前發生中斷返回THROW_IE
            // 調用signal之後發生中斷返回REINTERRUPT
            return Thread.interrupted() ?
                (transferAfterCancelledWait(node) ? THROW_IE : REINTERRUPT) :
                0;
        }
  1. transferAfterCancelledWait：清除在條件隊列中被取消的節點
// 只有線程處於中斷狀態，才會調用此方法
// 如果需要的話，將這個已經取消等待的節點轉移到阻塞隊列
// 返回 true，如果此線程在 signal 之前被取消，否則返回false
final boolean transferAfterCancelledWait(Node node) {
  
        // 用 CAS 將節點狀態設置為 0 
        // 如果這步 CAS 成功，說明是 signal 方法之前發生的中斷，
       // 因為如果 signal 先發生的話，signal 中會將 waitStatus 設置為 0
        if (node.compareAndSetWaitStatus(Node.CONDITION, 0)) {
            enq(node); // 將節點放入阻塞隊列
            return true;
        }
        // 到這裡是因為 CAS 失敗，肯定是因為 signal 方法已經將 waitStatus 設置為了 0
        // signal 方法會將節點轉移到阻塞隊列，但是可能還沒完成，這邊自旋等待其完成
        // 當然，這種事情還是比較少的吧：signal 調用之後，沒完成轉移之前，發生了中斷
        while (!isOnSyncQueue(node))
            Thread.yield();
        return false;
    }
  1. enq：把節點添加到同步隊列
private Node enq(Node node) {
        // 無限迴圈，將節點添加到同步隊列尾部
        for (;;) {
            Node oldTail = tail;
            if (oldTail != null) {
                node.setPrevRelaxed(oldTail);
                if (compareAndSetTail(oldTail, node)) {
                    oldTail.next = node;
                    return oldTail;
                }
            } else {
                // 如果同步隊列為空，初始化
                initializeSyncQueue();
            }
        }
    }
  1. reportInterruptAfterWait：中斷處理
private void reportInterruptAfterWait(int interruptMode)
            throws InterruptedException {
            // 如果是THROW_IE狀態，拋異常
            if (interruptMode == THROW_IE)
                throw new InterruptedException();
            else if (interruptMode == REINTERRUPT) // 再次中斷，因為中斷狀態被使用過一次
                selfInterrupt();
        }

awaitNanos、awaitUntil和await(long time, TimeUnit unit)這幾個方法的整體邏輯是一樣的，就不再分析了

實現signal功能需要做的事情

  1. 將條件隊列中的節點加入同步隊列
  2. 喚醒線程

與signal功能相關的代碼

  • signal方法：喚醒等待條件的節點
 public final void signal() {
            if (!isHeldExclusively())
                throw new IllegalMonitorStateException();
            // 獲取條件隊列中的第一個節點
            Node first = firstWaiter;
            if (first != null)
                // 喚醒等待條件的節點
                doSignal(first); 
        }
  1. doSignal：喚醒等待條件的節點
private void doSignal(Node first) {
            do {
                // 去掉無效的節點
                if ( (firstWaiter = first.nextWaiter) == null)
                    lastWaiter = null;
                first.nextWaiter = null;
            } while (!transferForSignal(first) &&  // 將節點轉移到同步隊列
                     (first = firstWaiter) != null);
        }
  1. transferForSignal：將節點轉移到同步隊列
final boolean transferForSignal(Node node) {
        /*
         * 取消的節點不需要轉移
         */
        if (!node.compareAndSetWaitStatus(Node.CONDITION, 0))
            return false;

        /*
         * 將節點加入同步隊列尾部
         */
        Node p = enq(node);
        int ws = p.waitStatus;
        // ws > 0 說明 node 在阻塞隊列中的前驅節點取消了等待鎖，直接喚醒 node 對應的線程
        // 如果 ws <= 0, 那麼 compareAndSetWaitStatus 將會被調用
        // 節點入隊後，需要把前驅節點的狀態設為SIGNAL
        if (ws > 0 || !p.compareAndSetWaitStatus(ws, Node.SIGNAL))
            // 如果前驅節點取消或者 CAS 失敗，會進到這裡喚醒線程
            LockSupport.unpark(node.thread);
        return true;
    }
  • signalAlll方法：喚醒所有等待條件的節點
public final void signalAll() {
            // 如果是當前線程
            if (!isHeldExclusively())
                throw new IllegalMonitorStateException();
            Node first = firstWaiter;
            if (first != null)
                // 喚醒所有等待條件的節點
                doSignalAll(first);
        }
  1. doSignalAll：喚醒所有等待條件的節點
// 將所有的節點都轉移到同步隊列
private void doSignalAll(Node first) {
            lastWaiter = firstWaiter = null;
            do {
                Node next = first.nextWaiter;
                first.nextWaiter = null;
                transferForSignal(first);
                first = next;
            } while (first != null);
        }

現在將與AQS相關的核心代碼都整理了一遍，裡面如果有描述不清晰或者不准確的地方希望大家可以幫忙指出！


您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • uni-app平臺判斷 | uni app判斷h5 小程式 app 等不同平臺
    推薦使用條件編譯，少用條件判斷 // @/utils/EPlatform.ts/**枚舉EPlatform*/ export enum EPlatform { /**App*/ AppPlus = 'APP-PLUS', /**App nvue*/ AppPlusNvue = 'APP-PLUS-N ...
  • JavaScript 監聽組合按鍵
    JavaScript監聽組合按鍵 by:授客 QQ：1033553122 1. 思路 如圖，通過監聽並列印鍵盤keydown事件，得到圖示內容，觀察發現， 當按下的組合鍵包含Ctrl鍵時，ctrlKey鍵會顯示為true; 當按下的組合鍵包含Shift鍵、或者按鍵之前開啟大寫時，shiftkey鍵會 ...
  • Vue 基於vue-codemirror實現的代碼編輯器
    基於vue-codemirror實現的代碼編輯器 開發環境 jshint 2.11.1 jsonlint 1.6.3 script-loader 0.7.2 vue 2.6.11 vue-codemirror 4.0.6 element-ui 2.13.1 （使用到element-ui messag ...
  • 結合絕對定位\相對定位\固定定位寫一個奧運五環案例
    實現功能： 當滑動頁面時，奧運五環固定在中間。 涉及到的知識： 相對定位、絕對定位、固定定位、z-index、border-radius 關鍵知識點： 1、絕對定位和相對定位的區別： position: absolute; 脫離原來位置進行定位；定位的參照物是離自己最近的有定位的父級，參照最近的有定 ...
  • 函數防抖和節流
    函數防抖和節流都是對高頻動作觸發回調函數的一個優化，實現方式上有類似之處。先從使用場景做個區分。 防抖使用場景： 表單輸入框校驗 提交按鈕避免重覆提交 節流使用場景： scroll,mousemove,resize等 函數防抖（debounce） 表單輸入框校驗在用戶不停的打字輸入時並不需要向後臺校 ...
  • 尤雨溪在 vue3.0 beta 上推薦的 no webpack 小工具 vite
    前言 在4月21日晚，Vue作者尤雨溪在嗶哩嗶哩直播分享了Vue.js 3.0 Beta最新進展。 裡面尤大大所提到他最近在做的這個小工具 vite ,一個實驗性的no build的vue開發伺服器。(這個小工具可以支持熱更新,且不用預編譯) 一丶安裝 命令行複製以下 mkdir vue-vite  ...
  • 二叉樹數組實現
    1 #include <stdio.h> 2 3 void createbtree(int *btree,int *data,int len) 4 { 5 int level; //樹的層數 6 int i; 7 8 btree[1] = data[1]; //創建根節點 9 for( i = 2; ...
  • python virtualenv虛擬環境配置與使用
    python virtualenv虛擬環境配置與使用 By：賴富玉 QQ：1033553122 概述 python開發過程中，我們可能需要同時開發多款應用，這些應用可能公用同一個版本的Python程式，但是使用不同版本的第三方庫，比如A應用使用six 1.12.0，而B應用需要使用six 1.15. ...
一周排行
    -Advertisement-
    Play Games
  • 移動開發（一）：使用.NET MAUI開發第一個安卓APP
    移動開發（一）：使用.NET MAUI開發第一個安卓APP 對於工作多年的C#程式員來說，近來想嘗試開發一款安卓APP，考慮了很久最終選擇使用.NET MAUI這個微軟官方的框架來嘗試體驗開發安卓APP，畢竟是使用Visual Studio開發工具，使用起來也比較的順手，結合微軟官方的教程進行了安卓 ...
  • wpf ToggleButton選中效果和一個登錄界面
    前言 QuestPDF 是一個開源 .NET 庫，用於生成 PDF 文檔。使用了C# Fluent API方式可簡化開發、減少錯誤並提高工作效率。利用它可以輕鬆生成 PDF 報告、發票、導出文件等。 項目介紹 QuestPDF 是一個革命性的開源 .NET 庫，它徹底改變了我們生成 PDF 文檔的方 ...
  • 彈幕樹洞項目功能新增篇
    項目地址 項目後端地址： https://github.com/ZyPLJ/ZYTteeHole 項目前端頁面地址： ZyPLJ/TreeHoleVue (github.com) https://github.com/ZyPLJ/TreeHoleVue 目前項目測試訪問地址： http://tree ...
  • 第27篇 sqlserver2022詳細安裝步驟
    話不多說，直接開乾 一.下載 1.官方鏈接下載： https://www.microsoft.com/zh-cn/sql-server/sql-server-downloads 2.在下載目錄中找到下麵這個小的安裝包 SQL2022-SSEI-Dev.exe，運行開始下載SQL server； 二. ...
  • .NET 開源高性能 MQTT 類庫
    前言 隨著物聯網（IoT）技術的迅猛發展，MQTT（消息隊列遙測傳輸）協議憑藉其輕量級和高效性，已成為眾多物聯網應用的首選通信標準。 MQTTnet 作為一個高性能的 .NET 開源庫，為 .NET 平臺上的 MQTT 客戶端與伺服器開發提供了強大的支持。 本文將全面介紹 MQTTnet 的核心功能 ...
  • Serilog文檔翻譯系列（六） - 可用的接收器、增強器、格式化輸出
    Serilog支持多種接收器用於日誌存儲，增強器用於添加屬性，LogContext管理動態屬性，支持多種輸出格式包括純文本、JSON及ExpressionTemplate。還提供了自定義格式化選項，適用於不同需求。 ...
  • 警惕 Visual Studio 屬性求值副作用導致邏輯不符合預期
    目錄簡介獲取 HTML 文檔解析 HTML 文檔測試參考文章 簡介 動態內容網站使用 JavaScript 腳本動態檢索和渲染數據，爬取信息時需要模擬瀏覽器行為，否則獲取到的源碼基本是空的。 本文使用的爬取步驟如下： 使用 Selenium 獲取渲染後的 HTML 文檔 使用 HtmlAgility ...
  • [使用目前最新版]HybridCLR6.9.0+YooAsset2.2.4實現純C# Unity熱更新方案 (一)
    1.前言 什麼是熱更新 游戲或者軟體更新時，無需重新下載客戶端進行安裝，而是在應用程式啟動的情況下，在內部進行資源或者代碼更新 Unity目前常用熱更新解決方案 HybridCLR，Xlua，ILRuntime等 Unity目前常用資源管理解決方案 AssetBundles，Addressable， ...
  • 在 ASP.NET Core Web API 中使用操作篩選器統一處理通用操作
    本文章主要是在C# ASP.NET Core Web API框架實現向手機發送驗證碼簡訊功能。這裡我選擇是一個互億無線簡訊驗證碼平臺，其實像阿裡雲，騰訊雲上面也可以。 首先我們先去 互億無線 https://www.ihuyi.com/api/sms.html 去註冊一個賬號 註冊完成賬號後，它會送 ...
  • 第28篇 如何.net中實現高效可靠數據同步api
    通過以下方式可以高效，並保證數據同步的可靠性 1.API設計 使用RESTful設計，確保API端點明確，並使用適當的HTTP方法（如POST用於創建，PUT用於更新）。 設計清晰的請求和響應模型，以確保客戶端能夠理解預期格式。 2.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類