黑马程序员全套Java教程_Java基础教程_多线程之生产者消费者（三十六）

3.1 生产者和消费者

• 生产者消费者模式是一个非常经典的多线程协作的模式，弄懂生产者消费者问题能够让我们对多线程编程的理解更加深刻。所谓生产者消费者问题，实际上主要是包含了两类线程：
  （1）生产者线程用于生产数据；
  （2）消费者线程用于消费数据。
  为了解耦生产者和消费者的关系，通常会采用共享的数据区域，就像是一个仓库，通过这个共享的数据区域：
  （1）生产者生产数据之后直接放置在共享数据区，并不需要关心消费者的行为；
  （2）消费者只需要从共享数据区中获取数据，并不需要关心生产者的行为。
  比如说送牛奶的小哥给我们送牛奶，小哥就是生产者，我们是消费者，而小哥将牛奶都存放到牛奶箱中，牛奶箱就相当于这个共享的数据区域。
  
• 为了体现生产和消费过程中的等待和唤醒，Java就提供了几个方法供我们使用，这几个等待和唤醒方法在Object类中：

方法名	说明
void wait()	导致当前线程等待，直到另一个线程调用该对象的notify()方法或者notifyAll()
void notify	唤醒正在等待对象监视器的单个线程
void notifyAll()	~的所有线程

面试题：下列关于Java中的wait()和sleep()的区别描述错误的是

• （1）wait()方法属于Object类，sleep属于Thread类。
  （2）调用sleep()的过程中，线程不会释放对象锁。
  （3）调用wait()方法的时候，线程会放弃对象锁。
  （4）sleep()方法导致了程序暂停执行指定的时间，让出CPU给其他线程。
  导致了线程暂停执行指定的时间，而非程序。
• （1）sleep()方法（参照笔记三十四1.6线程控制）：属于Thread类中的方法；会导致线程暂停执行指定的时间，让出cpu给其他线程，但是他的监控状态依然保持着，当指定时间到了之后，又会自动恢复运行状态；在调用sleep方法的过程中，线程不会释放对象锁。（只会让出CPU，不会导致锁行为的改变）
  （2）wait()方法：属于Object类中的方法；在调用wait方法的时候，线程会放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象调用notify方法后本线程才进入对象锁定池准备。获取对象锁进入运行状态。（不仅让出CPU，还释放已经占有的同步资源锁）

3.2 生产者消费者案例

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

public class Producer implements Runnable{
    private Box b;

    public Producer(Box b) {
        this.b = b;
    }

    @Override
    public void run() {
        for (int i=1;i<=30;i++){
            b.depositMilk(i);
        }
    }
}

public class Customer implements Runnable{
    private Box b;

    public Customer(Box b) {
        this.b=b;
    }

    @Override
    public void run() {
        while (true){
            b.takeMilk();
        }
    }
}

public class Box{
    private int milk = 0;
    //定义一个成员变量，表示奶箱的状态（是否有牛奶）
    private boolean state = false;

    public int getMilk() {
        return milk;
    }

    public void setMilk(int milk) {
        this.milk = milk;
    }

    //如果没有synchronized关键字：IllegalMonitorStateException
    //官方文档：抛出该异常表明某一线程已经试图等待对象的监视器（监视器相当锁对象），或者试图通知其他正在等待对象的监视器，然而本身没有指定了监视器的线程。
    //这个异常表名：一个线程尝试让一个对象的锁进入等待状态，或者尝试去唤醒其他线程中处于等待状态的对象的锁，然而这个线程根本就没有锁
    //也就是当前的线程不是此对象监视器的所有者。当前线程要锁定该对象之后，才能用锁定的对象执行这些方法。
    public synchronized void depositMilk(int milk){
        //如果有牛奶，等待消费
        if (state){
            try {
                //IllegalMonitorStateException
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果没有牛奶，就存放牛奶
        this.milk = milk;
        System.out.println("送奶小哥将第" + this.milk +"瓶奶放入奶箱");
        //生产完毕后，修改奶箱状态
        state = true;
        //唤醒其他等待的线程
        notifyAll();
    }

    public synchronized void takeMilk(){
        //如果没有牛奶，等待生产
        if (!state){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果有牛奶，就消费牛奶
        System.out.println("消费者拿到第" + this.milk +"瓶奶");
        //消费完毕之后，修改奶箱状态
        state = false;
        //唤醒其他等待的线程
        notifyAll();
    }
}

public class BoxDemo {
    public static void main(String[] args) {
        Box b = new Box();

        Producer p = new Producer(b);
        Customer c = new Customer(b);

        Thread t1 = new Thread(p);
        Thread t2 = new Thread(c);

        t1.start();
        t2.start();
    }
}