/**
 * Creates an instance of {@code ReentrantLock}.
 * This is equivalent to using {@code ReentrantLock(false)}.
 */
public ReentrantLock() {
    sync = new NonfairSync();
}
/**
 * Creates an instance of {@code ReentrantLock} with the
 * given fairness policy.
 *
 * @param fair {@code true} if this lock should use a fair ordering policy
 */
public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
}

static final class NonfairSync extends Sync {
    private static final long serialVersionUID = 7316153563782823691L;

    /**
     * Performs lock.  Try immediate barge, backing up to normal
     * acquire on failure.
     */
    final void lock() {
        //CAS修改state狀態(tài)
        if (compareAndSetState(0, 1))
           //修改成功設(shè)置exclusiveOwnerThread
            setExclusiveOwnerThread(Thread.currentThread());
        else
           //嘗試獲取資源
            acquire(1);
    }

    protected final boolean tryAcquire(int acquires) {
        return nonfairTryAcquire(acquires);
    }
}

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

final boolean nonfairTryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    //獲取當(dāng)前資源標(biāo)識(shí)
    int c = getState();
    if (c == 0) {
        //如果資源沒(méi)被占有CAS嘗試加鎖
        if (compareAndSetState(0, acquires)) {
            //修改成功設(shè)置exclusiveOwnerThread
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    //資源被占有要判斷占有資源的線程是不是當(dāng)前線程，加鎖成功設(shè)置的exclusiveOwnerThread值在這里就派上了用處
    else if (current == getExclusiveOwnerThread()) {
        //這下面就是將重入次數(shù)設(shè)置到資源標(biāo)識(shí)里
        int nextc = c + acquires;
        if (nextc < 0) // overflow
            throw new Error("Maximum lock count exceeded");
        setState(nextc);
        return true;
    }
    return false;
}

private Node addWaiter(Node mode) {
    //構(gòu)建一個(gè)當(dāng)前線程的node節(jié)點(diǎn) 這里prev 和 next 都為null
    Node node = new Node(Thread.currentThread(), mode);
    // 指向雙向鏈表的尾節(jié)點(diǎn)的引用
    Node pred = tail;
    //B線程進(jìn)來(lái)目前還未構(gòu)建任何隊(duì)列這里肯定是空的
    if (pred != null) {
        //如果已經(jīng)構(gòu)建過(guò)隊(duì)列會(huì)把當(dāng)前線程的node節(jié)點(diǎn)的上一個(gè)node節(jié)點(diǎn)指向tail尾節(jié)點(diǎn)
        node.prev = pred;
        //CAS操作把當(dāng)前線程的node節(jié)點(diǎn)設(shè)置為新的tail尾節(jié)點(diǎn)
        if (compareAndSetTail(pred, node)) {
            //把舊的tail尾節(jié)點(diǎn)的下一個(gè)node節(jié)點(diǎn)指向當(dāng)前線程的node節(jié)點(diǎn)
            pred.next = node;
            return node;
        }
    }
    //尾節(jié)點(diǎn)為空?qǐng)?zhí)行
    enq(node);
    return node;
}

private Node enq(final Node node) {
    //死循環(huán)當(dāng)tail 尾節(jié)點(diǎn)不為空才會(huì)跳出
    for (;;) {
        Node t = tail;
        if (t == null) { // Must initialize
            //用CAS構(gòu)建出一個(gè)head空的node節(jié)點(diǎn)
            if (compareAndSetHead(new Node()))
            //將當(dāng)前空的node節(jié)點(diǎn)交給尾節(jié)點(diǎn)（下一次循環(huán)就會(huì)走else分支）
                tail = head;
        } else {
            //把我們addWaiter中創(chuàng)建的node節(jié)點(diǎn)的prev指向了當(dāng)前線程node節(jié)點(diǎn)
            node.prev = t;
            //將tail尾節(jié)點(diǎn)更改為當(dāng)前線程的node節(jié)點(diǎn)
            if (compareAndSetTail(t, node)) {
                //將t的下一個(gè)節(jié)點(diǎn)指向當(dāng)前線程創(chuàng)建的node節(jié)點(diǎn)
                t.next = node;
                return t;
            }
        }
    }
}

final boolean acquireQueued(final Node node, int arg) {
    boolean failed = true;
    try {
        //中斷標(biāo)志位
        boolean interrupted = false;
        for (;;) {
            //獲取當(dāng)前線程node節(jié)點(diǎn)的上一個(gè)節(jié)點(diǎn)
            final Node p = node.predecessor();
            //如果上一個(gè)節(jié)點(diǎn)就是head節(jié)點(diǎn)說(shuō)明當(dāng)前線程其實(shí)是處在隊(duì)列第一位然后就會(huì)再次嘗試加鎖
            if (p == head && tryAcquire(arg)) {
                setHead(node);
                p.next = null; // help GC
                failed = false;
                return interrupted;
            }
            //這里是重點(diǎn) 這個(gè)方法來(lái)判斷當(dāng)前線程是否應(yīng)該進(jìn)入等待狀態(tài)
            if (shouldParkAfterFailedAcquire(p, node) &&
                //調(diào)用LockSupport.park(this)阻塞了當(dāng)前線程等待被喚醒
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    //獲取上一個(gè)節(jié)點(diǎn)的等待狀態(tài)
    int ws = pred.waitStatus;
    if (ws == Node.SIGNAL)//表示當(dāng)前節(jié)點(diǎn)的后繼節(jié)點(diǎn)包含的線程需要運(yùn)行
        /*
         * This node has already set status asking a release
         * to signal it, so it can safely park.
         */
        return true;
    if (ws > 0) {//當(dāng)前線程被取消
        /*
         * 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);//設(shè)置等待狀態(tài)為-1
    }
    return false;
}

public void unlock() {
    sync.release(1);
}

public final boolean release(int arg) {
   //嘗試釋放鎖
    if (tryRelease(arg)) {
        Node h = head;
        if (h != null && h.waitStatus != 0)
            //head節(jié)點(diǎn)不為空并且等待狀態(tài)不是0就去進(jìn)行unpark操作
            unparkSuccessor(h);
        return true;
    }
    return false;
}

private void unparkSuccessor(Node node) {
    /*
     * If status is negative (i.e., possibly needing signal) try
     * to clear in anticipation of signalling.  It is OK if this
     * fails or if status is changed by waiting thread.
     */
    //head節(jié)點(diǎn)等待狀態(tài)
    int ws = node.waitStatus;
    //
    if (ws < 0)
       //將頭節(jié)點(diǎn)的等待狀態(tài)修改為0
        compareAndSetWaitStatus(node, ws, 0);

    /*
     * Thread to unpark is held in successor, which is normally
     * just the next node.  But if cancelled or apparently null,
     * traverse backwards from tail to find the actual
     * non-cancelled successor.
     */
    //獲取頭節(jié)點(diǎn)的下一個(gè)節(jié)點(diǎn)(也就是B節(jié)點(diǎn))
    Node s = node.next;
    if (s == null || s.waitStatus > 0) {//節(jié)點(diǎn)為空或者線程處于取消狀態(tài)
        s = null;
        //從尾節(jié)點(diǎn)往上找符合條件的節(jié)點(diǎn)
        for (Node t = tail; t != null && t != node; t = t.prev)
            if (t.waitStatus <= 0)
                s = t;
    }
    if (s != null)
        //對(duì)該線程進(jìn)行unpark喚醒(B節(jié)點(diǎn))
        LockSupport.unpark(s.thread);
}

final boolean acquireQueued(final Node node, int arg) {
    boolean failed = true;
    try {
        boolean interrupted = false;
        for (;;) {
            final Node p = node.predecessor();
            //這里嘗試獲取鎖由于A線程釋放了鎖這里是肯定獲取成功的
            if (p == head && tryAcquire(arg)) {
                //把head設(shè)置為當(dāng)前節(jié)點(diǎn)（也就是往前移一位,并且把上一個(gè)節(jié)點(diǎn)指向指為null）
                setHead(node);
                //把剛剛的上一個(gè)節(jié)點(diǎn)也指向?yàn)閚ull (這里他就沒(méi)引用了會(huì)被GC回收掉)
                p.next = null; // help GC
                failed = false;
                return interrupted;
            }
            if (shouldParkAfterFailedAcquire(p, node) &&
                //剛剛在這里阻塞現(xiàn)在被喚醒
                parkAndCheckInterrupt())
                //設(shè)置標(biāo)志中斷位為true 然后開(kāi)始下一次循環(huán)
                interrupted = true;
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}