生产者消费者模式详解
2017-03-22 本文已影响2068人
小编
生产者消费者模式说明：
- 生产者只在仓库未满时进行生产，仓库满时生产者进程被阻塞；
- 消费者只在仓库非空时进行消费，仓库为空时消费者进程被阻塞；
- 当消费者发现仓库为空时会通知生产者生产；
- 当生产者发现仓库满时会通知消费者消费；
实现的关键：
共享内存中的两个同步方法，及同步方法中wait()方法的调用。
- synchronized 保证了对象只能被一个线程占用。
- wait 保证了当线程在等待过程中释放锁，使得其他对象有机会获得锁。
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
