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. 消费者

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