// （獨占式）嘗試獲取資源，成功則返回true，失敗則返回false。
protected boolean tryAcquire(int arg) {
    throw new UnsupportedOperationException();
}
// （獨占式）嘗試釋放資源，成功則返回true，失敗則返回false。
protected boolean tryRelease(int arg) {
    throw new UnsupportedOperationException();
}
// （共享式）嘗試獲取資源，負數(shù)表示失?。?表示成功，但沒有剩余可用資源；正數(shù)表示成功，且有剩余資源。
protected int tryAcquireShared(int arg) {
    throw new UnsupportedOperationException();
}
// （共享式）嘗試釋放資源，成功則返回true，失敗則返回false。
protected boolean tryReleaseShared(int arg) {
    throw new UnsupportedOperationException();
}
// 判斷當前線程是否正在獨占式，只有用到condition才需要去實現(xiàn)它。
protected boolean isHeldExclusively() {
    throw new UnsupportedOperationException();
}

static final class Node {
    // 共享模式
    static final Node SHARED = new Node();
    // 獨占模式
    static final Node EXCLUSIVE = null;
    // 由于超時、中斷或其他原因，線程被取消
    static final int CANCELLED =  1;
    // 當前節(jié)點的后繼節(jié)點阻塞等待共享資源
    static final int SIGNAL    = -1;
    // 當前節(jié)點在條件隊列
    static final int CONDITION = -2;
    // 當前節(jié)點的下一個acquireShared應(yīng)無條件傳播
    static final int PROPAGATE = -3;
    // 節(jié)點狀態(tài)
    volatile int waitStatus;
    // 前驅(qū)節(jié)點
    volatile Node prev;
    // 后繼節(jié)點
    volatile Node next;
    // 節(jié)點的線程
    volatile Thread thread;
    // 下一個等待者（這個用于 Condition，這里不做過多說明）
    Node nextWaiter;
    // 是否是共享模式
    final boolean isShared() {
        return nextWaiter == SHARED;
    }
    // 獲取前驅(qū)節(jié)點，為空則拋出異常
    final Node predecessor() throws NullPointerException {
        Node p = prev;
        if (p == null)
            throw new NullPointerException();
        else
            return p;
    }
    // 各種構(gòu)造器
    Node() {
    }
    Node(Thread thread, Node mode) {
        this.nextWaiter = mode;
        this.thread = thread;
    }
    Node(Thread thread, int waitStatus) {
        this.waitStatus = waitStatus;
        this.thread = thread;
    }
}

// 序列號
private static final long serialVersionUID = 7373984972572414691L;
// 頭結(jié)點
private transient volatile Node head;
// 尾結(jié)點
private transient volatile Node tail;
// 同步狀態(tài)
private volatile int state;
// 自旋時間
static final long spinForTimeoutThreshold = 1000L;
// Unsafe實例以及各種內(nèi)存偏移量
private static final Unsafe unsafe = Unsafe.getUnsafe();
private static final long stateOffset;
private static final long headOffset;
private static final long tailOffset;
private static final long waitStatusOffset;
private static final long nextOffset;

// 獲取同步狀態(tài)
protected final int getState() {
    return state;
}
// 設(shè)置同步狀態(tài)
protected final void setState(int newState) {
    state = newState;
}
// CAS方式設(shè)置同步狀態(tài)（當期待值expect等于當前同步狀態(tài)時，將同步狀態(tài)設(shè)置為update值）
protected final boolean compareAndSetState(int expect, int update) {
    // See below for intrinsics setup to support this
    return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
}

// 這里調(diào)用的是 nonfairTryAcquire(1)，也就是acquires為 1
final boolean nonfairTryAcquire(int acquires) {
    // 獲取當前線程
    final Thread current = Thread.currentThread();
    // 獲取同步狀態(tài)
    int c = getState();
    // 同步狀態(tài)為0，說明共享資源空閑可以直接搶占
    if (c == 0) {
        // 再次嘗試搶占
        if (compareAndSetState(0, acquires)) {
            // 成功則將當前線程設(shè)置為共享資源所有者
            setExclusiveOwnerThread(current);
            // 返回 true
            return true;
        }
    }
    // 當前共享資源還在被占用，判斷當前線程是不是共享資源所有者
    else if (current == getExclusiveOwnerThread()) {
        // 增加同步狀態(tài)（這里其實也就是 ReentrantLock 是可重入鎖的原因，如果是自己線程持有的鎖，可以再次加鎖，也就是可重入）
        int nextc = c + acquires;
        if (nextc < 0) // overflow
            throw new Error("Maximum lock count exceeded");
        // 更新同步狀態(tài)
        setState(nextc);
        // 返回 true
        return true;
    }
    // 如果上面情況都不是則返回 false
    return false;
}

