private volatile int state;

private transient volatile Node head; //执行队列的头结点
private transient volatile Node tail; //执行队列的尾节点

/**
  * Status field, taking on only the values:
  *   SIGNAL:     The successor of this node is (or will soon be)
  *               blocked (via park), so the current node must
  *               unpark its successor when it releases or
  *               cancels. To avoid races, acquire methods must
  *               first indicate they need a signal,
  *               then retry the atomic acquire, and then,
  *               on failure, block.
  *   CANCELLED:  This node is cancelled due to timeout or interrupt.
  *               Nodes never leave this state. In particular,
  *               a thread with cancelled node never again blocks.
  *   CONDITION:  This node is currently on a condition queue.
  *               It will not be used as a sync queue node
  *               until transferred, at which time the status
  *               will be set to 0. (Use of this value here has
  *               nothing to do with the other uses of the
  *               field, but simplifies mechanics.)
  *   PROPAGATE:  A releaseShared should be propagated to other
  *               nodes. This is set (for head node only) in
  *               doReleaseShared to ensure propagation
  *               continues, even if other operations have
  *               since intervened.
  *   0:          None of the above
  *
  * The values are arranged numerically to simplify use.
  * Non-negative values mean that a node doesn't need to
  * signal. So, most code doesn't need to check for particular
  * values, just for sign.
  *
  * The field is initialized to 0 for normal sync nodes, and
  * CONDITION for condition nodes.  It is modified using CAS
  * (or when possible, unconditional volatile writes).
  */
  volatile int waitStatus;

public class ReentrantLock implements Lock, java.io.Serializable {
    /** Synchronizer providing all implementation mechanics */
    private final Sync sync;

    abstract static class Sync extends AbstractQueuedSynchronizer{
      ...
    }

    static final class NonfairSync extends Sync {
      ...
    }

    static final class FairSync extends Sync {
      ...
    }

    public ReentrantLock() { sync = new NonfairSync(); }

    public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }

    public void lock() { sync.lock();}

    public void lockInterruptibly() throws InterruptedException {
        sync.acquireInterruptibly(1);
    }

    public boolean tryLock() {
        return sync.nonfairTryAcquire(1);
    }

    public boolean tryLock(long timeout, TimeUnit unit)
            throws InterruptedException {
        return sync.tryAcquireNanos(1, unit.toNanos(timeout));
    }

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

    public Condition newCondition() {
        return sync.newCondition();
    }
}

abstract static class Sync extends AbstractQueuedSynchronizer {

    abstract void lock();

    /**
     * Performs non-fair tryLock.  tryAcquire is implemented in
     * subclasses, but both need nonfair try for trylock method.
     */
    //注释说到， tryAcquire在子类中实现，但是tryLock是使用nofair的，所以放到了父类中
    final boolean nonfairTryAcquire(int acquires) {
        final Thread current = Thread.currentThread();
        int c = getState();
        if (c == 0) {
            //如果当前没有线程持有，则直接尝试获取一次，不管后面后又没其他线程再等待
            if (compareAndSetState(0, acquires)) {
                setExclusiveOwnerThread(current);
                return true;
            }
        }
        //判断是否为锁重入
        else if (current == getExclusiveOwnerThread()) {
            //记录重入
            int nextc = c + acquires;
            //判断int overflow的情况，所以最大的重入次数为int的最大值
            if (nextc < 0) // overflow
                throw new Error("Maximum lock count exceeded");
            setState(nextc);
            return true;
        }
        return false;
    }

    //尝试释放锁
    protected final boolean tryRelease(int releases) {

        int c = getState() - releases;
        if (Thread.currentThread() != getExclusiveOwnerThread())
            throw new IllegalMonitorStateException();
        boolean free = false;
        //如通c == 0，表示所有的锁都释放完了
        //则设置持有锁线程为null
        //返回释放锁成功
        if (c == 0) {
            free = true;
            setExclusiveOwnerThread(null);
        }
        //如果c != 0 则表示发生了锁重入，只是里层释放了锁
        //返回没有完全释放锁
        setState(c);
        return free;
    }

    protected final boolean isHeldExclusively() {
        // While we must in general read state before owner,
        // we don't need to do so to check if current thread is owner
        return getExclusiveOwnerThread() == Thread.currentThread();
    }
    // 省略掉一些不太重要的方法。。。。
}

