生产者消费者模型-Java代码实现

什么是生产者-消费者模式

　　比如有两个进程A和B，它们共享一个固定大小的缓冲区，A进程产生数据放入缓冲区，B进程从缓冲区中取出数据进行计算，那么这里其实就是一个生产者和消费者的模式，A相当于生产者，B相当于消费者，生产者消费者要解决的问题就是如何处理公共资源。

生产者-消费者模式的特点

• 保证生产者不会在缓冲区满的时候继续向缓冲区放入数据，而消费者也不会在缓冲区空的时候，消耗数据
• 当缓冲区满的时候，生产者会进入休眠状态，当下次消费者开始消耗缓冲区的数据时，生产者才会被唤醒，开始往缓冲区中添加数据；当缓冲区空的时候，消费者也会进入休眠状态，直到生产者往缓冲区中添加数据时才会被唤醒

代码实现

package com.rao.operatingSystem;

/**
 * @author Srao
 * @className ProducerAndConsumer
 * @date 2019/12/20 22:51
 * @package com.rao.operatingSystem
 * @Description 生产者消费者模型
 */
public class ProducerAndConsumer {
    public static void main(String[] args) {
        Factory factory = new Factory();

        Producer producer = new Producer(factory);
        Producer producer2 = new Producer(factory);
        Consumer consumer = new Consumer(factory);

        producer.start();
        producer2.start();
        consumer.start();
    }

    /**
     * 工厂模型，表示公共资源
     */
    static class Factory{
        int max;//工厂的最大物品数
        int num;//当前工厂当中还有多少物品

        public Factory(int max) {
            this.max = max;
        }

        /**
         * 生产
         */
        synchronized void add(){
            //如果工厂没有满，就生产物品
            if (num < max){
                num++;
                System.out.println("生产了一件商品，现在工厂中还有：" + num + "件物品");
                //唤醒等待的消费者来消费
                notifyAll();
            }else {
                try {
                    //工厂满了，生产者等待
                    wait();
                    System.out.println("工厂满了，生产者等待");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

        synchronized void remove(){
            //如果工厂有物品
            if ( < num){
                num--;
                System.out.println("消费了一件物品，还剩下：" + num + "件物品");
                //唤醒等待的生产者来生产物品
                notifyAll();
            }else {
                try {
                    //没有东西可以被消费了，该线程等待，等到生产者来生产
                    wait();
                    System.out.println("工厂没东西了，消费者等待");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * 生产者
     */
    static class Producer extends Thread{
        Factory factory;

        public Producer(Factory factory) {
            this.factory = factory;
        }

        @Override
        public void run() {
            while (true){
                //一直生产
                try{
                    sleep();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                factory.add();
            }
        }
    }

    /**
     * 消费者
     */
    static class Consumer extends Thread{
        Factory factory;

        public Consumer(Factory factory) {
            this.factory = factory;
        }

        @Override
        public void run() {
            while (true){
                //一直消费
                try {
                    sleep();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                factory.remove();
            }
        }
    }
}