多线程-生产者-消费者模型_多线程生产者与消费者模型

一、前言

        生产者消费者问题（英语：Producer-consumer problem），也称有限缓冲问题（英语：Bounded-buffer problem），是一个多线程同步问题的经典案例。该问题描述了两个共享固定大小缓冲区的线程——即所谓的“生产者”和“消费者”——在实际运行时会发生的问题。生产者的主要作用是生成一定量的数据放到缓冲区中，然后重复此过程。与此同时，消费者也在缓冲区消耗这些数据。该问题的关键就是要保证生产者不会在缓冲区满时加入数据，消费者也不会在缓冲区中空时消耗数据。

        生产者消费者模型需要抓住“三个主体，三个要点“，三个主体是指：生产者、消费者、缓冲区。生产者往缓冲区放数据，消费者从缓冲区取数据。

三个要点是指：

1.缓冲区有固定大小
2.缓冲区满时，生产者不能再往缓冲区放数据（产品），而是被阻塞，直到缓冲区不是满的
3.缓冲区为空时，消费者不能再从缓冲区取数据，而是被阻塞，直到缓冲区不是空的。

        数据（产品）往往是先生产出来的先被消费。所以缓冲区一般用有界队列实现，又由于生产者、消费者在特定情况下需要被阻塞，所以更具体一点，缓冲区一般用有界阻塞队列来实现。
本篇用三种方式实现生产者-消费者模型：wait/notify + 队列、Lock/Condition + 队列、有界阻塞队列。

二、wait/notify + 队列

        实现生产者-消费者模型，主要是实现两个核心方法：往缓冲区中放元素、从缓冲区中取元素。
以下是缓冲区的代码实现，是生产者-消费者模型的核心。

ProducerConsumerQueue缓冲区

package cn.java.threadmodel.producerconsumer;
 
import java.util.LinkedList;
import java.util.Queue;
/**
 * @author 小石潭记
 * @date 2021/12/18 9:58
 * @Description: wait/notify机制实现生产者-消费者模型
 */
public class ProducerConsumerQueue<E> {
    /**
     * 队列最大容量
     */
    private final static int QUEUE_MAX_SIZE = 3;
    /**
     * 存放元素的队列
     */
    private Queue<E> queue;
 
    public ProducerConsumerQueue() {
        queue = new LinkedList<>();
    }
 
    /**
     * 向队列中添加元素
     *
     * @param e
     * @return
     */
    public synchronized boolean put(E e) {
        // 如果队列是已满，则阻塞当前线程
        while (queue.size() == QUEUE_MAX_SIZE) {
            try {
                wait();
            } catch (InterruptedException e1) {
                e1.printStackTrace();
            }
        }
        // 队列未满，放入元素，并且通知消费线程
        queue.offer(e);
        System.out.println(Thread.currentThread().getName() + " -> 生产元素，元素个数为：" + queue.size());
        notify();
        return true;
    }
 
    /**
     * 从队列中获取元素
     * @return
     */
    public synchronized E get() {
        // 如果队列是空的，则阻塞当前线程
        while (queue.isEmpty()) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
 
        // 队列非空，取出元素，并通知生产者线程
        E e = queue.poll();
        System.out.println(Thread.currentThread().getName() + " -> 消费元素，元素个数为：" + queue.size());
        notify();
        return e;
    }
}
 

Producer生产者

package cn.java.threadmodel.producerconsumer;
 
/**
 * @author 小石潭记
 * @date 2021/12/18 10:00
 * @Description: 生产者线程
 */
public class Producer implements Runnable {
 
    private ProducerConsumerQueue<Integer> queue;
 
    public Producer(ProducerConsumerQueue<Integer> queue) {
        this.queue = queue;
    }
 
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            queue.put(i);
        }
    }
}

Consumer消费者

package cn.java.threadmodel.producerconsumer;
 
/**
 * @author 小石潭记
 * @date 2021/12/18 10:00
 * @Description: 消费者线程
 */
public class Consumer implements Runnable {
 
    private ProducerConsumerQueue<Integer> queue;
 
    public Consumer(ProducerConsumerQueue<Integer> queue) {
        this.queue = queue;
    }
 
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            queue.get();
        }
    }
}

ProducerConsumerDemo测试类

package cn.java.threadmodel.producerconsumer;
 
import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
 
/**
 * @author 小石潭记
 * @date 2021/12/18 10:01
 * @Description: 测试生产消费者模型
 */
public class ProducerConsumerDemo {
    private final static ExecutorService service = Executors.newCachedThreadPool();
 
    public static void main(String[] args) throws InterruptedException {
        Random random = new Random();
        // 生产者-消费者模型缓冲区
        ProducerConsumerQueue<Integer> queue = new ProducerConsumerQueue<>();
        Producer producer = new Producer(queue);
        Consumer consumer = new Consumer(queue);
        for (int i = 0; i < 3; i++) {
            // 休眠0-50毫秒，增加随机性
            Thread.sleep(random.nextInt(50));
            service.submit(producer);
        }
        for (int i = 0; i < 3; i++) {
            // 休眠0-50毫秒，增加随机性
            Thread.sleep(random.nextInt(50));
            service.submit(consumer);
        }
        // 关闭线程池
        service.shutdown();
    }
}

从上图的测试结果得知：