private Node addWaiter(Node mode) {
    // 以當前線程以及 mode（這里是獨占式）為參數(shù)構(gòu)建節(jié)點
    Node node = new Node(Thread.currentThread(), mode);
    // 獲取隊列末尾節(jié)點
    Node pred = tail;
    // 判斷末尾節(jié)點是否為空
    if (pred != null) {
        // 末尾不為空時，將當前節(jié)點鏈接到莫尾結(jié)點后面，并且將當前節(jié)點設(shè)置為末尾節(jié)點
        node.prev = pred;
        if (compareAndSetTail(pred, node)) {
            pred.next = node;
            // 返回當前節(jié)點
            return node;
        }
    }
    // 末尾節(jié)點為空，則進入 enq 方法
    enq(node);
    return node;
}

private Node enq(final Node node) {
    // 循環(huán)直到將 node 加入隊列為止
    for (;;) {
        Node t = tail;
        // 判斷末尾節(jié)點是否為空
        if (t == null) {
            // 為空，說明需要設(shè)置哨兵節(jié)點
            if (compareAndSetHead(new Node()))
                tail = head;
        } else {
            // 不為空，直接加入末尾，并設(shè)置當前節(jié)點為末尾節(jié)點
            node.prev = t;
            if (compareAndSetTail(t, node)) {
                t.next = node;
                return t;
            }
        }
    }
}

// node 為當前加入隊列的節(jié)點，arg 為 1
final boolean acquireQueued(final Node node, int arg) {
    // 標志，用來判斷是否執(zhí)行后面的cancelAcquire方法
    // 也就是中途是否存在異常中斷，有則使用cancelAcquire整理隊列
    boolean failed = true;
    try {
        // 中斷標志
        boolean interrupted = false;
        // 循環(huán)
        for (;;) {
            // 獲取當前節(jié)點的前置節(jié)點
            final Node p = node.predecessor();
            // 判斷前置節(jié)點是否是頭結(jié)點（當前節(jié)點是否是隊列第一個等待線程）以及再次嘗試獲取資源
            if (p == head && tryAcquire(arg)) {
                // 滿足條件說明當前節(jié)點已經(jīng)搶占到資源，可以從隊列中移除
                // 所以這里會將當前節(jié)點設(shè)置為頭結(jié)點（setHead方法操作是先將節(jié)點線程以及前驅(qū)節(jié)點置空）
                setHead(node);
                // 并且將原本的頭結(jié)點置空，通過輔助GC回收
                p.next = null; // help GC
                // 標志置為false，表示沒有異常
                failed = false;
                // 返回中斷標志
                return interrupted;
            }
            // 上述條件不滿足，則執(zhí)行shouldParkAfterFailedAcquire和parkAndCheckInterrupt
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        if (failed)
            // 整理隊列，將隊列中中斷的進程移除
            cancelAcquire(node);
    }
}

// 傳參 pred 為當前節(jié)點的前置節(jié)點；node 為 當前節(jié)點
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    // 獲取前置節(jié)點的狀態(tài)
    int ws = pred.waitStatus;
    // 判斷是不是 Node.SIGNAL（-1）
    if (ws == Node.SIGNAL)
        // 狀態(tài)為-1表示線程已經(jīng)準備好了（阻塞等待了），就等資源釋放進行爭搶了
        // 返回 true 執(zhí)行 parkAndCheckInterrupt() 方法（這玩意就是阻塞線程）
        return true;
    // 判斷狀態(tài)是否大于0，表示被中斷
    if (ws > 0) {
        //前置節(jié)點為被中斷，意味著這個節(jié)點沒用了，需要再往前找，找到不是被中斷的狀態(tài)為止
        do {
            node.prev = pred = pred.prev;
        } while (pred.waitStatus > 0);
        // 找到后將新的前置節(jié)點與當前節(jié)點鏈接起來
        pred.next = node;
    } else {
        // CAS 方式將前置節(jié)點的狀態(tài)設(shè)置為 Node.SIGNAL
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
    }
    // 返回 false 直接跳出
    return false;
}

private final boolean parkAndCheckInterrupt() {
    // 調(diào)用 LockSupport 類進行阻塞當前線程
    LockSupport.park(this);
    // 返回當前線程是否中斷，同時清除中斷標志位
    return Thread.interrupted();
}

