Java 中的 condition 类

Condition 是在 java 1.5 中才呈现的，它用来代替传统的 Object 的 wait()、notify()实现线程间的合作，

相比应用 Object 的 wait()、notify()，应用 Condition 的 await()、signal()这种形式实现线程间合作更加平安和高效。

因而通常来说，线程通信的实现比拟举荐应用 Condition

• Condition 是个接口，根本的办法就是 await()和 signal()办法；
• Condition 依赖于 Lock 接口，生成一个 Condition 的根本代码是lock.newCondition()
• 调用 Condition 的 await()和 signal()办法，都必须在 lock 爱护之内，就是说必须在 lock.lock()和 lock.unlock 之间才能够应用，因为外部会做开释锁的操作，如果不是在 lock 和 unlock 之间应用，会报错java.lang.IllegalMonitorStateException

Conditon 中的 await()对应 Object 的 wait()；

Condition 中的 signal()对应 Object 的 notify()；

Condition 中的 signalAll()对应 Object 的 notifyAll()。

简略 demo

Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();
    public void conditionWait() throws InterruptedException {lock.lock();
        try {condition.await();
        } finally {lock.unlock();
        }
    }
    public void conditionSignal() throws InterruptedException {lock.lock();
        try {condition.signal();
        } finally {lock.unlock();
        }
    }

个别都会将 Condition 对象作为成员变量。当调用 await()办法后，以后线程会开释锁并在此期待，而其余线程调用 Condition 对象的 signal()办法，告诉以后线程后，以后线程才从 await()办法返回，并且在返回前曾经获取了锁。

深刻了解 demo

获取一个 Condition 必须通过 Lock 的 newCondition()办法。上面通过一个有界队列的示例来深刻理解 Condition 的应用形式。有界队列是一种非凡的队列，当队列为空时，队列的获取操作将会阻塞获取线程，直到队列中有新增元素，当队列已满时，队列的插入操作将会阻塞插入线程，直到队列呈现“空位”

public class BoundedQueue<T> {private Object[] items;

    // 增加的下标，删除的下标和数组以后数量
    private int addIndex,removeIndex,count;

    private Lock lock = new ReentrantLock();

    private Condition notEmpty = lock.newCondition();

    private Condition notFull = lock.newCondition();

    public BoundedQueue(int size){items = new Object[size];
    }

    /**
     * 增加一个元素，如果数组满，则增加线程进入期待状态，直到有 "空位"
     * @author fuyuwei
     * 2017 年 5 月 21 日 下午 6:14:55
     * @param t
     * @throws InterruptedException
     */
    public void add(T t) throws InterruptedException{lock.lock();
        try{while(count == items.length){notFull.await();
            }
            items[addIndex] = t;
            if(++addIndex == items.length)
                addIndex = 0;
            ++count;
            notEmpty.signal();}finally{lock.unlock();
        }
    }

    /**
     * 由头部删除一个元素，如果数组空，则删除线程进入期待状态，直到有新增加元素
     * @author fuyuwei
     * 2017 年 5 月 21 日 下午 6:20:54
     * @return
     * @throws InterruptedException
     */
    @SuppressWarnings("unchecked")
    public T remove() throws InterruptedException{lock.lock();
        try{while(count == 0)
                notEmpty.await();
            Object x = items[removeIndex];
            if(++removeIndex == items.length)
                removeIndex = 0;
            --count;
            notFull.signal();
            return (T)x;
        }finally{lock.unlock();
        }
    }
}

首先须要取得锁，目标是确保数组批改的可见性和排他性。当数组数量等于数组长度时，示意数组已满，则调用 notFull.await()，以后线程随之开释锁并进入期待状态。如果数组数量不等于数组长度，示意数组未满，则增加元素到数组中，同时告诉期待在 notEmpty 上的线程，数组中曾经有新元素能够获取。在增加和删除办法中应用 while 循环而非 if 判断，目标是避免过早或意外的告诉，只有条件合乎才可能退出循环。

