AbstractQueuedSynchronizer（AQS）這個抽象類，是Java併發包 java.util.concurrent 的基礎工具類，是實現 ReentrantLock、CountDownLatch、Semaphore、FutureTask 等類的基礎。

一、CLH同步佇列

AQS通過內建的FIFO同步佇列來完成資源獲取執行緒的排隊工作。

如果當前執行緒獲取同步狀態失敗（鎖）時，AQS則會將當前執行緒以及等待狀態等資訊構造成一個節點（Node）並將其加入同步佇列，同時會park當前執行緒；

當同步狀態釋放時，則會把節點中的執行緒喚醒，使其再次嘗試獲取同步狀態。

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;// 當前node的後繼節點對應的執行緒需要被喚醒(表示後繼節點的狀態)
    static final int CONDITION = -2;// 當前節點執行緒狀態 0-沒有獲得鎖 >0-執行緒取消了等待
    volatile
 
 int waitStatus;
    volatile Node prev;
    volatile Node next;
    volatile Thread thread;// 每一個節點對應一個執行緒
    Node nextWaiter;// 共享模式/獨佔模式
}

入列：

    private Node addWaiter(Node mode) {
        Node node = new Node(Thread.currentThread(), mode);
        Node pred = tail;
        if (pred != null) {// 加入隊尾
 

            node.prev = pred;
            if (compareAndSetTail(pred, node)) {// 失敗:其它執行緒搶先入列了
                pred.next = node;
                return node;
            }
        }
        enq(node);
        return node;
    }
    
    private Node enq(final Node node) {
        for (;;) {// 迴圈入列，直到成功
            Node t = tail;
            if (t == null) {// 初始化head
                if (compareAndSetHead(new Node()))
                    tail = head;
            } else {
                node.prev = t;
                if (compareAndSetTail(t, node)) {// 失敗:其它執行緒搶先入列了
                    t.next = node;
                    return t;
                }
            }
        }
    }

兩個方法都是通過一個CAS方法compareAndSetTail(Node expect, Node update)來設定尾節點，該方法可以確保節點是執行緒安全新增的

二、屬性

    private transient volatile Node head;
    private transient volatile Node tail;
    private volatile int state;// 0代表沒有被佔用，大於0代表有執行緒持有當前鎖(鎖可以重入，每次重入都+1)
    private transient Thread exclusiveOwnerThread; // 繼承自AbstractOwnableSynchronizer 當前持有鎖的執行緒

三、主要方法

    getState()// 返回同步狀態的當前值；
    setState(int newState)// 設定當前同步狀態；
    compareAndSetState(int expect, int update)// 使用CAS設定當前狀態，該方法能夠保證狀態設定的原子性；
    
    acquire(int arg)// 獨佔式獲取同步狀態，如果當前執行緒獲取同步狀態成功，則由該方法返回，否則，將會進入同步佇列等待，該方法將會呼叫可重寫的tryAcquire(int arg)方法；
    acquireInterruptibly(int arg)// 與acquire(int arg)相同，但是該方法響應中斷，當前執行緒為獲取到同步狀態而進入到同步佇列中，如果當前執行緒被中斷，則該方法會丟擲InterruptedException異常並返回；
    tryAcquireNanos(int arg,long nanos)// 超時獲取同步狀態，如果當前執行緒在nanos時間內沒有獲取到同步狀態，那麼將會返回false，已經獲取則返回true；
    acquireShared(int arg)// 共享式獲取同步狀態，如果當前執行緒未獲取到同步狀態，將會進入同步佇列等待，與獨佔式的主要區別是在同一時刻可以有多個執行緒獲取到同步狀態；
    acquireSharedInterruptibly(int arg)// 共享式獲取同步狀態，響應中斷；
    tryAcquireSharedNanos(int arg, long nanosTimeout)// 共享式獲取同步狀態，增加超時限制；
    release(int arg)// 獨佔式釋放同步狀態，該方法會在釋放同步狀態之後，將同步佇列中第一個節點包含的執行緒喚醒；
    releaseShared(int arg)// 共享式釋放同步狀態；
    
    tryAcquire(int arg)// 獨佔式獲取同步狀態；通過子類重寫實現
    tryRelease(int arg)// 獨佔式釋放同步狀態；通過子類重寫
    tryAcquireShared(int arg)// 共享式獲取同步狀態；子類重寫
    tryReleaseShared(int arg)// 共享式釋放同步狀態；子類重寫