• 由于队列的最大长度是3（QUEUE_MAX_SIZE），所以缓冲区元素不会超过3，说明缓冲区满时，生产者确实被阻塞了
• 缓冲区元素个数最小为0，不会出现负数，说明缓冲区为空时，消费者被阻塞了

 这就是生产者-消费者模型基于wait/notify+队列的基本实现。

三、Lock/Condition + 队列

核心部分缓冲区的实现代码实现如下：

package cn.java.threadmodel.producerconsumer.lockcondition;
 
import java.util.LinkedList;
import java.util.Queue;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
 * @author 小石潭记
 * @date 2021/12/18 10:11
 * @Description: Lock/Condition实现生产者-消费者模型
 */
public class ProducerConsumerQueue<E> {
    /**
     * 队列最大容量
     */
    private final static int QUEUE_MAX_SIZE = 3;
    /**
     * 存放元素的队列
     */
    private Queue<E> queue;
 
    private final Lock lock = new ReentrantLock();
    private final Condition producerCondition = lock.newCondition();
    private final Condition consumerCondition = lock.newCondition();
 
    public ProducerConsumerQueue() {
        queue = new LinkedList<>();
    }
 
    /**
     * 向队列中添加元素
     * @param e
     * @return
     */
    public boolean put(E e) {
        final Lock lock = this.lock;
        lock.lock();
        try {
            while (queue.size() == QUEUE_MAX_SIZE) {
                // 队列已满
                try {
                    producerCondition.await();
                } catch (InterruptedException e1) {
                    e1.printStackTrace();
                }
            }
            queue.offer(e);
            System.out.println(Thread.currentThread().getName() + " -> 生产元素，元素个数为：" + queue.size());
            consumerCondition.signal();
        } finally {
            lock.unlock();
        }
        return true;
    }
 
    /**
     * 从队列中取出元素
     * @return
     */
    public E get() {
        final Lock lock = this.lock;
        lock.lock();
        try {
            while (queue.isEmpty()) {
                // 队列为空
                try {
                    consumerCondition.await();
                } catch (InterruptedException e1) {
                    e1.printStackTrace();
                }
            }
            E e = queue.poll();
            System.out.println(Thread.currentThread().getName() + " -> 消费元素，元素个数为：" + queue.size());
            producerCondition.signal();
            return e;
        } finally {
            lock.unlock();
        }
    }
}

生产者线程、消费者线程、测试代码更是和wait/notify方式一致。

四、有界阻塞队列

同样，缓冲区的实现也是其核心部分，不过阻塞队列已经提供了相应的阻塞API，所以不需要额外编写阻塞部分的代码。

package cn.java.threadmodel.producerconsumer.queue;
 
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
 
/**
 * @author 小石潭记
 * @date 2021/12/18 10:23
 * @Description:  * 阻塞队列实现生产者-消费者模型
 *                * 对应的阻塞方法是put()/take()
 */
public class ProducerConsumerQueue<E> {
 
    /**
     * 队列最大容量
     */
    private final static int QUEUE_MAX_SIZE = 3;
    /**
     * 存放元素的队列
     */
    private BlockingQueue<E> queue;
 
    public ProducerConsumerQueue() {
        queue = new LinkedBlockingQueue<>(QUEUE_MAX_SIZE);
    }
 
    /**
     * 向队列中添加元素
     * @param e
     * @return
     */
    public boolean put(E e) {
        try {
            queue.put(e);
            System.out.println(Thread.currentThread().getName() + " -> 生产元素，元素个数为：" + queue.size());
        } catch (InterruptedException e1) {
            e1.printStackTrace();
        }
        return true;
    }
 
    /**
     * 从队列中取出元素
     * @return
     */
    public E get() {
        try {
            E e = queue.take();
            System.out.println(Thread.currentThread().getName() + " -> 消费元素，元素个数为：" + queue.size());
            return e;
        } catch (InterruptedException e1) {
            e1.printStackTrace();
        }
        return null;
    }
}

生产者线程、消费者线程、测试代码也和前面两种一模一样。

五、总结

通过三种方式实现生产者-消费者模型，可以看出使用阻塞队列的方式最简单，也更安全。其实看看阻塞队列的源码，会发现其内部的实现和这里的前两种差不多，只是JDK提供的阻塞队列健壮性更好。

说完了三种实现方式，再来说说为什么要使用生产者-消费者模式，消费者直接调用生产者不好吗？
回顾文章开始的那张图，试想一下，如果没有生产者-消费者模式会怎样，大概会变成如下这样

 可以看到，三个生产者，三个消费者就会产生 3 * 3 = 9条调用关系（箭头方法代表数据走向），还有一点就是消费者也有可能还是生产者，生产者也有可能还是消费者，一旦生产者、消费者的数量多了之后就会形成复杂的调用网。所以生产者-消费者模型的最大好处就是解耦。
其次如果生产者和消费者的速度上有较大的差异，就一定会存在一方总是在等待另一方的情况。比如快递小哥如果每一个快递都必须直接送到用户手上，如果某个用户一直联系不上，或者说过了很久才取快递，那么快递小哥就只能一直等待。所以就出现了快递站，快递小哥只需要把快递放在指定位置，用户去指定位置取就行了。所以生产者-消费者模型的第二个好处就是平衡生产能力和消费能力的差异。

六、参考

三种方式实现生产者-消费者模型