java并发编程系列之Condition的使用

Condition是做什么用的了？Condition是用来实现线程间通信的，说到这，可能很多人都想到了wait和notify以及notifyAll，没错，Condition的功能和他们类似，只是功能更强而已，下面我们就来学习一下线程间通过Condition来实现通信。

Condition也是jdk1.5并发包下的一个接口，原型如下：

public interface Condition {    // 相当于Object的wait方法    void await() throws InterruptedException;    void awaitUninterruptibly();long awaitNanos(long nanosTimeout) throws InterruptedException;// 在给定的时间，阻塞    boolean await(long time, TimeUnit unit) throws InterruptedException;boolean awaitUntil(Date deadline) throws InterruptedException;// 相当于Object的notify方法void signal();// 相当于Object的notifyAll方法    void signalAll();}

Condition使用说明：

· Condition是个接口，基本的方法就是await()和signal()方法；

· Condition依赖于Lock接口，生成一个Condition的基本代码是lock.newCondition() 

·  调用Condition的await()和signal()方法，都必须在lock保护之内，就是说必须在lock.lock()和lock.unlock之间才可以使用

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

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

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

下面用官网上的一个示例来说明Condition的使用，代码如下：

public class ConditionDemo {// 可重入锁final Lock lock = new ReentrantLock();// 写线程条件final Condition notFull  = lock.newCondition();// 读线程条件final Condition notEmpty = lock.newCondition();// 缓存队列的深度final Object[] items = new Object[100];// 写索引int putptr = 0;// 读索引int takeptr = 0;// 缓存队列中存在的数据个数int count = 0;/** * 描述：模拟往队列里面放对象 */public void put(Object x) throws InterruptedException {System.out.println("获取写锁！");// 上锁lock.lock();try {/* *  如果当前队列里面的对象个数和队列的深度相同，说明队列已经满了，准备阻塞写线程 *  注意，此处用while而不用if，是为了防止假唤醒 */while (count == items.length){System.out.println("队列已满，阻塞写线程!");// 阻塞写线程notFull.await();}// 写数据System.out.println("写入的数据为："+x);items[putptr] = x;// 如果当前的写索引和队列的深度相同，说明队列已经写满了，所以需要从索引0开始写数据if (++putptr == items.length){putptr = 0;}// 队列中的数据个数递增++count;// 唤醒读线程notEmpty.signal();}finally {System.out.println("释放写锁!");// 释放锁lock.unlock();}}/** * 描述：模拟从队列里面取对象 */public Object take() throws InterruptedException {System.out.println("获取读锁！");// 上锁lock.lock();try {// 如果当前队列里面没有数据，阻塞读线程，此处用while原因同上while (count == 0){System.out.println("队列为空，阻塞读线程!");// 阻塞读线程notEmpty.await();}// 读数据Object x = items[takeptr];// 如果读索引和队列的深度相同，说明已经读到了队列的最后一个数据，需要从0开始读if (++takeptr == items.length){takeptr = 0;}// 队列里面的个数递减--count;// 唤醒写线程notFull.signal();// 返回读取的对象return x;}finally {System.out.println("释放读锁！");// 释放锁lock.unlock();}}public static void main(String[] args) {final ConditionDemo demo = new ConditionDemo();// 新建N个写线程，且写比对快ExecutorService put = Executors.newCachedThreadPool();put.execute(new Runnable() {@Overridepublic void run() {for(int i=0; i<399; i++){try {demo.put("chhliu"+i);} catch (InterruptedException e) {e.printStackTrace();}}}});// 新建N个读线程，读比写慢ExecutorService take = Executors.newCachedThreadPool();take.execute(new Runnable() {@Overridepublic void run() {while(true){try {// 模拟长时间读Thread.sleep(200);String message = (String) demo.take();System.out.println("读取的数据为："+message);} catch (InterruptedException e) {e.printStackTrace();}}}});}}

首先，我们先让写快，读慢，当写的线程将缓存队列写满之后，写线程就会被阻塞，只有当读线程从队列中读取数据之后，写线程才会被唤醒，测试结果如下：

写入的数据为：chhliu98释放写锁!获取写锁！写入的数据为：chhliu99释放写锁!获取写锁！队列已满，阻塞写线程!获取读锁！读取的数据为：chhliu0释放读锁！写入的数据为：chhliu100释放写锁!获取写锁！队列已满，阻塞写线程!.......读取的数据为：chhliu298释放读锁！获取读锁！队列为空，阻塞读线程!程序首先会一直写数据，直到队列写满，然后会阻塞写线程，唤醒读线程，读线程读取数据之后，队列未满，然后会唤醒写线程，这样依次交替进行，等所有的数据都读取完之后，会阻塞读线程。

从上面的例子中，我们可以看到，我们同时使用了多个Condition，这在传统的线程通信中是不可能看到的现象，假设缓存队列中已经存满，那么阻塞的肯定是写线程，唤醒的肯定是读线程，相反，阻塞的肯定是读线程，唤醒的肯定是写线程，那么假设只有一个 Condition会有什么效果呢，缓存队列中已经存满，这个Lock不知道唤醒的是读线程还是写线程了，如果唤醒的是读线程，皆大欢喜，如果唤醒的是写 线程，那么线程刚被唤醒，又被阻塞了，这时又去唤醒，这样就浪费了很多时间。