/**
 * Sync object for non-fair locks
 */
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() {
        //非公平锁上来就先尝试获取一次,就是这里体现了不公平，
        if (compareAndSetState(0, 1))
            setExclusiveOwnerThread(Thread.currentThread());
        else
            //如果没有获取成功,通过acquire方法，加入队列中等待
            acquire(1);
    }

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

/**
 * Sync object for fair locks
 */
static final class FairSync extends Sync {
    private static final long serialVersionUID = -3000897897090466540L;

    final void lock() {
        acquire(1);
    }

    /**
     * Fair version of tryAcquire.  Don't grant access unless
     * recursive call or no waiters or is first.
     */
    //公平锁的tryAcquire和非公平锁的差别就是，非公平锁会直接尝试一次CAS获取锁
    //而公平锁则会先判断一下等待队列是不是为空。
    //如果都尝试获取失败，之后的处理逻辑都是一样的
    protected final boolean tryAcquire(int acquires) {
        final Thread current = Thread.currentThread();
        int c = getState();
        if (c == 0) {
            //如果队列为空，或者当前线程已经处于队列的最前，则尝试一次通过CAS获取锁
            //否则不获取
            if (!hasQueuedPredecessors() &&
                compareAndSetState(0, acquires)) {
                setExclusiveOwnerThread(current);
                return true;
            }
        }
        //判断重入的逻辑
        else if (current == getExclusiveOwnerThread()) {
            int nextc = c + acquires;
            if (nextc < 0)
                throw new Error("Maximum lock count exceeded");
            setState(nextc);
            return true;
        }
        //获取锁失败，并且不是重入，则tryAcquire失败
        return false;
    }
}

/**
 * Performs non-fair tryLock.  tryAcquire is implemented in
 * subclasses, but both need nonfair try for trylock method.
 */

public class FairVsNonFairLock {

    // 公平锁
    private static Lock fairLock = new ReentrantLock(true);
    // 非公平锁
    private static Lock nonFairLock = new ReentrantLock(false);
    // 计数器
    private static int fairCount = 0;
    // 计数器
    private static int nonFairCount = 0;

    private static int threadCount = 1;

    public static void main(String[] args) throws InterruptedException {
        System.out.println("公平锁耗时:   " + testFairLock(threadCount) + " ms");
        System.out.println("非公平锁耗时: " + testNonFairLock(threadCount) + " ms");
    }

    public static long testFairLock(int threadNum) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(threadNum);
        // 创建threadNum个线程，让其以公平锁的方式，对fairCount进行自增操作
        List<Thread> fairList = new ArrayList<>();
        for (int i = 0; i < threadNum; i++) {
            fairList.add(new Thread(() -> {
                for (int j = 0; j < 10000; j++) {
                    fairLock.lock();
                    fairCount++;
                    fairLock.unlock();
                }
                countDownLatch.countDown();
            }));
        }
        long startTime = System.currentTimeMillis();
        for (Thread thread : fairList) {
            thread.start();
        }
        // 让所有线程执行完
        countDownLatch.await();
        return System.currentTimeMillis() - startTime;
    }

    public static long testNonFairLock(int threadNum) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(threadNum);
        // 创建threadNum个线程，让其以非公平锁的方式，对nonFairCountCount进行自增操作
        List<Thread> nonFairList = new ArrayList<>();
        for (int i = 0; i < threadNum; i++) {
            nonFairList.add(new Thread(() -> {
                for (int j = 0; j < 10000; j++) {
                    nonFairLock.lock();
                    nonFairCount++;
                    nonFairLock.unlock();
                }
                countDownLatch.countDown();
            }));
        }
        long startTime = System.currentTimeMillis();
        for (Thread thread : nonFairList) {
            thread.start();
        }
        // 让所有线程执行完
        countDownLatch.await();
        return System.currentTimeMillis() - startTime;
    }
}