四、以獨佔鎖為例解析AQS（共享鎖幾乎一樣）

AQS的設計模式採用的模板方法模式，子類通過繼承的方式，實現它的抽象方法來管理同步狀態，對於子類而言它並沒有太多的活要做，AQS提供了大量的模板方法來實現同步。

獨佔式同步狀態獲取

   public final void acquire(int arg) {
        if (!tryAcquire(arg) && // 嘗試獲取鎖-由子類重寫
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) // 獲取鎖失敗: addWaiter()-當前執行緒new Node+入列; acquireQueued()-設定前驅節點狀態-1，當前執行緒park()
            selfInterrupt();
    }
    
    /**    
     * 1.嘗試獲取鎖  獲取成功，將當前節點置為頭結點
     * 2.獲取鎖失敗，將前驅節點狀態置為-1，當前節點執行緒park()等待
     * 3.前驅點釋放鎖時，會將當前節點unpark()，繼續自旋獲取鎖
     */
    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)) { // 前驅節點是head時，當前節點才能請求鎖（請求鎖的是第二個節點）
                    setHead(node); // 當前執行緒獲取到鎖之後，將當前節點置為頭結點
                    p.next = null;
                    failed = false;
                    return interrupted;
                }
                
                if (shouldParkAfterFailedAcquire(p, node) &&
                        parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }
    
    /**
     * 1.park開頭的方法來阻塞當前執行緒，unpark(Thread thread)方法來喚醒一個被阻塞的線
     * 2.前驅點 waitStatus==-1，當前節點執行緒才能park
     * 3.ws>0表示已經獲取過鎖，從CLH佇列刪除，CLH佇列存放沒有獲取到鎖被掛起的執行緒節點
     * 4.當前執行緒沒有獲取到鎖，需要設定前驅節點狀態為-1，這樣當前節點執行緒才能park()
     */
    private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
        int ws = pred.waitStatus; // 前驅節點 
        if (ws == Node.SIGNAL) // 當前節點執行緒可以park
            return true;
        if (ws > 0) { // ws>0 已經獲取過鎖,從CLH佇列刪除
            do {
                node.prev = pred = pred.prev;
            } while (pred.waitStatus > 0);
            pred.next = node;
        } else { // 需要設定前驅節點狀態為-1，這樣當前節點執行緒才能park()
            compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
        }
        return false;
    }
    
    /**
     * 當前執行緒park()等待，直到unpark()
     */
    private final boolean parkAndCheckInterrupt() {
        LockSupport.park(this);
        return Thread.interrupted();
    }
    

acquire(int arg)方法流程圖如下：

獨佔式同步狀態釋放

    public final boolean release(int arg) {
        if (tryRelease(arg)) { // 嘗試釋放鎖-由子類重寫
            Node h = head; // 頭結點佔有鎖(原因：第二節點獲取到鎖之後被置為頭結點)
            if (h != null && h.waitStatus != 0)
                unparkSuccessor(h);
            return true;
        }
        return false;
    }
    
    private void unparkSuccessor(Node node) {
        int ws = node.waitStatus;
        if (ws < 0)
            compareAndSetWaitStatus(node, ws, 0);
        Node s = node.next;
        if (s == null || s.waitStatus > 0) {
            s = null;
            // 從隊尾往前找，找到waitStatus<=0的所有節點中排在最前面的
            // 從隊尾往前找原因：node.next可能會存在null或者取消了。入列時是先設定node.prev,CAS之後再設定node.next
            for (Node t = tail; t != null && t != node; t = t.prev) 
                if (t.waitStatus <= 0)
                    s = t;
        }
        if (s != null) // 喚醒下一節點
            LockSupport.unpark(s.thread);
    }

參考資料 / 相關推薦：