public abstract class AbstractQueuedSynchronizer
    extends AbstractOwnableSynchronizer
    implements java.io.Serializable {

// 同步器的狀態(tài)，子類會根據(jù)狀態(tài)字段進行判斷是否可以獲得鎖
// 比如 CAS 成功給 state 賦值 1 算得到鎖，賦值失敗為得不到鎖， CAS 成功給 state 賦值 0 算釋放鎖，賦值失敗為釋放失敗
// 可重入鎖，每次獲得鎖 +1，每次釋放鎖 -1
private volatile int state;
 
// 自旋超時閥值，單位納秒
// 當(dāng)設(shè)置等待時間時才會用到這個屬性
static final long spinForTimeoutThreshold = 1000L;

// 同步隊列的頭。
private transient volatile Node head;
// 同步隊列的尾
private transient volatile Node tail;

// 條件隊列，從屬性上可以看出是鏈表結(jié)構(gòu)
public class ConditionObject implements Condition, java.io.Serializable {
    private static final long serialVersionUID = 1173984872572414699L;
    // 條件隊列中第一個 node
    private transient Node firstWaiter;
    // 條件隊列中最后一個 node
    private transient Node lastWaiter;
}  

static final class Node {
    /**
     * 同步隊列單獨的屬性
     */
    //node 是共享模式
    static final Node SHARED = new Node();
    //node 是排它模式
    static final Node EXCLUSIVE = null;
    // 當(dāng)前節(jié)點的前節(jié)點
    // 節(jié)點 acquire 成功后就會變成head
    // head 節(jié)點不能被 cancelled
    volatile Node prev;
    // 當(dāng)前節(jié)點的下一個節(jié)點
    volatile Node next;
    /**
     * 兩個隊列共享的屬性
     */
    // 表示當(dāng)前節(jié)點的狀態(tài)，通過節(jié)點的狀態(tài)來控制節(jié)點的行為
    // 普通同步節(jié)點，就是 0 ，條件節(jié)點是 CONDITION -2
    volatile int waitStatus;
    // waitStatus 的狀態(tài)有以下幾種
    // 被取消
    static final int CANCELLED =  1;
    // SIGNAL 狀態(tài)的意義：同步隊列中的節(jié)點在自旋獲取鎖的時候，如果前一個節(jié)點的狀態(tài)是 SIGNAL，那么自己就可以阻塞休息了，否則自己一直自旋嘗試獲得鎖
    static final int SIGNAL    = -1;
    // 表示當(dāng)前 node 正在條件隊列中，當(dāng)有節(jié)點從同步隊列轉(zhuǎn)移到條件隊列時，狀態(tài)就會被更改成 CONDITION
    static final int CONDITION = -2;
    // 無條件傳播,共享模式下，該狀態(tài)的進程處于可運行狀態(tài)
    static final int PROPAGATE = -3;
    // 當(dāng)前節(jié)點的線程
    volatile Thread thread;
    // 在同步隊列中，nextWaiter 并不真的是指向其下一個節(jié)點，我們用 next 表示同步隊列的下一個節(jié)點，nextWaiter 只是表示當(dāng)前 Node 是排它模式還是共享模式
    // 但在條件隊列中，nextWaiter 就是表示下一個節(jié)點元素
    Node nextWaiter;
}

void await() throws InterruptedException;

// 返回的 long 值表示剩余的給定等待時間，如果返回的時間小于等于 0 ，說明等待時間過了
// 選擇納秒是為了避免計算剩余等待時間時的截斷誤差
long awaitNanos(long nanosTimeout) throws InterruptedException;
// 雖然入?yún)⒖梢允侨我鈫挝坏臅r間，但底層仍然轉(zhuǎn)化成納秒
boolean await(long time, TimeUnit unit) throws InterruptedException;

// 喚醒條件隊列中的一個線程，在被喚醒前必須先獲得鎖
void signal();
// 喚醒條件隊列中的所有線程
void signalAll();

// 排它模式下，嘗試獲得鎖
public final void acquire(int arg) {
    // tryAcquire 方法是需要實現(xiàn)類去實現(xiàn)的，實現(xiàn)思路一般都是 cas 給 state 賦值來決定是否能獲得鎖
    if (!tryAcquire(arg) &&
        // addWaiter 入?yún)⒋硎桥潘Ｊ?
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
}

// 方法主要目的：node 追加到同步隊列的隊尾
// 入?yún)?mode 表示 Node 的模式（排它模式還是共享模式）
// 出參是新增的 node
// 主要思路：
// 新 node.pre = 隊尾
// 隊尾.next = 新 node
private Node addWaiter(Node mode) {
    // 初始化 Node
    Node node = new Node(Thread.currentThread(), mode);
    // 這里的邏輯和 enq 一致，enq 的邏輯僅僅多了隊尾是空，初始化的邏輯
    // 這個思路在 java 源碼中很常見，先簡單的嘗試放一下，成功立馬返回，如果不行，再 while 循環(huán)
    // 很多時候，這種算法可以幫忙解決大部分的問題，大部分的入隊可能一次都能成功，無需自旋
    Node pred = tail;
    if (pred != null) {
        node.prev = pred;
        if (compareAndSetTail(pred, node)) {
            pred.next = node;
            return node;
        }
    }
    //自旋保證node加入到隊尾
    enq(node);
    return node;
}
// 線程加入同步隊列中方法，追加到隊尾
// 這里需要重點注意的是，返回值是添加 node 的前一個節(jié)點
private Node enq(final Node node) {
    for (;;) {
        // 得到隊尾節(jié)點
        Node t = tail;
        // 如果隊尾為空，說明當(dāng)前同步隊列都沒有初始化，進行初始化
        // tail = head = new Node();
        if (t == null) {
            if (compareAndSetHead(new Node()))
                tail = head;
        // 隊尾不為空，將當(dāng)前節(jié)點追加到隊尾
        } else {
            node.prev = t;
            // node 追加到隊尾
            if (compareAndSetTail(t, node)) {
                t.next = node;
                return t;
            }
        }
    }
}

// 主要做兩件事情：
// 1：通過不斷的自旋嘗試使自己前一個節(jié)點的狀態(tài)變成 signal，然后阻塞自己。
// 2：獲得鎖的線程執(zhí)行完成之后，釋放鎖時，會把阻塞的 node 喚醒,node 喚醒之后再次自旋，嘗試獲得鎖
// 返回 false 表示獲得鎖成功，返回 true 表示失敗
final boolean acquireQueued(final Node node, int arg) {
    boolean failed = true;
    try {
        boolean interrupted = false;
        // 自旋
        for (;;) {
            // 選上一個節(jié)點
            final Node p = node.predecessor();
            // 有兩種情況會走到 p == head：
            // 1:node 之前沒有獲得鎖，進入 acquireQueued 方法時，才發(fā)現(xiàn)他的前置節(jié)點就是頭節(jié)點，于是嘗試獲得一次鎖；
            // 2:node 之前一直在阻塞沉睡，然后被喚醒，此時喚醒 node 的節(jié)點正是其前一個節(jié)點，也能走到 if
            // 如果自己 tryAcquire 成功，就立馬把自己設(shè)置成 head，把上一個節(jié)點移除
            // 如果 tryAcquire 失敗，嘗試進入同步隊列
            if (p == head && tryAcquire(arg)) {
                // 獲得鎖，設(shè)置成 head 節(jié)點
                setHead(node);
                //p被回收
                p.next = null; // help GC
                failed = false;
                return interrupted;
            }
            // shouldParkAfterFailedAcquire 把 node 的前一個節(jié)點狀態(tài)置為 SIGNAL
            // 只要前一個節(jié)點狀態(tài)是 SIGNAL了，那么自己就可以阻塞(park)了
            // parkAndCheckInterrupt 阻塞當(dāng)前線程
            if (shouldParkAfterFailedAcquire(p, node) &&
                // 線程是在這個方法里面阻塞的，醒來的時候仍然在無限 for 循環(huán)里面，就能再次自旋嘗試獲得鎖
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        // 如果獲得node的鎖失敗，將 node 從隊列中移除
        if (failed)
            cancelAcquire(node);
    }
}

// 當(dāng)前線程可以安心阻塞的標(biāo)準(zhǔn)，就是前一個節(jié)點線程狀態(tài)是 SIGNAL 了。
// 入?yún)?pred 是前一個節(jié)點，node 是當(dāng)前節(jié)點。
// 關(guān)鍵操作：
// 1：確認(rèn)前一個節(jié)點是否有效，無效的話，一直往前找到狀態(tài)不是取消的節(jié)點。
// 2: 把前一個節(jié)點狀態(tài)置為 SIGNAL。
// 1、2 兩步操作，有可能一次就成功，有可能需要外部循環(huán)多次才能成功（外面是個無限的 for 循環(huán)），但最后一定是可以成功的
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    int ws = pred.waitStatus;
    // 如果前一個節(jié)點 waitStatus 狀態(tài)已經(jīng)是 SIGNAL 了，直接返回，不需要在自旋了
    if (ws == Node.SIGNAL)
        /*
         * This node has already set status asking a release
         * to signal it, so it can safely park.
         */
        return true;
    // 如果當(dāng)前節(jié)點狀態(tài)已經(jīng)被取消了。
    if (ws > 0) {
        /*
         * Predecessor was cancelled. Skip over predecessors and
         * indicate retry.
         */
        // 找到前一個狀態(tài)不是取消的節(jié)點，因為把當(dāng)前 node 掛在有效節(jié)點身上
        // 因為節(jié)點狀態(tài)是取消的話，是無效的，是不能作為 node 的前置節(jié)點的，所以必須找到 node 的有效節(jié)點才行
        do {
            node.prev = pred = pred.prev;
        } while (pred.waitStatus > 0);
        pred.next = node;
    // 否則直接把節(jié)點狀態(tài)置 為SIGNAL
    } 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:把當(dāng)前節(jié)點設(shè)置成頭節(jié)點
// 2:看看后續(xù)節(jié)點有無正在等待，并且也是共享模式的，有的話喚醒這些節(jié)點
private void setHeadAndPropagate(Node node, int propagate) {
    Node h = head; // Record old head for check below
    // 當(dāng)前節(jié)點設(shè)置成頭節(jié)點
    setHead(node);
    /*
     * Try to signal next queued node if:
     *   Propagation was indicated(表示指示) by caller,
     *     or was recorded (as h.waitStatus either before
     *     or after setHead) by a previous operation
     *     (note: this uses sign-check of waitStatus because
     *      PROPAGATE status may transition to SIGNAL.)
     * and
     *   The next node is waiting in shared mode,
     *     or we don't know, because it appears null
     *
     * The conservatism(保守) in both of these checks may cause
     * unnecessary wake-ups, but only when there are multiple
     * racing acquires/releases, so most need signals now or soon
     * anyway.
     */
    // propagate > 0 表示已經(jīng)有節(jié)點獲得共享鎖了
    if (propagate > 0 || h == null || h.waitStatus < 0 ||
        (h = head) == null || h.waitStatus < 0) {
        Node s = node.next;
        //共享模式，還喚醒頭節(jié)點的后置節(jié)點
        if (s == null || s.isShared())
            doReleaseShared();
    }
}
// 釋放后置共享節(jié)點
private void doReleaseShared() {
    /*
     * Ensure that a release propagates, even if there are other
     * in-progress acquires/releases.  This proceeds in the usual
     * way of trying to unparkSuccessor of head if it needs
     * signal. But if it does not, status is set to PROPAGATE to
     * ensure that upon release, propagation continues.
     * Additionally, we must loop in case a new node is added
     * while we are doing this. Also, unlike other uses of
     * unparkSuccessor, we need to know if CAS to reset status
     * fails, if so rechecking.
     */
    for (;;) {
        Node h = head;
        // 還沒有到隊尾，此時隊列中至少有兩個節(jié)點
        if (h != null && h != tail) {
            int ws = h.waitStatus;
            // 如果隊列狀態(tài)是 SIGNAL ，說明后續(xù)節(jié)點都需要喚醒
            if (ws == Node.SIGNAL) {
                // CAS 保證只有一個節(jié)點可以運行喚醒的操作
                if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
                    continue;            // loop to recheck cases
                // 進行喚醒操作
                unparkSuccessor(h);
            }
            else if (ws == 0 &&
                     !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
                continue;                // loop on failed CAS
        }
        // 第一種情況，頭節(jié)點沒有發(fā)生移動，結(jié)束。
        // 第二種情況，因為此方法可以被兩處調(diào)用，一次是獲得鎖的地方，一處是釋放鎖的地方，
        // 加上共享鎖的特性就是可以多個線程獲得鎖，也可以釋放鎖，這就導(dǎo)致頭節(jié)點可能會發(fā)生變化，
        // 如果頭節(jié)點發(fā)生了變化，就繼續(xù)循環(huán)，一直循環(huán)到頭節(jié)點不變化時，結(jié)束循環(huán)。
        if (h == head)                   // loop if head changed
            break;
    }
}