/**
 * Acquires in exclusive mode, ignoring interrupts.  Implemented
 * by invoking at least once {@link #tryAcquire},
 * returning on success.  Otherwise the thread is queued, possibly
 * repeatedly blocking and unblocking, invoking {@link
 * #tryAcquire} until success.  This method can be used
 * to implement method {@link Lock#lock}.
 *
 * @param arg the acquire argument.  This value is conveyed to
 *        {@link #tryAcquire} but is otherwise uninterpreted and
 *        can represent anything you like.
 */
public final void acquire(int arg) {
    if (!tryAcquire(arg) &&
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        //自我中断，用来传递线程在获取锁的过程中被中断的状态
        selfInterrupt();
}

/**
  * Creates and enqueues node for current thread and given mode.
  *
  * @param mode Node.EXCLUSIVE for exclusive, Node.SHARED for shared
  * @return the new node
  */
 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
     //这里进行一次快速入队，而不是直接走完整的入队方法的考虑是
     //完整入队操作，是通过死循环，然后调用CAS来实现的。JVM或者操作系统，在处理循环的时候，需要很多额外的资源和开销，
     //所以先进行一次单独的CAS操作，如果成功的话，就能节省掉死循环的开销,如果不成功再使用enq，也不会有太大的开销
     Node pred = tail;
     //如果尾节点不为空，把当前节点的前置节点设置为尾节点
     //这里入队的时候，先尝试快速入队
     if (pred != null) {
         //先和前面的节点建立联系，保证从后面遍历的时候，能够遍历到所有的节点
         node.prev = pred;
         //使用CAS设置当前节点为尾节点
         if (compareAndSetTail(pred, node)) {
             //如果设置成功，把前置节点的next指向当前节点
             pred.next = node;
             return node;
         }
     }
     //如果CAS失败，或者尾结点为空，则需要进入完整的入队逻辑。
     //CAS失败，则说明，有另一个线程进入了队列，并成为了尾结点。
     enq(node);
     return node;
 }

/**
 * Inserts node into queue, initializing if necessary. See picture above.
 * @param node the node to insert
 * @return node's predecessor
 */
private Node enq(final Node node) {
    for (;;) {
        Node t = tail;
        if (t == null) { // Must initialize
            //走到这里的话说明，说明Node还没有初始化，需要创建一个节点，当做头结点
            //初始化的时候，只有一个节点，所以这个节点既是头结点又是尾结点
            if (compareAndSetHead(new Node()))
                tail = head;
        } else {
            //当初始化完成之后，会继续循环，直到把当前节点设置为尾结点。
            node.prev = t;
            if (compareAndSetTail(t, node)) {
                t.next = node;
                return t;
            }
        }
    }
}

/**
 * Acquires in exclusive uninterruptible mode for thread already in
 * queue. Used by condition wait methods as well as acquire.
 *
 * @param node the node
 * @param arg the acquire argument
 * @return {@code true} if interrupted while waiting 如果在等待过程，被中断过，获取锁之后返回true
 */
