线程的生产者和消费者模式

生产者消费者模式是一个非常经典的多线程协作的模式，所谓的生产者消费者问题，实际上主要是包含了两类线程，如下 1、生产者线程用于生成数据 2、消费者线程用于消费数据

为了解耦生产者和消费者的关系，通常会采用共享的数据区域，就像是一个仓库，如下 1、生产者生成数据之后，直接放置在共享数据区域中。不用关心消费者的行为 2、消费者只需要从共享数据区域中去获取数据。不用关心生产者的行为

为了体现生成和消费过程中的等待和唤醒，Java就提供了几个方法供我们使用，这几个方法在Object类中，如下

线程生产者和消费者模式的练习

生产者和消费者案例中包含的类: 1、奶箱类(BOX)，里面定义一个成员变量，表示第x瓶奶，提供存储牛奶和获取牛奶的操作 2、生产者类(Producer)，里面实现了Runnable接口，重写run()方法，调用存储牛奶的操作 3、消费者类(Customer)，里面实现了Runnable接口，重写run()方法，调用存储牛奶的操作 4、测试类，里面有main方法，main方法中的代码步骤如下 (1)创建奶箱对象，这是共享数据区域 (2)创建生产者对象，把奶箱对象作为构造方法参数传递，因为在这个类中要调用存储牛奶的操作 (3)创建消费者对象，把奶箱对象作为构造方法参数传递，因为在这个类中要调用存储牛奶的操作 (4)创建两个线程对象，分别把生产者对象和消费者对象作为构造方法参数传递 (5)启动线程

xxxxxxxxxx
package ch21;

//奶箱类(BOX)
public class a_17_1Box {

    //里面定义一个成员变量，表示第x瓶奶
    private int milk;

    //定义一个成员变量，表示奶箱的状态
    private boolean state = false;//默认情况下表示没有牛奶

    //存储牛奶
    public synchronized void put(int milk) {
        //如果有牛奶，等待消费，而不是生产
        if(state){
            try {
                wait();//wait就是我们的重点，现在正在学的。wait报红线，按Alt+Enter，点击try...catch捕获异常
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果没有牛奶，就生产牛奶
        this.milk = milk;
        System.out.println("正在将第" + this.milk + "瓶奶放入奶箱");

        //生产完毕之后，修改奶箱状态，修改为true，表示有奶
        state = true;

        //唤醒其他线程，即唤醒其他等待的线程
        notifyAll();
    }

    //获取牛奶
    public synchronized void get() {
        //如果没有牛奶，就等待生产牛奶
        if(!state){
            try {
                wait();//wait就是我们的重点，现在正在学的。wait报红线，按Alt+Enter，点击try...catch捕获异常
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果有牛奶，就消费牛奶
        System.out.println("用户拿到第" + this.milk + "瓶奶");

        //消费完毕之后，修改奶箱的状态
        state = false;

        //唤醒其他线程，即唤醒其他等待的线程
        notifyAll();
    }

}

xxxxxxxxxx
package ch21;

//生产者类(Producer)，实现了Runnable接口
public class a_17_2Producer implements Runnable{

    private a_17_1Box b;

    //构造方法
    public a_17_2Producer(a_17_1Box b) {
        this.b=b;
    }

    //重写run()方法
    @Override
    public void run() {
        for(int i=1; i<=10; i++){
            b.put(i);//生产者生成5瓶牛奶
        }
    }
}

xxxxxxxxxx
package ch21;

//消费者类(Customer)，实现了Runnable接口
public class a_17_3Customer implements Runnable{

    private a_17_1Box b;

    public a_17_3Customer(a_17_1Box b) {
        this.b=b;
    }

    //重写run()方法
    @Override
    public void run() {
        while(true){
            b.get();//使用死循环获取奶箱中的牛奶
        }
    }
}

xxxxxxxxxx
package ch21;

public class a_17_4测试 {

    public static void main(String[] args) {

        //创建奶箱对象，这是共享数据区域
        a_17_1Box b = new a_17_1Box();

        //创建生产者对象，把奶箱对象作为构造方法参数传递，因为在这个类中要调用存储牛奶的操作
        a_17_2Producer p = new a_17_2Producer(b);

        //创建消费者对象，把奶箱对象作为构造方法参数传递，因为在这个类中要调用存储牛奶的操作
        a_17_3Customer c = new a_17_3Customer(b);

        //创建两个线程对象，分别把生产者对象和消费者对象作为构造方法参数传递
        Thread t1 = new Thread(p);
        Thread t2 = new Thread(c);

        //启动线程
        t1.start();
        t2.start();

        //控制台报错，输出IllegalMonitorStateException异常，表示抛出此异常表示线程已尝试在对象的监视器上等待，或者在没有指定监视器
        //的情况下通知在对象监视器上等待的其他线程。即理解为在"a_17_1Box"类里面的wait方法和notify方法必须要有锁对象，即这两个方法要在同步里面使用
        //解决:在"a_17_1Box"类中的put和get方法加上synchronized关键字来修饰，此时再put方法和get方法里面使用wait方法才不会抛异常

        //注意wait方法是等待，必须搭配notify或notifyall唤醒方法使用

    }
}