这种设计模式需要满足以下三点要求：
（1）生产者生产数据到缓冲区中，消费者从缓冲区中取数据。
（2）如果缓冲区已经满了，则生产者线程阻塞；
（3）如果缓冲区为空，那么消费者线程阻塞。
编写之前分析：
（1）定义一个缓存队列，选择一个集合当做缓存，给予缓存上限，缓存队列只有两种行为（生产数据和消费数据）；
（2）定义一个生产者线程，调用缓存队列中的生产行为；
（3）定义一个消费者线程，调用缓存队列中的消费行为；
开始编写代码：
第一种方式:
(双向链表LinkedHashMap和synchronized结合)
定义一个缓存队列
/**
* 公共缓存队列
* 只做两件事：（1）生产；（2）消费
*/
public class PublicQueue<T> {
private int putIndex = 0;//数据插入的角标
private int maxCount = 50;//缓存区最大长度
private LinkedHashMap<Integer, T> linkedHashMap = new LinkedHashMap<>();//缓冲区
public synchronized void add(T msg){
if(linkedHashMap.size() == maxCount){
//如果缓存区达到最大数量，则阻塞生产者线程
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}else{
notifyAll();//唤醒所有线程
}
linkedHashMap.put(putIndex, msg);
System.out.println("生产一个产品，当前商品角标为："+putIndex+"===文本为："+msg+"===缓存长度为："+linkedHashMap.size());
putIndex = (putIndex + 1 >= maxCount) ? (putIndex + 1) % maxCount : putIndex + 1;
}
public synchronized T remove(){
if(linkedHashMap.size() == 0){
//如果缓存区没有数据，则阻塞消费线程
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}else{
notifyAll();//唤醒所有线程
}
Iterator it = linkedHashMap.entrySet().iterator();
T t = null;
if(it.hasNext()){
Map.Entry<Integer, T> entry = (Map.Entry<Integer, T>) it.next();
t = entry.getValue();
int index = entry.getKey();
linkedHashMap.remove(index);
System.out.println("消费一个产品，当前商品角标为："+index+"===文本为："+ t +"===缓存长度为："+linkedHashMap.size());
}
return t;
}
}
定义一个生产者线程
/**
* 生产者线程
*/
public class ProducerThread extends Thread {
private PublicQueue publicQueue;
public ProducerThread(PublicQueue publicQueue){
this.publicQueue = publicQueue;
}
@Override
public void run() {
for(int i=0;i<60;i++){
publicQueue.add(String.valueOf(i));
}
}
}
定义一个消费者线程
/**
* 消费者线程
*/
public class ConsumerThread extends Thread {
private PublicQueue publicQueue;
public ConsumerThread(PublicQueue publicQueue){
this.publicQueue = publicQueue;
}
@Override
public void run() {
for(;;){
publicQueue.remove();
}
}
}
启动：
public class ProducerConsumerTest {
public static void main(String[] args){
PublicQueue publicQueue = new PublicQueue();
ProducerThread producerThread = new ProducerThread(publicQueue);
ConsumerThread consumerThread = new ConsumerThread(publicQueue);
producerThread.start();//启动生产者线程
consumerThread.start();//启动消费者线程
}
}
代码分析：
（1）生产者/消费者设计模式顾名思义就是两个互斥线程，一个负责生产，一个负责消费，两者是线程不安全的；
（2）这里选择使用LinkedHashMap作为缓存队列，LinkedHashMap是一个双向链表，用来处理线程不安全的数据，可以保证取出第一个数据，it.next()就是取出第一个数据。（LinkedHashMap可以保证遍历的顺序）
（3）为了保证互斥线程的安全性，需要做对应的处理，以上代码使用了synchronized 、wait()、notifyAll()来保证。
第二种方式：
双向链表LinkedHashMap和lock结合
/**
* 公共缓存队列
* 只做两件事：（1）生产；（2）消费
*/
public class PublicQueue<T> {
private int putIndex = 0;//数据插入的角标
private int maxCount = 50;//缓存区最大长度
private Lock lock;
private Condition addCondition;
private Condition removeCondition;
public PublicQueue(){
lock = new ReentrantLock();
addCondition = lock.newCondition();
removeCondition =lock.newCondition();
}
private LinkedHashMap<Integer, T> linkedHashMap = new LinkedHashMap<>();//缓冲区
public void add(T msg){
try {
lock.lock();
if (linkedHashMap.size() == maxCount){
//如果缓存区达到最大数量，则阻塞生产者线程
addCondition.await();//等待
}
linkedHashMap.put(putIndex, msg);
System.out.println("生产一个产品，当前商品角标为："+putIndex+"===文本为："+msg+"===缓存长度为："+linkedHashMap.size());
putIndex = (putIndex + 1 >= maxCount) ? (putIndex + 1) % maxCount : putIndex + 1;
removeCondition.signalAll();//唤醒所有线程
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
public T remove(){
T t = null;
try {
lock.lock();
if (linkedHashMap.size() == 0){
//如果缓存区没有数据，则阻塞消费线程
removeCondition.await();//等待
}
Iterator it = linkedHashMap.entrySet().iterator();
if(it.hasNext()){
Map.Entry<Integer, T> entry = (Map.Entry<Integer, T>) it.next();
t = entry.getValue();
int index = entry.getKey();
linkedHashMap.remove(index);
System.out.println("消费一个产品，当前商品角标为："+index+"===文本为："+ t +"===缓存长度为："+linkedHashMap.size());
}
addCondition.signalAll();//唤醒所有线程
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
return t;
}
}
第三种方式：（最简单的）
直接使用阻塞队列BlockingQueue
/**
* 公共缓存队列
* 只做两件事：（1）生产；（2）消费
*/
public class PublicQueue<T> {
private BlockingDeque<T> blockingDeque = new LinkedBlockingDeque<>(50);//缓冲区
public void add(T msg){
try {
blockingDeque.put(msg);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("生产一个产品，当前商品角标为："+"===文本为："+msg);
}
public T remove(){
T t = null;
try {
t = blockingDeque.take();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("消费一个产品，当前商品角标为："+"===文本为："+t);
return t;
}
}
