共计 3462 个字符，预计需要花费 9 分钟才能阅读完成。
工具与资源核心
帮忙开发者更加高效的工作，提供围绕开发者全生命周期的工具与资源
https://developer.aliyun.com/…
一、前言
在上一篇 Java 中的设计模式（一）：观察者模式 中咱们理解了 观察者模式 的基本原理和应用场景，在明天的这篇文章中咱们要做一点简略的延伸性学习——比照一下 生产者 - 消费者模式 和 观察者模式 的异同。
二、什么是“生产者 - 消费者模式”？
和观察者模式不同，生产者 - 消费者模式 自身并不属于设计模式中的任何一种。那么生产者 - 消费者模式到底是什么呢？上面咱们用一个例子简略阐明一下：
如同上图中所示，生产者和消费者就如同一本杂志的投稿作者和订阅的读者，同一本杂志的投稿作者能够有多个，它的读者也能够有多个，而杂志就是连贯作者和读者的桥梁（即缓冲区）。通过杂志这个数据缓冲区，作者能够将实现的作品投递给订阅了杂志的读者，在这一过程中，作者不必关怀读者是否收到了作品或是否实现了浏览，作者和读者是两个绝对独立的对象，两者的行为互不影响。
能够看到，在这个例子当中呈现了三个角色，别离是 生产者、消费者 以及 缓冲区 。生产者和消费者比拟好了解，前者是生产数据，后者则是解决前者生产进去的数据。而缓冲区在生产者 - 消费者模式中则起到了一个 解耦、反对异步、反对忙闲不均 的作用。
三、两者的区别
1. 编程范式不同
生产者 - 消费者模式和观察者模式的第一个不同点在下面曾经说过，前者是一种 面向过程 的软件设计模式，不属于 Gang of Four 提出的 23 种设计模式中的任何一种，而后者则是 23 中设计模式中的一种，也即面向对象的设计模式中的一种。
2. 关联关系不同
这一理念上的不同就带出了下一种不同点，即观察者模式中只有一对多的关系，没有多对多的关系，而在生产者 - 消费者模式中则是多对多的关系。
在观察者模式中，被观察者只有一个，观察者却能够有多个。就比方十字路口的交通灯，直行的车辆只会察看管制直行的交通灯，不会去察看管制左拐或者右拐的交通灯，也就是说察看的对象是固定惟一的。
而在生产者 - 消费者模式中则不同，生产者能够有多个，消费者也能够有多个。还是用下面作者和读者的例子，在这个例子当中，读者只关怀杂志的内容而不用关怀内容的创作者是谁，作者也只须要晓得创作完的作品能够公布到对应的杂志，而不用关怀会有那些读者。
3. 耦合关系不同
从上一个不同中不难看出生产者 - 消费者模式和观察者模式的耦合关系也不雷同，前者为 轻耦合，后者为 重耦合。
4. 利用场景不同
观察者模式多用于 事件驱动模型 当中，生产者 - 消费者模式则多呈现在 过程间通信，用于进行解耦和并发解决，咱们罕用的音讯队列用的就是生产者 - 消费者模式。当然在 Java 中应用生产者 - 消费者模式还须要留神缓冲区的线程平安问题，这里就不做过多叙述。
四、一个小例子
最初用一个简略的 demo 来完结本次的延长学习。
1. StoreQueue– 缓冲区
public class StoreQueue<T> {private final BlockingQueue<T> 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– 生产者
public class Producer implements Runnable{
private StoreQueue<String> storeQueue;
public Producer(StoreQueue<String> storeQueue) {this.storeQueue = storeQueue;}
@Override
public void run() {for (int i = 0; i < 10; i++) {storeQueue.add(Thread.currentThread().getName() + ":" + i);
}
}
}3. Consumer– 消费者
public class Consumer implements Runnable{
private StoreQueue<String> storeQueue;
public Consumer(StoreQueue<String> 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<String> 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/…
