AQS之Condition

Lock lock = new ReentrantLock();
Condition condition = lock.newCondition();

new Thread(() -> {
    lock.lock();
    System.out.println(Thread.currentThread().getName() + " 开始处理任务");
    try {
        condition.await();
        System.out.println(Thread.currentThread().getName() + " 结束处理任务");
    } catch (InterruptedException e) {
        e.printStackTrace();
    } finally {
        lock.unlock();
    }
}).start();

new Thread(() -> {
    lock.lock();
    System.out.println(Thread.currentThread().getName() + " 开始处理任务");
    try {
        condition.signal();
        System.out.println(Thread.currentThread().getName() + " 结束处理任务");
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        lock.unlock();
    }
}).start();

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

final ConditionObject newCondition() {
    return new ConditionObject();
}

public class ConditionObject implements Condition, java.io.Serializable {
}

public final void await() throws InterruptedException {
    // 响应中断
    if (Thread.interrupted())
        throw new InterruptedException();
    
    // 向 Condition队列 添加一个尾节点
    Node node = addConditionWaiter();

    // 释放阻塞队列中的锁，及调用`release`方法释放锁，然后唤醒head节点的下一个节点
    int savedState = fullyRelease(node);
    int interruptMode = 0;

    // 判断该节点是否在阻塞队列中
    while (!isOnSyncQueue(node)) {
        // 如果不在阻塞队列中，这阻塞当前线程，等待 ConditionObject#signal 方法唤醒
        LockSupport.park(this);
        if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
            break;
    }

    // 通过执行 ConditionObject#signal 方法唤醒节点后，继续往下执行，这时候需要重新获取锁
    if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
        interruptMode = REINTERRUPT;
    if (node.nextWaiter != null) // clean up if cancelled
        unlinkCancelledWaiters();
    if (interruptMode != 0)
        reportInterruptAfterWait(interruptMode);
}

private Node addConditionWaiter() {
    Node t = lastWaiter;
    // If lastWaiter is cancelled, clean out.
    if (t != null && t.waitStatus != Node.CONDITION) {
        // 将 `Condition队列` 中 `waitStatus != Node.CONDITION` 的节点删除
        unlinkCancelledWaiters();
        // 删除之后可能尾节点已经改变了，需要重新赋值
        t = lastWaiter;
    }

    Node node = new Node(Thread.currentThread(), Node.CONDITION);
    if (t == null)
        // 如果Condition队列为空，则设置头指针
        firstWaiter = node;
    else
        // 如果Condition队列不为空，让目前的尾节点的的后驱指针指向它
        t.nextWaiter = node;
    // 将当前节点设置为尾节点
    lastWaiter = node;
    return node;
}

public final void signal() {
    // 当前线程持有锁才能唤醒首节点
    if (!isHeldExclusively())
        throw new IllegalMonitorStateException();
    
    Node first = firstWaiter;
    if (first != null)
        // 唤醒首节点
        doSignal(first);
}

private void doSignal(Node first) {
    do {
        if ( (firstWaiter = first.nextWaiter) == null)
            lastWaiter = null;
        // 脱离 Condition队列 首节点 help GC
        first.nextWaiter = null;
    } while (!transferForSignal(first) &&
                (first = firstWaiter) != null);
}

final boolean transferForSignal(Node node) {
    /*
        * If cannot change waitStatus, the node has been cancelled.
        */
    if (!compareAndSetWaitStatus(node, Node.CONDITION, 0))
        return false;


    // 将Condition队列中的首节点添加到阻塞队列的尾部， end方法返回的是入参的前驱节点， 这将会导致ConditionObject#await方法中的 `!isOnSyncQueue(node)` 不成立
    Node p = enq(node);
    int ws = p.waitStatus;
    if (ws > 0 || !compareAndSetWaitStatus(p, ws, Node.SIGNAL))
        // 唤醒调用 ConditionObject#await 方法的线程
        LockSupport.unpark(node.thread);
    return true;
}
    ```