java并发学习--第六章 线程之间的通信

一、等待通知机制wait()与notify()

　　在线程中除了线程同步机制外，还有一个最重要的机制就是线程之间的协调任务。比如说最常见的生产者与消费者模式，很明显如果要实现这个模式，我们需要创建两个线程，一个生产者，一个消费者；有两个线程还不够，如果当生产者生产商品完成后，消费者如何知道要去消费生产的商品？为此JDK给我们可提供了wait()和notify()方法来进行线程之间的通信，从而解决了生产者完成后通知消费者进行消费的问题。

　　wait()和notify()是等待/唤醒机制，调用wait()方法可以让当前线程阻塞，只有当使用notify()时，才能让阻塞的线程继续执行。这样的机制就能够达道两个线程之间通信的功能。

　　我们来看看这两个方法：

　　1.wait()、notify()和notifyAll()方法是都是Objec类中自带的方法，因此所有的类都能够使用；

　　2.wait()、notify()和notifyAll()是native方法，无法被重写；

　　3.调用某个对象的wait()方法能让当前线程阻塞，并且当前线程必须拥有此对象的锁；

　　4.notify()方法能够唤醒一个正在等待的线程，如果有多个线程都在等待被唤醒，调用notify()方法只能随机唤醒一个方法；

　　5.调用notifyAll()方法能够唤醒所有正在等待的线程；

　　6.使用wait()、notify()和notifyAll()方法必须给线程加锁。

　　

　　我们用一个例子来介绍生成者与消费者模式：

　　生产者代码：

/**
 * 生产者，生成了10个商品后通知消费者消费
 */
public class Productor implements Runnable {

    @Override
    public void run() {
        //注意，这里生成者和消费者必须拿同一把锁，如果锁不相同，则这个机制无法成功使用
        synchronized (Job.value) {
            int i = 0;
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            while (i < 10) {
                //生产任务
                Job.value[i] = "商品:" + i;
                System.out.println("开始生产" + Job.value[i]);
                i++;
            }
            //生产完成后，唤醒所有线程，让消费者消费
            System.out.println("生产完成，开始消费");
            Job.value.notifyAll();
        }
    }
}

　　消费者代码：

/**
 * 消费者，等待生产者生成完商品后，才开始消费
 */
public class Consume implements Runnable {