final boolean acquireQueued(final Node node, int arg) {
    boolean failed = true;
    try {
        boolean interrupted = false;
        for (;;) {
            final Node p = node.predecessor();
            //如果这个节点的前置节点是头结点，那么则表示这个节点有获取锁的资格。
            //顺便说一下，在AQS的队列中个，头结点是一个虚节点，是为了在编程的时候更为方便，或者可以理解为已经获取到锁的节点
            //调用tryAcquire()尝试获取锁
            if (p == head && tryAcquire(arg)) {
                setHead(node);
                //把之前的头结点踢出等待队列
                p.next = null; // help GC
                failed = false;
                //获取锁成功之后，返回中断状态
                return interrupted;
            }
            //如果没有资格获取锁，或者获取锁失败
            //则需要通过shouldParkAfterFailedAcquire()，判断这个线程是否需要挂起
            //如果当前节点，是头结点的下一个节点，那么shouldParkAfterFailedAcquire()方法会返回false，直接跳过挂起，再执行上面的逻辑获取一次
            //如果需要park，则调用parkAndCheckInterrupt()方法，进行挂起。
            //线程在挂起的时候，有两种唤醒的方式，
            // 1.使用unpark
            // 2.使用线程中断方法
            //如果这个线程是被线程中断方法唤醒，那么会把这个interrupted变量置为true
            //然后在等到这个线程获取到锁的时候，会把这个中断状态传出去
            //这里使用到的一个特性就是，被park挂起的线程，当线程中断的时候不会抛出线程中断异常
            if (shouldParkAfterFailedAcquire(p, node) &&
                //如果返回true，表示是被中断唤醒的
                parkAndCheckInterrupt())
                //记录中断状态
                interrupted = true;
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

/**
 * Checks and updates status for a node that failed to acquire.
 * Returns true if thread should block. This is the main signal
 * control in all acquire loops.  Requires that pred == node.prev.
 *
 * @param pred node's predecessor holding status
 * @param node the node
 * @return {@code true} if thread should block
 */
//在这个方法判断node节点的线程，是否需要挂起
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    //获取前置节点的waitStatus
    int ws = pred.waitStatus;
    if (ws == Node.SIGNAL)
        //如果pred节点的waitStatus是SIGNAL，则表示pred节点正在等待别的通知来唤醒
        //所以肯定还轮不到node节点来获取锁，直接挂起
        //这个节点已经设置了请求释放资源的时候来通知它的状态，所以可以安全的挂起
        /*
         * 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.
         */

        //waitStatus > 0 只有可能是canceled，那么则踢出pred节点
        //让node的prev指向 pred节点的prev，就相当于跳过了pred节点。
        //这里是一个循环操作，表示会把前面所有的连续的cancel状态的节点都踢出队列
        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.
         */
        //执行到这里的话，waitStatus只能是0 或者 PROPAGATE。
        //这时候会把前置节点的waitStatus 状态修改为signal，这样在下次循环的时候，当前节点就会执行挂起操作了
        //每个节点的waitStatus都是由他的下一个节点来修改的
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
    }
    return false;
}

//当线程被unpark()唤醒，或者被终端的时候返回当前线程的中断状态
//使用park()挂起的一个特点就是，当调用线程的中断方法时，不会抛出中断异常，同时也会保留线程的中断状态
private final boolean parkAndCheckInterrupt() {
    LockSupport.park(this);
    //这里注意一下，如果是通过调用线程interrupt方法唤醒了挂起的线程。
    //这里调用的是 interrupted(),这个方法的作用是，返回当前线程的中断状态，然后清除掉中断状态，
    //这里为什么必须要清除中断状态呢？
    //因为线程被唤醒之后，需要再次去尝试获取锁，但是并不能保证肯定成功，如果失败了，还需要继续挂起。
    //如果这里不清除中断状态，那么下次获取失败，需要再次挂起的时候，因为线程有中断状态，所以LockSuport.park()会失效，则导致线程无法挂起。
    return Thread.interrupted();
}

/**
 * Releases in exclusive mode.  Implemented by unblocking one or
 * more threads if {@link #tryRelease} returns true.
 * This method can be used to implement method {@link Lock#unlock}.
 *
 * @param arg the release argument.  This value is conveyed to
 *        {@link #tryRelease} but is otherwise uninterpreted and
 *        can represent anything you like.
 * @return the value returned from {@link #tryRelease}
 *
 */
public final boolean release(int arg) {
    //tryRelease，尝试释放
    //这里如果返回false，则表示发生了锁重入，这里只是释放了里层的，外层仍然还在持有锁
    //如果返回true，则表示所有的重入都已经被释放了，可以唤醒下面的等待线程了
    if (tryRelease(arg)) {
        Node h = head;
        //如果有head不为null，则表示至少有一个线程进入过等待队列，因为head节点是在后面线程进入等待队列的时候初始化的
        //h.waitStatus != 0,为什么要加这个判断呢?
        //因为waitStatus=0，是一个节点的初始状态，如果头结点处于这个状态，说明要么后面加入的线程还在执行中，没有执行到 shouldParkAfterFailedAcquire方法中的compareAndSetWaitStatus
        //要么就是后面的线程在执行到 shouldParkAfterFailedAcquire()方法之前，已经超时了
        //这两种情况都不需要唤醒
        //第一种线程正在执行的情况，后面的线程会在第二次循环的时候tryAcquire(),能够拿到锁
        if (h != null && h.waitStatus != 0)
            unparkSuccessor(h);
        return true;
    }
    return false;
}

//尝试释放锁
protected final boolean tryRelease(int releases) {

    int c = getState() - releases;
    if (Thread.currentThread() != getExclusiveOwnerThread())
        throw new IllegalMonitorStateException();
    boolean free = false;
    //如通c == 0，表示所有的锁都释放完了
    //则设置持有锁线程为null
    //返回释放锁成功
    if (c == 0) {
        free = true;
        setExclusiveOwnerThread(null);
    }
    //如果c != 0 则表示发生了锁重入，只是里层释放了锁
    //返回没有完全释放锁
    setState(c);
    return free;
}

Node h = head;
if (h != null && h.waitStatus != 0)
    unparkSuccessor(h);
return true;

/**
 * Wakes up node's successor, if one exists.
 *
 * @param node the node
 */
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.
     */
     // 这里传入的是头结点，头结点已经完成了唤醒后面节点的操作，那么则可以把这个状态改回默认值了
    int ws = node.waitStatus;
    if (ws < 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.
     */
    /**
     这里从后向前遍历的原因是，在新节点node入队的时候，都是先设置
     node.prev = p（之前的tail节点）(也就是说从后向前可以遍历整个队里了)
     然后通过cas，把node节点设置为tail
     如果cas成功，才设置 p.next = node (这时候从head节点向后才能遍历整个队列)

     以为cas成功，和 设置 p.next = node 这两个步骤并不是原子的
     所以如果cas成功之后，在执行 p.next = node之前，unparkSuccessor()被调用。
     线程开始从前往后遍历，这时候 p.next 还是为null的，所以就不能遍历队列所有的节点了。
     **/

    /**
     * 因为Node是一个双向队列
     * 在插入新节点的时候，总是会先把新节点和前面的节点(也就是之前的尾结点)建立联系。node.prev = p;
     * 然后当新节点成功的成为尾结点之后，才会把 前面的节点和新节点建立联系 p.next = node;
     *
     * 这是可以理解，也是必须的。
     * 因为 p(之前的尾结点)，已经是队列中确定的一个节点，如果在node节点确定加入队列之前就修改了p节点的next属性，如果node能在紧接着的
     * cas操作成功还好，如果cas失败，那就是让p.next指向了一个队列外的节点。这肯定是不行的。
     *
     * 所以说要么把入队和与p.next = node 这两个操作搞成一个原子操作(但是这样肯定会影响性能)，要么想出一个方案，在节点已经入队(已经成为了尾结点)，但是前面节点p还没和node节点建立联系的情况下，也能顺利的遍历所有的节点。
     *
     * 先执行node.prev = p，就是解决这个问题的办法。
     *
     * 所以导致了这里必须采用从队尾开始遍历的方案
     *
     */

    //拿到头结点的下一个节点
    Node s = node.next;
    //如果为空，或者状态是已取消，则从尾结点开始找到一个非canceled状态的节点，然后唤醒它
    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;
    }
    //如果找到了合适的节点，则使用unpark()方法唤醒
    if (s != null)
        LockSupport.unpark(s.thread);
}