原理

期待队列

期待队列是一个 FIFO 的队列，在队列中的每个节点都蕴含了一个线程援用，该线程就是在 Condition 对象上期待的线程，如果一个线程调用了 Condition.await()办法，那么该线程将会开释锁、结构成节点退出期待队列并进入期待状态
一个 Condition 蕴含一个期待队列，Condition 领有首节点（firstWaiter）和尾节点（lastWaiter）。以后线程调用 Condition.await()办法，将会以以后线程结构节点，并将节点从尾部退出期待队列，期待队列的根本构造如下图所示

如图所示，Condition 领有首尾节点的援用，而新增节点只须要将原有的尾节点 nextWaiter 指向它，并且更新尾节点即可。上述节点援用更新的过程并没有应用 CAS 保障，起因在于调用 await()办法的线程必然是获取了锁的线程，也就是说该过程是由锁来保障线程平安的。在 Object 的监视器模型上，一个对象领有一个同步队列和期待队列，而并发包中的 Lock（更确切地说是同步器）领有一个同步队列和多个期待队列，其对应关系如下图所示

期待

调用 Condition 的 await()办法（或者以 await 结尾的办法），会使以后线程进入期待队列并开释锁，同时线程状态变为期待状态。当从 await()办法返回时，以后线程肯定获取了 Condition 相关联的锁。如果从队列（同步队列和期待队列）的角度看 await()办法，当调用 await()办法时，相当于同步队列的首节点（获取了锁的节点）挪动到 Condition 的期待队列中

public final void await() throws InterruptedException {if (Thread.interrupted())
            throw new InterruptedException();
        // 以后线程退出期待队列
        Node node = addConditionWaiter();
        // 开释同步状态，也就是开释锁
        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)
            unlinkCancelledWaiters();
        if (interruptMode != 0)
            reportInterruptAfterWait(interruptMode);
    }

调用该办法的线程胜利获取了锁的线程，也就是同步队列中的首节点，该办法会将以后线程结构成节点并退出期待队列中，而后开释同步状态，唤醒同步队列中的后继节点，而后以后线程会进入期待状态。当期待队列中的节点被唤醒，则唤醒节点的线程开始尝试获取同步状态。如果不是通过其余线程调用 Condition.signal()办法唤醒，而是对期待线程进行中断，则会抛出 InterruptedException

告诉

调用 Condition 的 signal()办法，将会唤醒在期待队列中等待时间最长的节点（首节点），在唤醒节点之前，会将节点移到同步队列中

public final void signal() {if (!isHeldExclusively())
            throw new IllegalMonitorStateException();
        Node first = firstWaiter;
        if (first != null)
            doSignal(first);
    }

调用该办法的前置条件是以后线程必须获取了锁，能够看到 signal()办法进行了 isHeldExclusively()查看，也就是以后线程必须是获取了锁的线程。接着获取期待队列的首节点，将其挪动到同步队列并应用 LockSupport 唤醒节点中的线程
节点从期待队列挪动到同步队列的过程如下图所示

通过调用同步器的 enq(Node node)办法，期待队列中的头节点线程平安地挪动到同步队列。当节点挪动到同步队列后，以后线程再应用 LockSupport 唤醒该节点的线程。被唤醒后的线程，将从 await()办法中的 while 循环中退出（isOnSyncQueue(Node node)办法返回 true，节点曾经在同步队列中），进而调用同步器的 acquireQueued()办法退出到获取同步状态的竞争中。胜利获取同步状态（或者说锁）之后，被唤醒的线程将从先前调用的 await()办法返回，此时该线程曾经胜利地获取了锁。

Condition 的 signalAll()办法，相当于对期待队列中的每个节点均执行一次 signal()办法（留神是这个 Condition 对应的期待队列），成果就是将期待队列中所有节点全副挪动到同步队列中，并唤醒每个节点的线程。