java基础：java.util.concurrent.locks.Condition

前言

在BlockingQueue队列中，每当我们put和take元素时，当队列满时或空时，各自会阻塞，而这个阻塞方用的是Condition接口的await();与我们平时直接用Object的wait方法和notify方法大同小异，我将通过源码和一些例子来分析Condtion用法和它与Object的wait、notify之间的区别和各自的优点。

在JDK源码中有段解释是：
The key property that waiting for a condition provides is that it atomically releases the associated lock and suspends the current thread, just like Object.wait
Condition执行等待（阻塞）方法提供的关键属性是，它会原子地释放相关的锁，并挂起当前线程，就像object.wait一样。

由于Condition是一个接口，而实现这个接口的ConditionObject又是AbstractQueuedLongSynchronizer抽象类的内部类，所以，得到这个ConditionObject实例并不能直接newCondition，而是配合着AbstractQueuedLongSynchronizer方法使用，所以理解这层关系成了理解Condition的关键。

简单用法

下面是模拟Blockqueue写的一个关于Condition的用法，关于BlockQueue，大家可以参考java基础：java.util.concurrent.BlockingQueue，用法与wait和notify类似。
创建一个队列，生产者往队列里put元素，如果队列已满，则阻塞，无法继续添加数据。然后再有一个消费者取数据，每取出一个数据，就用Condition.signal()方法唤醒阻塞方法，让生产者可以继续put元素。
当队列为空时，再取元素就会开成阻塞，当再有生产者往队列里加数据时，也会唤醒取数据的阻塞方法。这样就形成了带阻塞的数据模型。

package com.company.condition;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

/**
 * Created by wxwall on 2017/5/31.
 */
public class ConditionDemo {


