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

前言

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

看完了定义，相信懵逼的依然懵逼，那我就来说人话吧。
生产者消费者模型需要抓住“三个主体，三个要点“，三个主体是指：生产者、消费者、缓冲区。生产者往缓冲区放数据，消费者从缓冲区取数据。

整个模型大致就是上面图示的结构。
三个要点是指：

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

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

wait/notify + 队列

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

import java.util.LinkedList;
import java.util.Queue;

/**
 * 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;
    }
}
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
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

实现了缓冲区后，对于生产者、消费者线程的实现就比较简单了

/**
 * 生产者线程
 */
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);
        }
    }
}

/**
 * 消费者线程
 */
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();
        }
    }
}
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

测试代码如下：

import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

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();
    }
}
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

执行结果（由于执行结果比较长，所以截取部分结果）

pool-1-thread-1 -> 生产元素，元素个数为：1
pool-1-thread-1 -> 生产元素，元素个数为：2
pool-1-thread-1 -> 生产元素，元素个数为：3
pool-1-thread-4 -> 消费元素，元素个数为：2
pool-1-thread-1 -> 生产元素，元素个数为：3
pool-1-thread-4 -> 消费元素，元素个数为：2
pool-1-thread-3 -> 生产元素，元素个数为：3
pool-1-thread-4 -> 消费元素，元素个数为：2
pool-1-thread-4 -> 消费元素，元素个数为：1
pool-1-thread-4 -> 消费元素，元素个数为：0
pool-1-thread-2 -> 生产元素，元素个数为：1
pool-1-thread-2 -> 生产元素，元素个数为：2
pool-1-thread-2 -> 生产元素，元素个数为：3
pool-1-thread-4 -> 消费元素，元素个数为：2
......
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

虽然是部分结果，但是依然可以看出几点：

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

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

Lock/Condition + 队列

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

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;

/**
 * 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();
        }
    }
}
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
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

可以看到，代码基本和wait/notify实现方式一致，基本只是API的不同而已。生产者线程、消费者线程、测试代码更是和wait/notify方式一致，所以就不赘述了。

有界阻塞队列

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

/**
 * 阻塞队列实现生产者-消费者模型
 * 对应的阻塞方法是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;
    }
}
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
43
44
45
46
47
48
49

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

总结

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

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

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

以上就是本篇关于生产者-消费者模型的全部内容。