private final boolean parkAndCheckInterrupt() {
  // 进入休息区 unpark就是从休息区唤醒
    LockSupport.park(this);
    return Thread.interrupted();
}

    private void cancelAcquire(Node node) {
        // 如果节点不存在，无视该方法
        if (node == null)
            return;
    // 设置该节点不关联任何线程，即虚节点
        node.thread = null;
        // 跳过被取消的前驱结点们
        Node pred = node.prev;
        while (pred.waitStatus > 0)
            node.prev = pred = pred.prev;
        // predNext 是要取消拼接的明显节点。如果没有，以下情况 CAS 将失败，在这种情况下，我们输掉了和另一个cancel或signal的竞争，因此无需采取进一步措施。
        // 通过前驱节点，跳过取消状态的node
        Node predNext = pred.next;
        // 这里可以使用无条件写代替CAS，把当前node的状态设置为CANCELLED
        // 在这个原子步骤之后，其他节点可以跳过我们。
        // 在此之前，我们不受其他线程的干扰。
        node.waitStatus = Node.CANCELLED;
        // 如果是 tail 节点, 移除自身
        // 如果当前节点是尾节点，将从后往前的第一个非取消状态的节点设置为尾节点
  // 更新失败的话，则进入else，如果更新成功，将tail的后继节点设置为null
        if (node == tail && compareAndSetTail(node, pred)) {
            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.
            int ws;
            if (pred != head &&
                ((ws = pred.waitStatus) == Node.SIGNAL ||
                 (ws <= 0 && compareAndSetWaitStatus(pred, ws, Node.SIGNAL))) &&
                pred.thread != null) {
                Node next = node.next;
                if (next != null && next.waitStatus <= 0)
                    compareAndSetNext(pred, predNext, next);
            } else {
                unparkSuccessor(node);
            }
            node.next = node; // 辅助 GC
        }
    }

private boolean doAcquireNanos(int arg, long nanosTimeout)
        throws InterruptedException {
    if (nanosTimeout <= 0L)
        return false;
    // 截止时间    
    final long deadline = System.nanoTime() + nanosTimeout;
    // 将当前的线程封装成 Node 加入到同步对列里面
    final Node node = addWaiter(Node.EXCLUSIVE);
    boolean failed = true;
    try {
        for (;;) {
          // 获取当前节点的前驱节点(当一个n在同步对列里, 并且没有获取
          // lock 的 node 的前驱节点不可能是 null)
            final Node p = node.predecessor();
            // 判断前驱节点是否为 head
            // 前驱节点是 head, 存在两种情况 
            //  (1) 前驱节点现在持有锁 
            //  (2) 前驱节点为 null, 已经释放锁, node 现在可以获取锁
            // 则再调用 tryAcquire 尝试获取
            if (p == head && tryAcquire(arg)) {
                setHead(node);
                p.next = null; // 辅助GC
                failed = false;
                return true;
            }
            // 计算剩余时间
            nanosTimeout = deadline - System.nanoTime();
            // 超时，直接返回 false
            if (nanosTimeout <= 0L)
                return false;
            // 调用 shouldParkAfterFailedAcquire 判断是否需要阻塞
            if (shouldParkAfterFailedAcquire(p, node) &&
              // 若未超时, 并且大于 spinForTimeoutThreshold, 则将线程挂起
                nanosTimeout > spinForTimeoutThreshold)
                LockSupport.parkNanos(this, nanosTimeout);
            if (Thread.interrupted())
                throw new InterruptedException();
        }
    } finally {
      // 在整个获取中出错(中断/超时等)，则清除该节点
        if (failed)
            cancelAcquire(node);
    }
}

private void doAcquireSharedInterruptibly(int arg)
    throws InterruptedException {
    // 创建"当前线程"的 Node 节点，且其中记录的共享锁
    final Node node = addWaiter(Node.SHARED);
    boolean failed = true;
    try {
        for (;;) {
          // 获取前驱节点
            final Node p = node.predecessor();
            // 如果前驱节点是头节点
            if (p == head) {
              // 尝试获取锁(由于前驱节点为头节点，所以可能此时前驱节点已经成功获取了锁，所以尝试获取一下)
                int r = tryAcquireShared(arg);
                // 获取锁成功
                if (r >= 0) {
                    setHeadAndPropagate(node, r);
                    p.next = null; // 辅助 GC
                    failed = false;
                    return;
                }
            }
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                throw new InterruptedException();
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}