我們常見的并發鎖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.cnblogs.com/yidengjiagou/p/16879681.html

硬核剖析Java鎖底層AQS源碼，深入了解底層架構設計

1. AQS加鎖流程

2. AQS的資料結構

3. AQS方法概覽

4. AQS源碼剖析

4.1 加鎖

4.2 釋放鎖

4.3 await等待

4.4 signal喚醒

5. 總結

繼續閱讀

架構師必讀書單，收藏自用

專業IT管理人才必備的十大能力

程序還是線程？是一個問題！

精通Spring 5.0：深入了解自動化配置的條件化注解

IBM Rational V7.5 架構設計産品新特性

深入了解 HDFS（二）：Replica

系統設計的套路

軟體性能——“并發使用者數”、“系統使用者數”和“同時線上使用者數”之間的差别

如何從“大公司”和“小公司”學習

軟體業人才結構

Mysql 網站大全

領域模組化實作思考

領域模組化的思想和方法

軟體設計是怎樣煉成的（5）——規劃系統的骨架（架構設計）（上篇）6.規劃系統骨架——架構設計

CAS增加驗證碼驗證功能

IBM SOA 解決方案設計師認證考試準備，第 1 部分：SOA 最佳實踐