// Condition中的操作实际上是，先把自己加入到一个 Condition队列中。
// 然后释放掉获取的AQS锁，然后通过LockSupport挂起，等待其他线程唤醒，唤醒后在继续获取锁
public final void await() throws InterruptedException {
    if (Thread.interrupted())
        throw new InterruptedException();
    //加入一个新节点到，condition队列中
    Node node = addConditionWaiter();
    //释放锁，想一下wait和notify，别人在唤醒你的时候，也需要获得锁，如果你不释放别人怎么唤醒你呢，所以这里要释放锁
    int savedState = fullyRelease(node);
    int interruptMode = 0;
    //在调用signal的时候会把节点加入到同步队列中，
    //如果已经在队列中了，那说明已经有人唤醒了它，把它加入到了队列中，那么直接获取锁就可以了。
    //如果还没有加入队列，则需要挂起，等待唤醒的时候被加入到队列中。
    while (!isOnSyncQueue(node)) {
        LockSupport.park(this);
        if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
            break;
    }
    //然后在进入等待队列中获取锁
    if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
        interruptMode = REINTERRUPT;
    if (node.nextWaiter != null) // clean up if cancelled
        unlinkCancelledWaiters();
    if (interruptMode != 0)
        //根据interruptMode执行抛出异常或者自我中断
        reportInterruptAfterWait(interruptMode);
}