    @Override
    public void run() {
        //注意，这里生产者和消费者必须拿同一把锁，如果锁不相同，则这个机制无法成功使用
        synchronized (Job.value) {
            //先判断有没商品生产，如果没有则开始等到生产者生成
            if (Job.value[0] == null) {
                try {
                    //等待生产
                    System.out.println("当前没有任务，等到生产");
                    Job.value.wait(0);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            //生产完成后，唤醒消费者后面的线程任务，消费商品
            for (String string : Job.value) {
                System.out.println("消费"+string);
            }
        }

    }
}

　　测试类：

public class Job {

    public static String value[]=new String[10] ;

    public static void main(String[] args) {

        Productor productor=new Productor();

        Consume consume=new Consume();

        new Thread(consume).start();
        new Thread(productor).start();

    }
}

　　运行的结果：

二、ReentrantLock中的等待唤醒机制Condition类

　　前面我们已经介绍了JDK中object自带的wait()与notify()方法，但是notify()在多线程环境下只能随机唤醒一个线程，这样的功能实在是有些鸡肋，为此在AQS（AbstractQueuedSynchronizer）中，为我们提供了一个Condition类实现了等待唤醒机制，并且Condition中唤醒的机制更加灵活。

　　Condition是在java 1.5中才出现的，它用来替代传统的Object的wait()、notify()实现线程间的协作，相比使用Object的wait()、notify()，使用Condition1的await()、signal()这种方式实现线程间协作更加安全和高效。因此通常来说比较推荐使用Condition。

　　Condition中常用的是await()和signal()方法，与wait()与notify一样，必须获取同一把锁才能实现等待唤醒机制，接下来我们就使用Condition中await()和signal()方法对我们的生产者和消费者模式进行改造：再增加一个消费者2，如果商品队列为空，两个消费者都进行等待，当生产者生产完成后唤醒消费者1，消费者1消费完成后唤醒消费者2，这样就能够指定唤醒一个线程

　　改造后的生成者：

/**
 * 生产者，生成了10个商品后唤醒所有线程
 */
public class Productor implements Runnable {
    //获取的锁
    Lock lock;
    //生成者和消费者1使用的等待/通知对象，用于绑定生成者和消费者1的等待/通知关系
    Condition condition;

    public Productor(Lock lock, Condition condition) {
        this.lock = lock;
        this.condition = condition;
    }

    @Override
    public void run() {
        //注意，这里生成者和消费者必须拿同一把锁，如果锁不相同，则这个机制无法成功使用
        lock.lock();
        int i = 0;
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        while (i < 5) {
            //生产任务
                Job.value[i] = "商品:" + i;
                System.out.println("开始生产" + Job.value[i]);
                i++;
        }
        //生产完成后，让消费者1消费
        System.out.println("生产完成，开始消费");
        condition.signal();
        //必须要释放锁
        lock.unlock();
    }
}

　　改造后的消费者1：

/**
 * 消费者1，等待生产者生成完商品后，才开始消费
 */
public class Consume implements Runnable {
    //获取的锁
    Lock lock;
    //生成者和消费者1使用的等待/通知对象，用于绑定生成者和消费者1的等待/通知关系
    Condition condition;
    //消费者1和消费者2使用的等待/通知对象，用于绑定消费者1和消费者2的等待/通知关系
    Condition consumeCondition;

    public Consume(Lock lock, Condition condition, Condition consumeCondition) {
        this.lock = lock;
        this.condition = condition;
        this.consumeCondition = consumeCondition;
    }

    @Override
    public void run() {
        //注意，这里生产者和消费者必须拿同一把锁，如果锁不相同，则这个机制无法成功使用
        lock.lock();
            //先判断有没商品生产，如果没有则开始等到生产者生成
            if (Job.value[0] == null) {
                try {
                    //等待生产
                    System.out.println("我是消费者1当前没有任务，等待生产");
                    condition.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            //生产完成后，唤醒消费者后面的线程任务，消费商品
            for (String string : Job.value) {
                System.out.println("消费者1清理"+string);
            }
        System.out.println("消费者1清理完毕，唤醒消费者2进行消费");
        //当所有都消费完成后，通知消费者2进行消费
        consumeCondition.signal();
        //必须要释放锁
        lock.unlock();

    }
}

　　新增消费者2：

/**
 * 消费者2，等待消费者1清理完成商品后，才开始消费
 */
public class Consume2 implements Runnable {
    //获取的锁
    Lock lock;
    //消费者1和消费者2使用的等待/通知对象，用于绑定消费者1和消费者2的等待/通知关系
    Condition consumeCondition;

    public Consume2(Lock lock, Condition consumeCondition) {
        this.lock = lock;
        this.consumeCondition = consumeCondition;
    }

    @Override
    public void run() {
        //注意，这里生产者和消费者必须拿同一把锁，如果锁不相同，则这个机制无法成功使用
        lock.lock();
            //先判断有没商品生产，如果没有则开始等到生产者生成
            if (Job.value[0] == null) {
                try {
                    //等待生产
                    System.out.println("我是消费者2，当前没有任务，等待生产");
                    consumeCondition.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            //生产完成后，唤醒消费者后面的线程任务，消费商品
            for (String string : Job.value) {
                System.out.println("消费者2消费"+string);
            }
        //必须要释放锁
        lock.unlock();

    }
}

　　测试类：

public class Job {

    //创建一把锁
    private static Lock lock = new ReentrantLock();
    //生成者和消费者1使用的等待/通知对象，用于绑定生成者和消费者1的等待/通知关系
    private static Condition condition = lock.newCondition();
    //消费者1和消费者2使用的等待/通知对象，用于绑定消费者1和消费者2的等待/通知关系
    private static Condition consumeCondition = lock.newCondition();

    public static String value[] = new String[5];

    public static void main(String[] args) {

        Productor productor = new Productor(lock,condition);

        Consume consume = new Consume(lock,condition,consumeCondition);

        Consume2 consume2=new Consume2(lock,consumeCondition);
        new Thread(consume2).start();
        new Thread(consume).start();
        new Thread(productor).start();

    }
}

运行的结果：