这是一个面试经常被问到的问题，很多问题都可以转化为这个模型。
什么是生产者与消费者问题？举个例子，我们去吃自助餐，在自助餐的一个公共区域放着各种食物，消费者需要就自行挑选，当食物被挑没的时候，大家就等待，等候厨师做出更多再放到公共区域内供大家挑选；当公共区域食物达到一定数量，不能再存放的时候，此时没有消费者挑选，厨师此时等待，等公共区域有地方再存放食物时，再开始生产。这就是一个生产者与消费者问题。
根据这个例子，我们可以模拟一下场景，我们从这个例子中，显然看出我们需要制造一个公共区域，而且这个公共区域是有容量限制的，需要模拟各种食物，同时还需要模拟几个厨师也就是生产者，最后再模拟几个消费者。
首先呢，我们创建一个产品Product类，这个类就代表食物的模板，厨师们就生产这种类型的食物，类里面定义食物的ID和name这两个属性，代码如下：
public class Product { private int id; private String name; public Product(int id, String name) { super(); this.id = id; this.name = name;
}
@Override public String toString() { return "Product ：id:"+id+",name:"+name;
} public int getId() { return id;
} public void setId(int id) { this.id = id;
} public String getName() { return name;
} public void setName(String name) { this.name = name;
}
}
接下来，我们创建那个公共区域，也就是一个容器，容器要么用数组保存，要么用集合，这里我们用集合LinkedList，然后呢，我们要清楚我们这个容器只能被创建一个，也就是公共区域只有一个，我们放也是放在这里面，取也是从这里面取，这里采用单例模式来保证只能创建一个容器实例，容器里面再定义放和取的方法，我们要加锁保证放和取的同步，以免发生线程安全问题，同时还要定义容器的最大容量，再放和取的同步方法里面，我们要判断是否容器内的食物超出了容器的最大容量，如果放的时候大于等于最大容量了，就不能再往里面放了，这时候厨师们（生产者）要等待；取的时候也一样，看是否容器内的食物个数为0，为0消费者们就要等待，最后我们在容器里面定义一个检查容器容量的方法，后面单独开启一个线程调用此方法，实时监测容器内食物的个数，一直在0-10之间，就说明我们写的代码没有问题，代码如下：
public class Container { //单例模式，保证只能创建一个容器实例
private static Container instance = null; private Container(){} public static Container getInstance(){ if(instance == null){
instance = new Container();
} return instance;
} private LinkedList<Product> list = new LinkedList<>();//容器
private int MAX = 10;//容器的最大容量 //放食物
public synchronized void putProduct(Product product){ while(list.size()>=MAX){ try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
list.addLast(product);//把新生产的食物放在最后 notifyAll();
} //取食物
public synchronized Product getProduct(){ while(list.size()<=0){ try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
notifyAll(); return list.removeFirst();//先取出放在这里时间最长的那个 } //检查容器内食物个数
public int checkSize(){ return list.size();
}
}
接下来就是生产者（厨师）线程，这个线程里面就是不停的生产食物，然后放入容器里面供消费者挑选，更形象一点，生产食物需要固定的时间，我们让线程每生产一个食物睡眠一段时间，时间为固定的。
代码如下：
public class ProducerThread implements Runnable{
Container container = null; public ProducerThread(Container container) { this.container = container;
}
@Override public void run() { int i = 0; while(true){
Product product = new Product(++i, "产品"+i); try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
container.putProduct(product);
}
}
}
有了生产者，接下来就是消费者线程了，该线程里面消费者不停的挑选产品，消费产品，每消费一个食物也需要一定的时间，而且这个对于每一个人时间是不一定的，所以呢我们就取1200以内的随机数，进行睡眠。
代码如下：
public class CustomThread implements Runnable{
Container container = null; public CustomThread(Container container) { this.container = container;
}
@Override public void run() { while(true){
Product p = container.getProduct(); try {
Thread.sleep((int)(Math.random()*1200));
} catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace();
}
System.out.println("消费了一个产品"+p);
}
}
}
在生产者与消费者线程里面，我们都定义了构造器，用来接收容器对象，这里面，并没有对容器进行初始化，就是为了保证容器的唯一性。
所需要的我们都定义完毕，最后定义一个测试类Go，测试类里面，创建2个生产者线程，10个消费者线程，并创建一个容器传给生产者和消费者，同时，另外开启一个线程，每隔300毫秒进行输出容器内食物的数量，如果食物数量一直在0到10之间，说明我们的程序没有问题，为了让打印看的更清晰，这里不用System.out.println打印，而是用显示为红色的System.err.println进行输出。
代码如下：
public class Go { public static void main(String[] args) {
Container container = Container.getInstance(); for (int i = 0; i < 2; i++) { new Thread(new ProducerThread(container)).start();;
} for (int i = 0; i < 10; i++) { new Thread(new CustomThread(container)).start();;
} new Thread(new Runnable() {
@Override public void run() { while(true){ try {
Thread.sleep(300);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.err.println(container.checkSize());
}
}
}).start();
}
}
整个生产者和消费者就完成了。
这里面一定要思考，代码的同步，容器的唯一以及对容器容量的控制，之间是怎么进行通讯的。
随时随地看视频
