【Java】设计模式之生产者/消费者

设计模式之生产者/消费者

这个设计模式使用一个消息队列对生产者和消费者进行解耦。它与保护性暂停最大的区别就是它并不需要产生结果者与消费结果者一一对应，而是可以多对多。而且这个设计模式它传递消息会存在一定的延迟，而保护性暂停传递信息是十分及时的。

• 消费者从消息队列中取消息，如果消息队列为空，消费者会进入阻塞状态；如果消息队列不为空，消费者会取出消息队列头的消息然后唤醒所有生产者。

• 生产者将消息放入消息队列中直到消息队列满，这时候生产者会进入阻塞状态；如果消息队列不满，生产者将消息放入消息队列后会唤醒所有的消费者。

package org.example;


import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.ArrayDeque;
import java.util.Hashtable;
import java.util.Map;

/**
* @author xcy
*/

public class Main {
   static Logger logger= LoggerFactory.getLogger("main");

   public static void main(String[] args) throws InterruptedException {
       MessageQueue messageQueue = new MessageQueue(2);
       for (int i = 0; i < 3; i++) {
           int finalI = i;
           new Thread(()->{
               messageQueue.put(new Message(finalI,"值"+finalI));
           },"生产者"+i).start();
       }

       for (int i = 0; i < 2; i++) {
           new Thread(()->{
               messageQueue.take();
           },"消费者"+i).start();
       }
   }
}

class MessageQueue{
   static Logger logger= LoggerFactory.getLogger("MessageQueue");

   //双向列表用于消息队列的容器
   private ArrayDeque<Message> queue=new ArrayDeque<>();
   //消息队列容量
   private int capcity;

   public MessageQueue(int capcity) {
       this.capcity = capcity;
   }

   //获取信息
   public Message take(){
       //检查对象是否为空
       synchronized (queue){
           while(queue.isEmpty()){
               logger.debug("队列空，消费者阻塞");
               try {
                   queue.wait();
               } catch (InterruptedException e) {
                   throw new RuntimeException(e);
               }
           }
           //从列表头部取出消息并唤醒阻塞的生产者，这时候如果有消费者也被唤醒，队列不为空可以继续消费，为空也会继续阻塞
           Message message = queue.removeFirst();
           logger.debug("消费者消费：{}",message);
           queue.notifyAll();
           return message;
       }
   }

   //存入信息
   public void put(Message message){
       synchronized (queue){
           //消息队列如果已经满了，线程需要阻塞
           while(queue.size()==capcity){
               logger.debug("队列满，生产者阻塞");
               try {
                   queue.wait();
               } catch (InterruptedException e) {
                   throw new RuntimeException(e);
               }
           }
           //生产消息并唤醒阻塞的消费者，这时候如果有生产者也被唤醒，队列不满会继续生产消息，满则会继续阻塞
           logger.debug("生产者消息：{}",message);
           queue.add(message);
           queue.notifyAll();
       }
   }
}

class Message{
   private Integer id;
   private Object value;

   public Message(Integer id, Object value) {
       this.id = id;
       this.value = value;
   }

   public Integer getId() {
       return id;
   }

   public Object getValue() {
       return value;
   }

   @Override
   public String toString() {
       return "Message{" +
               "id=" + id +
               ", value=" + value +
               '}';
   }
}