Condition的await()和signal()分析

Condition使用Node来封装需要控制的线程，Node具有以下状态：

• static final Node SHARED = new Node();    // 共享模式
• static final Node EXCLUSIVE = null;    // 独占模式
• static final int CANCELLED =  1;    // 线程超时或被中断，需要取消该Node
• static final int SIGNAL    = -1;    // 线程等待被唤醒
• static final int CONDITION = -2;    // 条件状态，处于等待队列中
• static final int PROPAGATE = -3;    // 在共享模式中使用表示获得的同步状态会被传播
  

状态会保存在waitStatus属性中，默认值为0。

public final void await() throws InterruptedException {

            if (Thread.interrupted())    // 判断线程是否被标识为中断的
                throw new InterruptedException();
            Node node = addConditionWaiter();    // 创建一个需要条件控制的节点，并加入Condition队列
            int savedState = fullyRelease(node);    // 释放当前线程的对锁的拥有权
            int interruptMode = 0;
            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)
                reportInterruptAfterWait(interruptMode);

        }
方法将绑定了当前Condition的线程进行等待操作，并释放锁。

    private Node addConditionWaiter() {
            Node t = lastWaiter;    // 获取末尾的节点
            // If lastWaiter is cancelled, clean out.
            if (t != null && t.waitStatus != Node.CONDITION) {    // 如果存在末尾的节点，并且状态不等于-2
                unlinkCancelledWaiters();
                t = lastWaiter;
            }
            Node node = new Node(Thread.currentThread(), Node.CONDITION);    // 为当前线程创建一个处于等待状态的Node
            if (t == null)    // 如果不存在末尾的节点，则设置当前线程为首节点
                firstWaiter = node;
            else
                t.nextWaiter = node;    // 否则将node设置为末尾的节点
            lastWaiter = node;    // 刷新末尾节点
            return node;
        }
方法为当前线程生成一个状态为CONDITION的Node，并加入队列末尾。

有await()让线程阻塞，就会有signal()让线程继续运行：
public final void signal() {
            if (!isHeldExclusively())    // 当前线程不拥有锁，抛出异常
                throw new IllegalMonitorStateException();
            Node first = firstWaiter;    // 获取Condition队列首个Node
            if (first != null)
                doSignal(first);    // 唤醒Condition队列的首个Node，把当前节点从condition队列迁移到同步队列中
        }

执行await()和signal()的线程必须先执行lock()方法进行同步，不然会抛出IllegalMonitorStateException()异常。

 private void doSignal(Node first) {
            do {
                if ( (firstWaiter = first.nextWaiter) == null)    // 如果condition队列的第二个节点为null，则把末尾节点设为null
                    lastWaiter = null;
                first.nextWaiter = null;
            } while (!transferForSignal(first) &&    // transferForSignal把当前节点从condition队列迁移到同步队列中，并设置waitStatus为SIGNAL
                     (first = firstWaiter) != null);

        }

 final boolean transferForSignal(Node node) {
        // 如果不能更改waitStatus，则该Node已被取消
        if (!compareAndSetWaitStatus(node, Node.CONDITION, 0))
            return false;

        Node p = enq(node);    // 将Node设置到同步队列的末尾
        int ws = p.waitStatus;
        if (ws > 0 || !compareAndSetWaitStatus(p, ws, Node.SIGNAL))
            LockSupport.unpark(node.thread);    // 唤醒线程
        return true;
    }
把Node放到同步队列的末尾，同时唤醒线程，然后和其他线程竞争锁的拥有权，但是signal()一次只能唤醒一个wait状态的线程，如果想把所有的wait线程都唤醒，则需要使用signalAll()，此方法会获取首个处于wait状态的Node，然后执行doSignalAll()。核心代码如下：

private void doSignalAll(Node first) {
            lastWaiter = firstWaiter = null;
            do {    // 遍历condition队列，并把已唤醒的Node设置为Null
                Node next = first.nextWaiter; 
                first.nextWaiter = null;
                transferForSignal(first);    // transferForSignal把当前节点从condition队列迁移到同步队列中，并设置waitStatus为SIGNAL
                first = next;
            } while (first != null);
        }
直接获取首个处于wati状态的Node，然后遍历整个队列，解除wait状态。