生产者消费者模式说明：
- 生产者只在仓库未满时进行生产，仓库满时生产者进程被阻塞；
- 消费者只在仓库非空时进行消费，仓库为空时消费者进程被阻塞；
实现的关键：
共享内存中的两个同步方法，及同步方法中wait()方法的调用。
- synchronized 保证了对象只能被一个线程占用。
- wait 保证了当线程在等待过程中释放锁，使得其他对象有机会获得锁。
执行wait后，当前线程处于等待状态，并且会释放锁。
执行notify后，当前线程并不会马上释放锁，而是执行完runnable代码后才会释放锁。
Java中有一个同步模型-监视器，负责管理线程对对象中的同步方法的访问，它的原理是：赋予该对象唯一一把'钥匙'，当多个线程进入对象，只有取得该对象钥匙的线程才可以访问同步方法，其它线程在该对象中等待，直到该线程用wait()方法放弃这把钥匙，其它等待的线程抢占该钥匙，抢占到钥匙的线程后才可得以执行，而没有取得钥匙的线程仍被阻塞在该对象中等待。 总而言之，synchonized使得只有一个线程能进入临界代码区。
由于wait( )所等待的对象必须先锁住，因此，它只能用在同步化程序段或者同步化方法内，否则，会抛出异常java.lang.IllegalMonitorStateException.
代码
- 仓库（缓冲区），用于管理产品的生产、消费和存储
/**
* 仓库类，用于管理产品的生产、消费和存储。
*/
public class Storage<T> {
private int index = 0;
private static final int MAX = 10;//最大容量
private List<T> storages = new ArrayList<T>(MAX);//存储集合
public synchronized void produce(T item) {
while (index >= MAX) {// 判断仓库满了，则等待。
try {
System.out.println("仓库满了，等待中...");
this.wait();
System.out.println("仓库不满了，开始生产");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("生产>>" + item.toString());
storages.add(item);
index++; //先添加item，在进行加1操作
notify(); //唤醒在此对象监视器上等待的单个线程，即消费者线程
}
public synchronized T consume() {
while (index <= 0) {// 判断仓库空了，则等待。
try {
System.out.println("仓库为空，等待中...");
this.wait();
System.out.println("仓库不为空，开始消费");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
index--;//先进行减1操作，再remove
T item = storages.remove(index);
System.out.println("消费>>" + item.toString());
notify();
return item;
}
}
- 产品
public class Phone {
private int id;// 手机编号
public Phone(int id) {
this.id = id;
}
@Override
public String toString() {
return "手机编号：" + id;
}
}
- 生产者
public class Producer implements Runnable {
private Storage<Phone> storage;
public Producer(Storage<Phone> storage) {
this.storage = storage;
}
public void run() {
for(int i = 0;i<20;i++){
storage.produce(new Phone(i));
try {
Thread.sleep(10);//每隔10毫秒生产一个产品
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
- 消费者
public class Consumer implements Runnable {
private Storage<Phone> storage;
public Consumer(Storage<Phone> storage) {
this.storage = storage;
}
public void run() {
for(int i = 0;i<20;i++){
storage.consume();
try {
Thread.sleep(100);//每隔100毫秒消费一个
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
- 客户端
public class ProducerAndConsumer {
public static void main(String[] args) {
Storage<Phone> storage = new Storage<Phone>();
new Thread(new Producer(storage)).start();
new Thread(new Consumer(storage)).start();
}
}
- 结果
生产>>手机编号：0
消费>>手机编号：0
生产>>手机编号：1
生产>>手机编号：2
生产>>手机编号：3
生产>>手机编号：4
生产>>手机编号：5
生产>>手机编号：6
生产>>手机编号：7
生产>>手机编号：8
生产>>手机编号：9
消费>>手机编号：9
生产>>手机编号：10
生产>>手机编号：11
仓库满了，等待中...
消费>>手机编号：11
仓库不满了，开始生产
生产>>手机编号：12
仓库满了，等待中...
消费>>手机编号：12
仓库不满了，开始生产
生产>>手机编号：13
仓库满了，等待中...
消费>>手机编号：13
仓库不满了，开始生产
生产>>手机编号：14
仓库满了，等待中...
消费>>手机编号：14
仓库不满了，开始生产
生产>>手机编号：15
仓库满了，等待中...
消费>>手机编号：15
仓库不满了，开始生产
生产>>手机编号：16
仓库满了，等待中...
消费>>手机编号：16
仓库不满了，开始生产
生产>>手机编号：17
仓库满了，等待中...
消费>>手机编号：17
仓库不满了，开始生产
生产>>手机编号：18
仓库满了，等待中...
消费>>手机编号：18
仓库不满了，开始生产
生产>>手机编号：19
消费>>手机编号：19
消费>>手机编号：10
消费>>手机编号：8
消费>>手机编号：7
消费>>手机编号：6
消费>>手机编号：5
消费>>手机编号：4
消费>>手机编号：3
消费>>手机编号：2
消费>>手机编号：1
2018.11.18补充
如上代码知识模拟的一个生产者一个消费者的场景，而且生产者和消费者分别执行20次。完全可以使用while（true）使得一直生产和消费。
对于一个生产者和一个消费者的场景，可以使用if来判断临界值。并不需要while（xxx）做处理。
而对于多生产者或多消费则需要使用while处理，同时需要使用notifyAll去唤醒。否则可能出现假死的情况，即生产者和消费者都处于wait，因此notify不仅仅可以唤醒异类，也可以唤醒同类（即生产者也可以唤醒另一个生产者）
