并发编程——详解 AQS CLH 锁

public final void acquireQueued(int arg) {
    // 当 tryAcquire 返回 true 就说明获取到锁了，直接结束。
    // 反之，返回 false 的话，就需要执行后面的方法。
    if (!tryAcquire(arg) &&
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
}

private Node addWaiter(Node mode) {
    // 创建一个独占类型的节点
    Node node = new Node(Thread.currentThread(), mode);
    // Try the fast path of enq; backup to full enq on failure
    Node pred = tail;
    // 如果 tail 节点不是 null，就将新节点的 pred 节点设置为 tail 节点。
    // 并且将新节点设置成 tail 节点。
    if (pred != null) {
        node.prev = pred;
        if (compareAndSetTail(pred, node)) {
            pred.next = node;
            return node;
        }
    }
    // 如果 tail 节点是  null，或者 CAS 设置 tail 失败。
    // 在 enq 方法中处理
    enq(node);
    return node;
}

private Node enq(final Node node) {
    for (;;) {
        Node t = tail;
        // 如果 tail 是 null，就创建一个虚拟节点，同时指向 head 和 tail，称为 初始化。
        if (t == null) { // Must initialize
            if (compareAndSetHead(new Node()))
                tail = head;
        } else {// 如果不是 null
            // 和 上个方法逻辑一样，将新节点追加到 tail 节点后面，并更新队列的 tail 为新节点。
            // 只不过这里是死循环的，失败了还可以再来 。
            node.prev = t;
            if (compareAndSetTail(t, node)) {
                t.next = node;
                return t;
            }
        }
    }
}

// 这里返回的节点是新创建的节点，arg 是请求的数量
final boolean acquireQueued(final Node node, int arg) {
    boolean failed = true;
    try {
        boolean interrupted = false;
        for (;;) {
            // 找上一个节点
            final Node p = node.predecessor();
            // 如果上一个节点是 head ，就尝试获取锁
            // 如果 获取成功，就将当前节点设置为 head，注意 head 节点是永远不会唤醒的。
            if (p == head && tryAcquire(arg)) {
                setHead(node);
                p.next = null; // help GC
                failed = false;
                return interrupted;
            }
            // 在获取锁失败后，就需要阻塞了。
            // shouldParkAfterFailedAcquire ---> 检查上一个节点的状态，如果是 SIGNAL 就阻塞，否则就改成 SIGNAL。
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    int ws = pred.waitStatus;
    //  如果他的上一个节点的 ws 是 SIGNAL，他就需要阻塞。
    if (ws == Node.SIGNAL)
        // 阻塞
        return true;
    // 前任被取消。 跳过前任并重试。
    if (ws > 0) {
        do {
            // 将前任的前任 赋值给 当前的前任
            node.prev = pred = pred.prev;
        } while (pred.waitStatus > 0);
        // 将前任的前任的 next 赋值为 当前节点
        pred.next = node;
    } else { 
        // 如果没有取消 || 0 || CONDITION || PROPAGATE，那么就将前任的 ws 设置成 SIGNAL.
        // 为什么必须是 SIGNAL 呢？
        // 答：希望自己的上一个节点在释放锁的时候，通知自己（让自己获取锁）
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
    }
    // 重来
    return false;
}

public final boolean release(int arg) {
    if (tryRelease(arg)) {
        Node h = head;
        // 所有的节点在将自己挂起之前，都会将前置节点设置成 SIGNAL，希望前置节点释放的时候，唤醒自己。
        // 如果前置节点是 0 ，说明前置节点已经释放过了。不能重复释放了，后面将会看到释放后会将 ws 修改成0.
        if (h != null && h.waitStatus != 0)
            unparkSuccessor(h);
        return true;
    }
    return false;
}

private void unparkSuccessor(Node node) {
    int ws = node.waitStatus;
    if (ws < 0)
        // 将 head 节点的 ws 改成 0，清除信号。表示，他已经释放过了。不能重复释放。
        compareAndSetWaitStatus(node, ws, 0);

    Node s = node.next;
    // 如果 next 是 null，或者 next 被取消了。就从 tail 开始向上找节点。
    if (s == null || s.waitStatus > 0) {
        s = null;
        // 从尾部开始，向前寻找未被取消的节点，直到这个节点是 null，或者是 head。
        // 也就是说，如果 head 的 next 是 null，那么就从尾部开始寻找，直到不是 null 为止，找到这个 head 就不管了。
        // 如果是 head 的 next 不是 null，但是被取消了，那这个节点也会被略过。
        for (Node t = tail; t != null && t != node; t = t.prev)
            if (t.waitStatus <= 0)
                s = t;
    }
    // 唤醒 head.next 这个节点。
    // 通常这个节点是 head 的 next。
    // 但如果 head.next 被取消了，就会从尾部开始找。
    if (s != null)
        LockSupport.unpark(s.thread);
}