AQS核心流程解析cancelAcquire方法

private void cancelAcquire(Node node) {
    // Ignore if node doesn't exist
    if (node == null)
        return;
    // 当前节点的线程指向置为null
    node.thread = null;
    // 协同取消的处理。
    // 这里是判断当前节点的上一个节点的状态是否是取消状态(状态大于0只有是取消状态)
    // 如果上一个节点是取消状态，那么继续往上遍历，直到找到状态为小于0的状态节点。
    // 并且把当前节点的prev指向非取消节点。
    Node pred = node.prev;
    while (pred.waitStatus > 0)
        node.prev = pred = pred.prev;
    // 得到没有取消节点的下一个节点。
    Node predNext = pred.next;
    // 因为当前cancelAcquire()方法就是取消的处理
    // 所以将当前节点设置为取消状态。
    node.waitStatus = Node.CANCELLED;
    // 如果当前取消的节点是tail节点，也就是最后一个节点
    // 那么就把tail指针指向上面while循环遍历出的prev节点(因为要指向一个没有被取消的节点)。
    if (node == tail && compareAndSetTail(node, pred)) {
        // help GC
        // 为什么说help GC呢？
        // 因为把prev的next节点设置为null，
        // 这样GC ROOT扫描发现没有根节点的引用。
        compareAndSetNext(pred, predNext, null);
    } else {
        // 走到else代表当前节点不是tail节点，或者是cas操作的时候tail发生了变化
        // 如果不是tail节点，不能直接把tail节点指向到上面while循环得出的prev节点
        int ws;
        // 这里是的if代码块，是为了尝试一次，如果不成功再去复杂的处理。
        // 这里的if判断条件如下：
            // 1.如果上面while循环得到的prev节点不是head节点
            // 2.如果上面while循环得到的prev节点为-1，如果不为-1，cas改变成-1也。
            // 3.如果上面while循环得到的rpev节点的线程指向不为null(如果为null代表在取消的过程中)
        // 因为&&是拼接，所以上面任意一个条件为false就会进入到else条件中。
        if (pred != head &&
            ((ws = pred.waitStatus) == Node.SIGNAL ||
             (ws <= 0 && compareAndSetWaitStatus(pred, ws, Node.SIGNAL))) &&
            pred.thread != null) {
            // 进到这里代表这次尝试成功了。
            // 得到当前节点的下一个节点
            // 然后把前面while循环得到的prev节点的next指向当前节点的next节点。
            Node next = node.next;
            if (next != null && next.waitStatus <= 0)
                compareAndSetNext(pred, predNext, next);
        } else {
            // 直接唤醒当前节点的下一个节点。
            // 唤醒的目的是为了去执行shouldParkAfterFailedAcquire方法去处理取消节点。
            unparkSuccessor(node);
        }
        // 把当前节点的下一个节点指向自己.
        // help gc。
        node.next = node; // help GC
    }
}

// Skip cancelled predecessors
// 跳过已经被取消的节点
Node pred = node.prev;
while (pred.waitStatus > 0)
    node.prev = pred = pred.prev;

if (node == tail && compareAndSetTail(node, pred)) {
    compareAndSetNext(pred, predNext, null);
} else {
    // 后面讲
}

// 当前取消的节点不为tail节点的情况
int ws;
// if的逻辑可以理解为尝试一次。
// 代表while循环得到的prev节点不是head节点
// 代表while循环得到的prev节点是可唤醒的正常节点
// 节点while循环得到的prev节点不是待取消节点
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; // help GC

private void setHead(Node node) {
    head = node;
    node.thread = null;
    node.prev = null;
}

cancelAcquire
    |->unparkSuccessor(node当前取消节点)
        |->LockSupport.unpark(node.next.thread)
            |->shouldParkAfterFailedAcquire(node(取消的节点),node.next(取消的节点的下一个节点))

// Node pred 是取消的节点
// Node node 是取消的节点的下一个节点
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    // 
    int ws = pred.waitStatus;
    if (ws == Node.SIGNAL)
        return true;
    // 遍历找到一个非取消的节点
    // 并且把当前取消的节点的下一个节点与找到的非取消节点双向链起来。
    if (ws > 0) {
        do {
            // 往前走
            node.prev = pred = pred.prev;     // 链起来
        } while (pred.waitStatus > 0);        // 循环条件，所以找到一个小于等于0的节点就会退出
        pred.next = node;              // 链起来
    } else {
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
    }
    return false;
}