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对应的期待队列），成果就是将期待队列中所有节点全副挪动到同步队列中，并唤醒每个节点的线程。