可能有很多同学不太了解生产者/消费者模式，也可能有同学会说：”四人帮(Gang Of Four)的23中设计模式中根本就没有生产者/消费者模式啊。”，你说的也对，GOF中是没有生产者/消费者模式，GOF中的23种设计模式主要是基于OO的，但模式可以是OO的，也可以不是OO的呀。所以，消除你的疑虑吧，生产者/消费者模式还是很强大的，大多数时候，它是用来解决并发问题的，后续，我会学习并总结一下JDK Concurrent包下的一些类，但今天我们主要聊一聊这个有趣的模式吧。

生产者/消费者模式简介

其实从字面意义上理解，某个模块负责生产数据，而另一个模块负责处理这些数据，那么产生数据的模块，就称为生产者而消费数据的模块就称为消费者喽。但是生产者/消费者模式还有一个重要的地方就是缓存区，你可以把它理解为一个古时候的媒婆，也就是现在的红娘（举例子而已，并不是单身狗），生产者把产生的数据放入缓存区，消费者从缓存区取得数据进行处理。大部分人往往对图像的理解和记忆是更加深刻的，如果你也是这样那就看图吧：(正所谓无图言屌)

生产者/消费者模式优势

  • 解耦

    生产者和消费者之间没有直接依赖，都依赖于缓存区，所以达到了解耦的目的。

  • 并发

    正因为生产者和消费者没有直接耦合在一起，所以生产者和消费者是两个独立的并发主体，生产者把数据生产数来，丢到缓存区，就可以继续生产数据了，消费者亦是如此。

  • 支持忙闲不均

    缓冲区还有另一个好处。如果制造数据的速度时快时慢，缓冲区的好处就体现出来了。当数据制造快的时候，消费者来不及处理，未处理的数据可以暂时存在缓冲区中。等生产者的制造速度慢下来，消费者再慢慢处理掉。

    既然我们已经了解了生产者/消费者模式，那么我们接下来就用代码来实现一下吧：

    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
    public class ProducerConsumerPattern {
        public static void main(String[] args) {
            BlockingQueue blockingDeque = new LinkedBlockingQueue();
            Thread threadProducer = new Thread(new Producer(blockingDeque));
            Thread threadConsumer = new Thread(new Consumer(blockingDeque));
            threadConsumer.start();
            threadProducer.start();
        }
        static class Producer implements Runnable{
            private final BlockingQueue blockingQueue;
            public Producer(BlockingQueue blockingQueue) {
                this.blockingQueue = blockingQueue;
            }
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    try {
                        System.out.println("producer"+i);
                        blockingQueue.put(i);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
        static class Consumer implements Runnable{
            private final BlockingQueue blockingQueue;
            public Consumer(BlockingQueue blockingQueue) {
                this.blockingQueue = blockingQueue;
            }
            @Override
            public void run() {
                for (;;) {
                    try {
                        System.out.println("consumer"+blockingQueue.take());
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }

    上面的代码是使用了concurrent包下的一个阻塞队列BlockingQueue，相对来说比较简单，当然你也可以使用wait()和notify()方法或者await()和signal()方法实现，如果你有看过LinkeBlockingQueue的源码，那么你会发现，LinkedBlockingQueue就使用了后者（为了简单明了，我使用了静态内部类，生产环境当中一般都是分开的）。

    总结

    笔者在阅读了LinkedBlockingQueue的源码并简单的看了下concurrent包下的类之后，发现着实有趣，所以才会有文章开头讲的计划着在将来的一段时间里学习一下concurrent包，如果你同样有兴趣，不妨花点时间看看吧，或许会有意想不到的收获哦。

    如果你想更加细致的了解生产者/消费者模式，建议参考编程随想的生产者/消费者模式概述。