J.U.C - AQS

• getState()：返回同步狀態的當前值；
• setState(int newState)：設定當前同步狀態；
• compareAndSetState(int expect, int update)：使用CAS設定當前狀態，該方法能夠保證狀態設定的原子性；
• tryAcquire(int arg)：獨佔式獲取同步狀態，獲取同步狀態成功後，其他執行緒需要等待該執行緒釋放同步狀態才能獲取同步狀態
• tryRelease(int arg)：獨佔式釋放同步狀態；
• tryAcquireShared(int arg)：共享式獲取同步狀態，返回值大於等於0則表示獲取成功，否則獲取失敗；
• tryReleaseShared(int arg)：共享式釋放同步狀態；
• isHeldExclusively()：當前同步器是否在獨佔式模式下被執行緒佔用，一般該方法表示是否被當前執行緒所獨佔；
• 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)：共享式釋放同步狀態；

public abstract class AbstractQueuedSynchronizer extends
    AbstractOwnableSynchronizer implements java.io.Serializable { 
    //等待佇列的頭節點
    private transient volatile Node head;
    //等待佇列的尾節點
    private transient volatile Node tail;
    //同步狀態
    private volatile int state;
    protected final int getState() { return state;}
    protected final void setState(int newState) { state = newState;}
    ...
}複製程式碼

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;
    //等待狀態,這個和state是不一樣的:有1,0,-1,-2,-3五個值
    volatile int waitStatus;
    volatile Node prev;//前驅節點
    volatile Node next;//後繼節點
    volatile Thread thread;//等待鎖的執行緒
    Node nextWaiter;//和節點是否共享有關
    ...
    }複製程式碼

public final void acquire(int arg) {   
 if (!tryAcquire(arg) && acquireQueued(addWaiter(Node.EXCLUSIVE), arg))    
    selfInterrupt();
}複製程式碼

private Node addWaiter(Node mode) {
    //把當前執行緒包裝為node,設為獨佔模式
    Node node = new Node(Thread.currentThread(), mode);
    // Try the fast path of enq; backup to full enq on failure
    Node pred = tail;
    //如果tail不為空,把node插入末尾
    if (pred != null) {
        node.prev = pred;
        //此時可能有其他執行緒插入,所以重新判斷tail
        if (compareAndSetTail(pred, node)) {
            pred.next = node;
            return node;
        }
    }
    enq(node);
    return node;
}
private Node enq(final Node node) {
    for (;;) {
        Node t = tail;
        //此時可能有其他執行緒插入,所以重新判斷tail是否為空
        if (t == null) { // Must initialize
            if (compareAndSetHead(new Node()))
                tail = head;
        } else {
            node.prev = t;
            if (compareAndSetTail(t, node)) {
                t.next = node;
                return t;
            }
        }
    }
}複製程式碼

1. 如果成功獲取到鎖，表明執行緒B已經執行完成，執行緒A不需要掛起。
2. 如果獲取失敗，表示執行緒B還未完成，至少還未修改state值。進行步驟5。

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)) {
                setHead(node);
                p.next = null; // help GC
                failed = false;
                return interrupted;
            }
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}複製程式碼

1. 如果pred的waitStatus == 0，則通過CAS指令修改waitStatus為Node.SIGNAL。
2. 如果pred的waitStatus > 0，表明pred的執行緒狀態CANCELLED，需從佇列中刪除。
3. 如果pred的waitStatus為Node.SIGNAL，則通過LockSupport.park()方法把執行緒A掛起，並等待被喚醒，被喚醒後進入步驟6。

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    int ws = pred.waitStatus;
    if (ws == Node.SIGNAL)
        /*
         * This node has already set status asking a release
         * to signal it, so it can safely park.
         */
        return true;
    if (ws > 0) {
        /*
         * Predecessor was cancelled. Skip over predecessors and
         * indicate retry.
         */
        do {
            node.prev = pred = pred.prev;
        } while (pred.waitStatus > 0);
        pred.next = node;
    } else {
        /*
         * waitStatus must be 0 or PROPAGATE.  Indicate that we
         * need a signal, but don't park yet.  Caller will need to
         * retry to make sure it cannot acquire before parking.
         */
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
    }
    return false;
}複製程式碼

1. 如果頭結點head的waitStatus值為-1，則用CAS指令重置為0；
2. 找到waitStatus值小於0的節點s，通過LockSupport.unpark(s.thread)喚醒執行緒。

public final boolean release(int arg) {
    if (tryRelease(arg)) {
        Node h = head;
        if (h != null && h.waitStatus != 0)
            unparkSuccessor(h);
        return true;
    }
    return false;
}
如果node的後繼節點不為空且不是作廢狀態,則喚醒這個後繼節點,否則
從末尾開始尋找合適的節點,如果找到,則喚醒
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;
        for (Node t = tail; t != null && t != node; t = t.prev)
            if (t.waitStatus <= 0)
                s = t;
    }
    if (s != null)
        LockSupport.unpark(s.thread);
}複製程式碼