生产者-消费者模式详解

生产者消费者模式说明:

  1. 生产者只在仓库未满时进行生产,仓库满时生产者进程被阻塞;
  2. 消费者只在仓库非空时进行消费,仓库为空时消费者进程被阻塞;
  3. 当消费者发现仓库为空时会通知生产者生产;
  4. 当生产者发现仓库满时会通知消费者消费;

实现的关键:

共享内存中的两个同步方法,及同步方法中wait()方法的调用。

  • synchronized 保证了对象只能被一个线程占用。
  • wait 保证了当线程在等待过程中释放锁,使得其他对象有机会获得锁。

    Java中有一个同步模型-监视器,负责管理线程对对象中的同步方法的访问,它的原理是:赋予该对象唯一一把’钥匙’,当多个线程进入对象,只有取得该对象钥匙的线程才可以访问同步方法,其它线程在该对象中等待,直到该线程用wait()方法放弃这把钥匙,其它等待的线程抢占该钥匙,抢占到钥匙的线程后才可得以执行,而没有取得钥匙的线程仍被阻塞在该对象中等待。 总而言之,synchonized使得只有一个线程能进入临界代码区。

由于wait( )所等待的对象必须先锁住,因此,它只能用在同步化程序段或者同步化方法内,否则,会抛出异常java.lang.IllegalMonitorStateException.

代码

  • 仓库(缓冲区),用于管理产品的生产、消费和存储

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    /**
    * 仓库类,用于管理产品的生产、消费和存储。
    */
    public class Storage {
    private int index = 0;
    private static final int MAX = 10;//最大容量
    private List storages = new ArrayList(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;
    }
    }
  • 产品

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    public class Phone {

    private int id;// 手机编号

    public Phone(int id) {
    this.id = id;
    }

    @Override
    public String toString() {
    return "手机编号:" + id;
    }
    }
  • 生产者

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    public class Producer implements Runnable {

    private Storage storage;

    public Producer(Storage 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();
    }
    }
    }
    }
  • 消费者

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    public class Consumer implements Runnable {

    private Storage storage;

    public Consumer(Storage 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();
    }
    }
    }
    }
  • 客户端

    1
    2
    3
    4
    5
    6
    7
    8
    9
    public class ProducerAndConsumer {

    public static void main(String[] args) {
    Storage storage = new Storage();

    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

参阅

生产者消费者模式详解及代码实现
生产者/消费者问题的多种Java实现方式
Java多线程之生产者消费者经典问题

坚持原创技术分享,您的支持将鼓励我继续创作!