/**
 * Adds a new waiter to wait queue.
 * @return its new wait node
 */
//这里之所以在向队列中添加节点的时候，没有采用AQS中的那种 形式
//是因为在调用 condition.await()的时候，需要先通过 lock.lock()获取到锁，所以在这一步不会存在竞争
//Condition队列是一个全新的队列
//这里因为没有并发问题，所以写起来就明朗多了，不用各种的CAS操作来保证并发安全了
private Node addConditionWaiter() {
    Node t = lastWaiter;
    // If lastWaiter is cancelled, clean out.
    if (t != null && t.waitStatus != Node.CONDITION) {
        //删除所有cancelled状态的节点
        unlinkCancelledWaiters();
        t = lastWaiter;
    }
    //构建节点，初始即为Condition状态。
    //如果当前队列为空，就设置为头结点
    //如果不为空，就设置为当前tail的next
    //最后设置当前节点为尾节点
    Node node = new Node(Thread.currentThread(), Node.CONDITION);
    if (t == null)
        firstWaiter = node;
    else
        t.nextWaiter = node;
    lastWaiter = node;
    return node;
}

//这里的fully的意思是，不管发生了几次重入，全部一次性释放
//所以这里是直接拿到当前的state，然后一次性release
//并唤醒同步队列中的一个节点
final int fullyRelease(Node node) {
    boolean failed = true;
    try {
        int savedState = getState();
        if (release(savedState)) {
            failed = false;
            return savedState;
        } else {
            throw new IllegalMonitorStateException();
        }
    } finally {
        if (failed)
            node.waitStatus = Node.CANCELLED;
    }
}

/**
 * Checks for interrupt, returning THROW_IE if interrupted
 * before signalled, REINTERRUPT if after signalled, or
 * 0 if not interrupted.
 */
/**
 * 在唤醒钱被中断，则返回 throw_ie,唤醒后中断则返回 REINTERRUPT
 * 没有中断，返回0
 */
private int checkInterruptWhileWaiting(Node node) {
    return Thread.interrupted() ?
        (transferAfterCancelledWait(node) ? THROW_IE : REINTERRUPT) :
        0;
}

public final void signal() {
    //首先判断是不是持有锁，如果没有持有锁，则抛出监视器状态异常
    if (!isHeldExclusively())
        throw new IllegalMonitorStateException();
    //唤醒Condition队列的第一个节点
    Node first = firstWaiter;
    if (first != null)
        doSignal(first);
}

//唤醒wait队列上的第一个节点
private void doSignal(Node first) {
    do {
        //判断是否队列上只有一个节点，如果是，就将lastWaiter 设置为null
        if ( (firstWaiter = first.nextWaiter) == null)
            lastWaiter = null;
        //既然要唤醒第一个节点，唤醒后，直接将第一个节点从队列上移除。
        first.nextWaiter = null;
        //通过transferForSignal将节点加入到同步队列中。如果加入失败了，则重新取出wait队列的第一个节点并唤醒。
    } while (!transferForSignal(first) &&
            (first = firstWaiter) != null);
}

//将wait节点放入到同步队列中
final boolean transferForSignal(Node node) {
    /*
     * If cannot change waitStatus, the node has been cancelled.
     */
     //这里如果CAS失败，说明当前节点的状态已经不是CONDITION，说明已经被其他线程唤醒了。
     //返回false之后，外层是一个循环，会继续取出wait队列的第一个节点，继续执行唤醒操作
    if (!compareAndSetWaitStatus(node, Node.CONDITION, 0))
        return false;
    /*
     * Splice onto queue and try to set waitStatus of predecessor to
     * indicate that thread is (probably) waiting. If cancelled or
     * attempt to set waitStatus fails, wake up to resync (in which
     * case the waitStatus can be transiently and harmlessly wrong).
     */
     //将当前节点加入到同步队列，注意，这里enq返回值返回的是假如队列节点的前一个节点，也就是原队尾节点。
    Node p = enq(node);
    int ws = p.waitStatus;
    //这里的判断非常巧妙，我们知道，我们把Node节点从wait移动到同步队列，如果我们把节点线程唤醒，是没有问题的。
    //因为唤醒后执行到await中的acquireQueued的时候，会被重新挂起，但是这样比较耗费性能，是没有必要的。
    //所以这里进行了判断，如果移入到同步队列后，发现原尾节点的状态大于0，或者将尾节点的状态改为SIGNAL的时候失败了，才会唤醒。并在acquireQueued中重新整理同步队列并重新挂起。
    //这里不挂起是没有问题的，因为在acquireQueued挂起前判断，如果当前节点是第一个节点，会直接获取锁。如果中断唤醒了，或继续从await挂起的地方继续执行，会继续在acquireQueued的地方重新挂起。
    if (ws > 0 || !compareAndSetWaitStatus(p, ws, Node.SIGNAL))
        LockSupport.unpark(node.thread);
    return true;
}

