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() {
            @Override
            public 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() {
            @Override
            public 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不知道唤醒的是读线程还是写线程了，如果唤醒的是读线程，皆大欢喜，如果唤醒的是写 线程，那么线程刚被唤醒，又被阻塞了，这时又去唤醒，这样就浪费了很多时间。
--------------------- 
作者：牛奋lch 
来源：CSDN 
原文：https://blog.csdn.net/liuchuanhong1/article/details/53539597 
版权声明：本文为博主原创文章，转载请附上博文链接！