关于java:Java中的设计模式二生产者消费者模式与观察者模式

工具与资源核心
帮忙开发者更加高效的工作，提供围绕开发者全生命周期的工具与资源
https://developer.aliyun.com/&＃8230;

一、前言

  在上一篇 Java中的设计模式（一）：观察者模式 中咱们理解了 观察者模式 的基本原理和应用场景，在明天的这篇文章中咱们要做一点简略的延伸性学习——比照一下 生产者-消费者模式 和 观察者模式 的异同。

二、什么是“生产者-消费者模式”？

  和观察者模式不同，生产者-消费者模式 自身并不属于设计模式中的任何一种 。那么生产者-消费者模式到底是什么呢？上面咱们用一个例子简略阐明一下：

  如同上图中所示，生产者和消费者就如同一本杂志的投稿作者和订阅的读者，同一本杂志的投稿作者能够有多个，它的读者也能够有多个，而杂志就是连贯作者和读者的桥梁（即缓冲区）。通过杂志这个数据缓冲区，作者能够将实现的作品投递给订阅了杂志的读者，在这一过程中，作者不必关怀读者是否收到了作品或是否实现了浏览，作者和读者是两个绝对独立的对象，两者的行为互不影响。
  能够看到，在这个例子当中呈现了三个角色，别离是 生产者 、 消费者 以及 缓冲区 。生产者和消费者比拟好了解，前者是生产数据，后者则是解决前者生产进去的数据。而缓冲区在生产者-消费者模式中则起到了一个 解耦 、 反对异步 、 反对忙闲不均 的作用。

三、两者的区别

1. 编程范式不同

  生产者-消费者模式和观察者模式的第一个不同点在下面曾经说过，前者是一种 面向过程 的软件设计模式，不属于Gang of Four提出的23种设计模式中的任何一种，而后者则是23中设计模式中的一种，也即面向对象的设计模式中的一种。

2. 关联关系不同

  这一理念上的不同就带出了下一种不同点，即观察者模式中只有一对多的关系，没有多对多的关系，而在生产者-消费者模式中则是多对多的关系。
  在观察者模式中，被观察者只有一个，观察者却能够有多个。就比方十字路口的交通灯，直行的车辆只会察看管制直行的交通灯，不会去察看管制左拐或者右拐的交通灯，也就是说察看的对象是固定惟一的。
  而在生产者-消费者模式中则不同，生产者能够有多个，消费者也能够有多个。还是用下面作者和读者的例子，在这个例子当中，读者只关怀杂志的内容而不用关怀内容的创作者是谁，作者也只须要晓得创作完的作品能够公布到对应的杂志，而不用关怀会有那些读者。

3. 耦合关系不同

  从上一个不同中不难看出生产者-消费者模式和观察者模式的耦合关系也不雷同，前者为 轻耦合 ，后者为 重耦合 。

4. 利用场景不同

  观察者模式多用于 事件驱动模型 当中，生产者-消费者模式则多呈现在 过程间通信 ，用于进行解耦和并发解决，咱们罕用的音讯队列用的就是生产者-消费者模式。当然在Java中应用生产者-消费者模式还须要留神缓冲区的线程平安问题，这里就不做过多叙述。

四、一个小例子

  最初用一个简略的demo来完结本次的延长学习。

1. StoreQueue&＃8211;缓冲区

public class StoreQueue {
    private final BlockingQueue queue = new LinkedBlockingQueue<>();
    /**
     * 队列中减少数据
     *
     * @param data 生产者生产的数据
     */
    public void add(T data) {
        try {
            queue.put(data);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    /**
     * 队列中获取数据
     *
     * @return 从队列中获取到的数据
     */
    public T get() {
        try {
            return queue.take();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}

  在这个例子中，咱们应用了jdk本身的 阻塞队列BlockingQueue 来实现了一个缓冲区，这里只须要实现放数据和取数据的办法。如果咱们本人实现一个阻塞队列，一方面须要留神阻塞的解决，另一方面须要思考线程平安的问题，这里就不开展叙述了，有趣味的同学能够看下BlockingQueue的源码。

2. Producer&＃8211;生产者

public class Producer implements Runnable{
    private StoreQueue storeQueue;
    public Producer(StoreQueue storeQueue) {
        this.storeQueue = storeQueue;
    }
    @Override
    public void run() {
        for (int i = 0; i <10; i++) {
            storeQueue.add(Thread.currentThread().getName() + ":" + i);
        }
    }
}

3. Consumer&＃8211;消费者

public class Consumer implements Runnable{
    private StoreQueue storeQueue;
    public Consumer(StoreQueue storeQueue) {
        this.storeQueue = storeQueue;
    }
    @Override
    public void run() {
        try {
            while (true) {
                String data = storeQueue.get();
                System.out.println("以后生产线程 : " + Thread.currentThread().getName() + ", 接管到数据 : " + data);
            }
        } catch (Exception e) {
            e.printStackTrace();
            Thread.currentThread().interrupt();
        }
    }
}

4. 执行逻辑和运行后果

执行逻辑

public static void main(String[] args) {
        StoreQueue storeQueue = new StoreQueue<>();
        Producer producer = new Producer(storeQueue);
        Consumer cOnsumer= new Consumer(storeQueue);
        Producer producerTwo = new Producer(storeQueue);
        Consumer cOnsumerTwo= new Consumer(storeQueue);
        new Thread(producer).start();
        new Thread(consumer).start();
        new Thread(producerTwo).start();
        new Thread(consumerTwo).start();
    }

运行后果

以后生产线程 : Thread-1, 接管到数据 : Thread-0:0
以后生产线程 : Thread-1, 接管到数据 : Thread-0:1
以后生产线程 : Thread-1, 接管到数据 : Thread-0:2
以后生产线程 : Thread-1, 接管到数据 : Thread-0:3
以后生产线程 : Thread-1, 接管到数据 : Thread-0:4
以后生产线程 : Thread-3, 接管到数据 : Thread-0:5
以后生产线程 : Thread-3, 接管到数据 : Thread-0:7
以后生产线程 : Thread-3, 接管到数据 : Thread-0:8
以后生产线程 : Thread-3, 接管到数据 : Thread-0:9
以后生产线程 : Thread-3, 接管到数据 : Thread-2:0
以后生产线程 : Thread-3, 接管到数据 : Thread-2:1
以后生产线程 : Thread-3, 接管到数据 : Thread-2:2
以后生产线程 : Thread-3, 接管到数据 : Thread-2:3
以后生产线程 : Thread-3, 接管到数据 : Thread-2:4
以后生产线程 : Thread-3, 接管到数据 : Thread-2:5
以后生产线程 : Thread-3, 接管到数据 : Thread-2:6
以后生产线程 : Thread-3, 接管到数据 : Thread-2:7
以后生产线程 : Thread-3, 接管到数据 : Thread-2:8
以后生产线程 : Thread-3, 接管到数据 : Thread-2:9
以后生产线程 : Thread-1, 接管到数据 : Thread-0:6

  能够看到在下面的数据后果中，不同生产者生产的数据只会被一个消费者生产，没有呈现线程平安问题，这要归功于实现缓冲区应用到的 BlockingQueue 。

本文转自：https://developer.aliyun.com/&＃8230;