public final void signalAll() {
    if (!isHeldExclusively())
        throw new IllegalMonitorStateException();
    //拿到wait队列，执行doSignalAll
    Node first = firstWaiter;
    if (first != null)
        doSignalAll(first);

//理解了signal，理解这里的doSignalAll就很简单了。
//就是遍历wait队列上的节点逐个顺序取出放入到同步队列中。
private void doSignalAll(Node first) {
    lastWaiter = firstWaiter = null;
    do {
        Node next = first.nextWaiter;
        first.nextWaiter = null;
        transferForSignal(first);
        first = next;
    } while (first != null);
}

private void cancelAcquire(Node node) {
    // Ignore if node doesn't exist
    if (node == null)
        return;
    //将节点中的线程设置为null
    //设置该节点不关联任何线程，也就是虚节点
    node.thread = null;

    // Skip cancelled predecessors
    //跳过前面节点中状态为cancel的节点，把这个节点的前置节点引用指向一个不是cancel状态的节点(0,或者SIGNAL)
    Node pred = node.prev;
    while (pred.waitStatus > 0)
        node.prev = pred = pred.prev;

    // predNext is the apparent node to unsplice. CASes below will
    // fail if not, in which case, we lost race vs another cancel
    // or signal, so no further action is necessary.
    Node predNext = pred.next;

    // Can use unconditional write instead of CAS here.
    // After this atomic step, other Nodes can skip past us.
    // Before, we are free of interference from other threads.
    //把当前节点的状态设置为取消
    node.waitStatus = Node.CANCELLED;

    // If we are the tail, remove ourselves.
    // 如果当前节点是尾结点，则修改当前节点的前置节点为新的尾结点
    if (node == tail && compareAndSetTail(node, pred)) {
        //如果修改成功，然后把前置节点的next 设置为null,这时候前置节点已经是尾结点了，所以它没有next节点了
        //这一步成功失败，并不重要，如果失败，表示节点已经为null了，或者有新的节点加入，成为了它的next
        compareAndSetNext(pred, predNext, null);
    } else {
        // If successor needs signal, try to set pred's next-link
        // so it will get one. Otherwise wake it up to propagate.
        //如果走到这里，说明要么当前节点不是tail节点
        //或者，在cas的时候node不是尾结点了，有新的线程加入成为了新的尾结点。
        int ws;
        //首先判断node节点的前置节点是不是head,如果是则直接走else逻辑
        if (pred != head &&
            //如果node的前置节点不是head
            //则判断waitStatus是不是signal
                //如果不是signal，则判断是不是非cancelled状态，如果是则cas把状态设置为signal
            //判断pred的线程不能为null
            ((ws = pred.waitStatus) == Node.SIGNAL || (ws <= 0 && compareAndSetWaitStatus(pred, ws, Node.SIGNAL)))
                && pred.thread != null) {
            //接下来的操作，我理解就是把node的前置节点和node的next节点，连接起来
            Node next = node.next;
            if (next != null && next.waitStatus <= 0)
                compareAndSetNext(pred, predNext, next);
        } else {
            //如果是head的话那么现在队列的情况是   head -> node -> node1 -> tail
            //这时候 node节点是cancel状态，那么就需要唤醒 node1节点
            //唤醒node1 需要传入的是node1的前置节点也就是node，所以 unparkSuccessor(node);
            unparkSuccessor(node);
        }

        //为什么不是=null呢？
        node.next = node; // help GC
    }
}

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;
}