    public static void main(String[] args) throws InterruptedException {
        //创建一个队列
        Queue queue = new Queue(3);
        //创建一个生产者，往队列里put数据
        Produce produce = new Produce(queue);
        Thread t = new Thread(produce);
        t.start();
        //Thread.sleep(3000);
        //创建一个消费者，用来取数据
        Consumer consumer = new Consumer(queue);
        Thread t1 = new Thread(consumer);
        t1.start();
    }
    static class Produce implements Runnable{
        Queue q = null;
        public Produce(Queue queue){
            this.q = queue;
        }
        @Override
        public void run() {
            try {
                long begin = System.currentTimeMillis();
                for (int i = 0;i<10;i++){
                    q.put(new String("aa"));
                    q.put(new String("bb"));
                    q.put(new String("cc"));
                }
                System.out.println("耗时：" + (System.currentTimeMillis() - begin));

            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    static class Consumer implements Runnable{
        Queue q = null;
        public Consumer(Queue queue){
            this.q = queue;
        }
        @Override
        public void run() {
            try {
                for (int i = 0 ;i<10;i ++){
                    Object obj1 = q.take();
                    Object obj2 = q.take();
                    Object obj3 = q.take();
                    System.out.println((String)obj1.toString()  + "   " + (String)obj2.toString() + "   " + (String)obj3.toString());
                }

            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 创建一个简单的数组队列
     */
    private static class Queue {
        ReentrantLock lock = new ReentrantLock();
        Condition condition = lock.newCondition();
        Object obj [] = null;
        private int size = 0;
        private int consInt = 0;

        public Queue(Integer obj){
            this.obj = new Object[obj];
        }

        //往队列里加数据
        public void put(Object obj) throws InterruptedException {
            //获得锁
            lock.lock();
            try {
                if(size > this.obj.length -1){
                    //如果队列满了就阻塞
                    condition.await();
                }
                this.obj[size] = obj;
                size ++;
                //如果队列空了，添加元素后要通知take，唤醒condition
                condition.signal();
            }finally {
                lock.unlock();
            }
        }

        public Object take(){
            lock.lock();
            try{
                if(size == 0 ){
                    try {
                        condition.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                Object obj = this.obj[size - 1];
                size --;
                condition.signal();
                return obj;
            }finally {
                lock.unlock();
            }
        }
    }
}

执行结果（因为没有用链表实现队列，所以结果并不是FIFO形式）

cc   bb   aa
cc   bb   aa
cc   bb   aa
cc   bb   aa
cc   bb   aa
cc   bb   aa
aa   aa   cc
cc   bb   bb
cc   bb   aa
cc   bb   aa
耗时：1

另外注意的一点是，BlockingQueue的实现ArrayBlockingQueue的put方法和take方法，分别用的是两个不同的condition实例，源码如下：

    /** Condition for waiting takes */
    private final Condition notEmpty;
    /** Condition for waiting puts */
    private final Condition notFull;

上面代码模型如图所示：

Paste_Image.png

下面用实现一个简单的wait、notify模型

package com.company.condition;


import java.util.concurrent.locks.Condition;

/**
 * Created by wxwall on 2017/5/29.
 */
public class ConditionTest {

    public static void main(String[] args) throws InterruptedException {
        Condition condition;
        Integer a = 2;
        Thread t1 = new Thread(new ThreadCondition(a));
        Thread t2 = new Thread(new ThreadCondition(a));
        t1.start();
        t2.start();
    }

    public static class ThreadCondition implements Runnable{
        Integer a = 0;
        public ThreadCondition(Integer a){
            this.a = a;
        }
        @Override
        public void run() {
            try {
                int  i = 0;
                while(i < 3){
                    synchronized (a){
                        a.notify();
                        System.out.println(Thread.currentThread().getName());
                        a.wait();
                        System.out.println("wait被唤醒");
                    }
                    i++;
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

下面是输出结果：

Thread-0
Thread-1
wait被唤醒
Thread-0
wait被唤醒
Thread-1
wait被唤醒
Thread-0
wait被唤醒
Thread-1
wait被唤醒

与notify、wait方法的区别

Condition 将 Object 监视器方法（wait、notify 和 notifyAll）分解成截然不同的对象，以便通过将这些对象与任意 Lock 实现组合使用，为每个对象提供多个等待 set （wait-set）。其中，Lock 替代了 synchronized 方法和语句的使用，Condition 替代了 Object 监视器方法的使用。
在同一个monitor中Conditioin可以存在多个实例，在生产者和消费者模型里比较常见。
而wait，notify和notifyAll必须在同步块或者同步方法中进行（synchronized块或者synchronized方法）

• wait()、notify()和notifyAll()方法是本地方法，并且为final方法，无法被重写。

• 调用某个对象的wait()方法能让当前线程阻塞，并且当前线程必须拥有此对象的monitor（即锁）

• 调用某个对象的notify()方法能够唤醒一个正在等待这个对象的monitor的线程，如果有多个线程都在等待这个对象的monitor，则只能唤醒其中一个线程；

• 调用notifyAll()方法能够唤醒所有正在等待这个对象的monitor的线程；

JDK原文整理如下

Condition 实现可以提供不同于 Object 监视器方法的行为和语义，比如受保证的通知排序，或者在执行通知时不需要保持一个锁。如果某个实现提供了这样特殊的语义，则该实现必须记录这些语义。
注意，Condition 实例只是一些普通的对象，它们自身可以用作 synchronized 语句中的目标，并且可以调用自己的 wait 和 notification 监视器方法。获取 Condition 实例的监视器锁或者使用其监视器方法，与获取和该 Condition 相关的 Lock或使用其 waiting和 signalling 方法没有什么特定的关系。为了避免混淆，建议除了在其自身的实现中之外，切勿以这种方式使用 Condition 实例。

为何这三个不是Thread类声明中的方法，而是Object类中声明的方法（当然由于Thread类继承了Object类，所以Thread也可以调用者三个方法）？

由于每个对象都拥有monitor（即锁），所以让当前线程等待某个对象的锁，当然应该通过这个对象来操作了。而不是用当前线程来操作，因为当前线程可能会等待多个线程的锁，如果通过线程来操作，就非常复杂了。