// 參數(shù)為當前節(jié)點
private void cancelAcquire(Node node) {
    // 當前節(jié)點為空直接返回
    if (node == null)
        return;
    // 將當前節(jié)點的線程置空
    node.thread = null;
    // 這一步是找到當前節(jié)點的前驅(qū)節(jié)點
    Node pred = node.prev;
    // 如果前驅(qū)節(jié)點狀態(tài)也為 CANCELLED 則循環(huán)找前驅(qū)節(jié)點的前驅(qū)節(jié)點直到狀態(tài)不為 CANCELLED
    while (pred.waitStatus > 0)
        node.prev = pred = pred.prev;
    // 獲取前驅(qū)節(jié)點的下一個節(jié)點
    Node predNext = pred.next;
    // 將當前節(jié)點設(shè)置為 CANCELLED
    node.waitStatus = Node.CANCELLED;
    // 判斷當前節(jié)點是否是末尾節(jié)點，是則只需要將末尾節(jié)點設(shè)置成獲取到的前驅(qū)節(jié)點即可
    // 相當于移除掉了前驅(qū)節(jié)點后的所有節(jié)點
    if (node == tail && compareAndSetTail(node, pred)) {
        // 并將前驅(qū)節(jié)點的下一節(jié)點置空
        compareAndSetNext(pred, predNext, null);
    } else {
        int ws;
        // 滿足三個條件
        // 1. 前驅(qū)節(jié)點不是頭結(jié)點
        // 2. 前驅(qū)節(jié)點的狀態(tài)為 SIGNAL 或者 前驅(qū)節(jié)點狀態(tài)小于0并且可以設(shè)置為 SIGNAL
        // 3. 前驅(qū)節(jié)點的線程不為空
        if (pred != head &&
            ((ws = pred.waitStatus) == Node.SIGNAL ||
             (ws <= 0 && compareAndSetWaitStatus(pred, ws, Node.SIGNAL))) &&
            pred.thread != null) {
            // 保存當前節(jié)點的后繼節(jié)點
            Node next = node.next;
            // 后繼節(jié)點不為空并且狀態(tài)不為 CANCELLED
            if (next != null && next.waitStatus <= 0)
                // 將前驅(qū)節(jié)點與后繼節(jié)點鏈接起來，移除中間的節(jié)點
                compareAndSetNext(pred, predNext, next);
        } else {
            // 以上條件不滿足則喚醒當前線程的下一個節(jié)點
            unparkSuccessor(node);
        }
        // 輔助GC回收
        node.next = node; // help GC
    }
}

protected final boolean tryRelease(int releases) {
    // 傳入releases 為 1, getState() 為 1
    // 所以 c = 1 - 1 = 0
    int c = getState() - releases;
    // 判斷當前線程是否是共享資源所有者，不是則拋出異常
    if (Thread.currentThread() != getExclusiveOwnerThread())
        throw new IllegalMonitorStateException();
    boolean free = false;
    // 判斷c是否等于0，共享資源是否空閑
    if (c == 0) {
        // 更新free標志
        free = true;
        // 將共享資源所有者置空
        setExclusiveOwnerThread(null);
    }
    // 更新state
    setState(c);
    // 返回free標志
    return free;
}

private void unparkSuccessor(Node node) {
    // 獲取當前結(jié)點的狀態(tài)
    int ws = node.waitStatus;
    // 判斷是否小于0，重新將狀態(tài)置為0
    if (ws < 0)
        compareAndSetWaitStatus(node, ws, 0);
    // 獲取當前結(jié)點的后繼節(jié)點
    Node s = node.next;
    // 如果后繼節(jié)點為空或者后繼節(jié)點狀態(tài)為 CANCELLED
    if (s == null || s.waitStatus > 0) {
        // 后繼節(jié)點置空
        s = null;
        // 通過從后向前遍歷找到離當前節(jié)點最近的后一個節(jié)點并且該節(jié)點狀態(tài)小于0
        for (Node t = tail; t != null && t != node; t = t.prev)
            if (t.waitStatus <= 0)
                // 如果狀態(tài)小于0說明已經(jīng)準備好獲取資源了，替換掉原先的后繼節(jié)點
                s = t;
    }
    // 后繼節(jié)點不為空
    if (s != null)
        // 喚醒該后繼節(jié)點的線程
        LockSupport.unpark(s.thread);
}