线程间通信-------生产者消费者模型

生产者消费者模型

概述

生产者消费者模式，是通过一块缓冲区作为容器，来解决生产者和消费者之间的强耦合关系。通俗来讲就是，在该模型之前，只有当顾客来了，店家才会生产商品，这样的话，来多个顾客就会将大量时间浪费在排队上，白白消磨时间。而有了生产者消费者模式后呢？店家在没有顾客的时候，也生产商品，并将商品放在一个容器中，顾客来了直接拿即可，只有当容器满了便停止生产。而生活中大多都采用这个模型。

图解

使用wait() notify() notifyAll() 方法实现生产者消费者模型

为了支持多线程之间的协作，JDK特意提供了这两个方法，且这两个方法不在Thread类中，而是在Object类中，这意味任何对象都可以调用这两个方法。

• 方法源码

public final native void notifyAll();
public final native void wait(long timeout) throws InterruptedException;

wait方法调用之后，线程停止运行，释放对象锁,同时将该线程放入等待队列中，该线程由运行状态，变为阻塞状态。
notify()方法调用之后，会从等待队列中随机唤醒一个线程，notifyAll()是将等待队列中所有的线程唤醒。唤醒后，该线程进入同步队列表明该线程此时处于就绪状态（而不是运行状态）就等着CPU的时间片了。notiyf（） 或者 notifyAll()方法调用后，不会立马释放对象锁，需要将整个代码执行完毕，才会释放锁。

面试题： wait(),notify(),notifyAll()为什么必须在同步代码块中？

经过检测，若wait方法不在同步代码块中，确实会抛出Java.long.IllegalMonitorStateException.
1.这三个方法执行时，需要获取到对象的monitor对象，又因为monitor对象在对象的Mark Word中，而通过同步代码可以获取到对象的monitor.
2.假如该方法可以不在同步代码块中使用，这样其实问题很多，主要原因是因为CPU上下文切换造成的，如果有这样的伪代码：

A:  生产者
  if(count <= 0){
      count++;
  }else{
      wait();
  }
 B: 消费者
  while(count > 0){
      count--;
  }else{
      notify();
  }

生产者判断商品数量是否小于0，小于0，就需要生产，否则啥事不干，让消费者消费就行。而消费者呢？商品数量大于0，说明还有商品，直接消费即可，如果小于0，就得通知生产者进行生产了。
假如，现在count == 1，有一个商品，生产者执行eles逻辑，再调用wait方法之前，cpu时间片切换，然后消费者消费了这个商品，再一次消费时，count = 0了，调用notify，因为没有线程阻塞，所有这个方法啥也没干，然后线程切换，生产者调用了wait，此时生产和消费就无法继续。

因此：主要原因是无法保证判断和wait 是原子操作如果在wait之前，发生了切换，而notify执行完之后，再执行wait是没有意义的,程序容易出错。

使用synchronize实现生产者多消费者模型

• 商品类

public class Goods {
    private int id = 0;
    public Goods(int id){
        this.id = id;
    }
    public int getId(){
        return id;
    }
}

• 生产者类

public class Producer implements Runnable {
    private final Queue<Goods> queue;  // 容器
    private final Integer maxNum;  // 最大容量
    private final Integer speed;   // 生产速率
    private Integer count = 0;

    public Producer(Queue<Goods> queue, Integer maxNum, Integer speed) {
        this.queue = queue;
        this.maxNum = maxNum;
        this.speed = speed;
    }

    @Override
    public void run() {
        while(true) {
            try {
                Thread.sleep(speed);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (this.queue) {
                if (this.queue.size() < maxNum) {
                    Goods goods = new Goods(++this.count);
                    queue.offer(goods);
                    System.out.println(Thread.currentThread().getName() + "开始生产第" + goods.getId() + "号产品！！！");
                } else {
                    try {
                        System.out.println("队列满着，不用生产，等待消费。。。。");
                        this.queue.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}

• 消费者类

public class Consumer implements Runnable {
    private final Queue<Goods> queue;   //容器
    private final Integer speed;        // 消费速率

    public Consumer(Queue<Goods> queue, Integer speed) {
        this.queue = queue;
        this.speed = speed;
    }

    @Override
    public void run() {
        while(true) {
            try {
                Thread.sleep(speed);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
                synchronized (this.queue) {
                    if (!this.queue.isEmpty()) {
                        Goods goods = this.queue.poll();
                        System.out.println(Thread.currentThread().getName() + "将第" + goods.getId() + "号商品售出。。。");
                    } else {
                        System.out.println("队列没有东西了，需要生产！！！");
                        this.queue.notifyAll();
                    }
                }
            }
        }
}

代码本身很简单，主要有几个注意点：

• 生产者生产的时候，消费者不能消费
• 消费者消费的时候，生产者不能生产
• 容器空了，消费者不能消费，需要通知生产者该干活了
• 容器满了，生产者不能再生产。
• 生产者消费者共享一个容器，共享数据作为锁。

生产者消费者模型的优点

• 解耦，通过缓冲区，将生产者与消费者之间进行解耦，谁也不关心谁，只关心容器中的商品数量。
• 提高速率，通过平衡生产者和消费者的处理能力，提高整体的运作能力。

面试题：请解释sleep()与wait()的区别：

• sleep()是Thread类的方法，wait是Object类中的方法，因此任意对象都可以调用wait方法，但仅有Thread类对象才能调用sleep方法。
• sleep和wait的功能都是让线程休眠，但sleep不需要唤醒，wait需要唤醒。
• 线程在调用sleep后，不会释放对象锁，因此其它线程仍然进不了同步块，但wait调用后会立即释放对象锁。
• wait方法必须在同步块或者同步方法中使用，但sleep没有该要求。