多生产者多消费者模式-优快云博客

本文介绍了一种多生产者多消费者的并发模式，利用多个线程进行数据生产和消费，提高处理效率。文中详细阐述了如何使用Java实现消息队列管理，并通过线程池进一步优化流程。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

多生产者和多消费者场

在多核时代，多线程并发速度比单线程速度更快，所以可以使用多个线程来生产数据，同样也可以使用多个线程来消费数据。而更复杂的是消费者消费的数据可能需要继续处理，于是消费者处理完数据后，他又要作为生产者把数据放在新的队列里，交个其他消费者继续处理如图1所示：

在一个长链接服务器中使用了这种模式，生产者1负责将所有客户端发送的消息存放在阻塞队列1中，消费者1从队列读消息，然后头通过消息ID进行散列分配得到N个队列中的一个，然后根据编号将消息存放在不同的队列里，每一个阻塞队列会分配一个线程来消费阻塞队列里的数据。如果消费者2无法消费消息，就将消息抛回到阻塞队列1中没交个其他消费者处理。

注：主队列主要负责数据处理的统一调度。各子队列需要保持做事的单纯性，就是拿数据并处理数据。某个子队列如果处理不过来，只需要把消息重新发回给主队列，自己不需要计算应该发给哪个子队列更合适。如果增加了新的子队列，也由主队列来平衡各个子队列的处理效率。

消息队列代码

/**
 * 总消息队列管理
 * 
 */
public class MsgQueueManager implements IMsgQueue{

    private static final Logger              LOGGER             
 = LoggerFactory.getLogger(MsgQueueManager.class);


    /**
     * 消息总队列
     */
    public final BlockingQueue
    
    
     
      messageQueue;

    private MsgQueueManager() {
        messageQueue = new LinkedTransferQueue
     
     
      
      ();
    }

    public void put(Message msg) {
        try {
            messageQueue.put(msg);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }

    public Message take() {
        try {
            return messageQueue.take();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        return null;
    }

}

启动一个消息分发线程。在这个线程里子队列自动去总队列里获取消息。

/**
     * 分发消息，负责把消息从大队列塞到小队列里
     * 
     */
    static class DispatchMessageTask implements Runnable {
        @Override
        public void run() {
            BlockingQueue
     
     
      
       subQueue;
            for (;;) {
                //如果没有数据，则阻塞在这里
                Message msg = MsgQueueFactory.getMessageQueue().take();
                //如果为空，则表示没有Session机器连接上来，需要等待，直到有Session机器连接上来
                while ((subQueue = getInstance().getSubQueue()) == null) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                    }
                }
                //把消息放到小队列里
                try {
                    subQueue.put(msg);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        }
    }

使用Hash算法获取一个子队列。

/**
     * 均衡获取一个子队列。
     * 
     * @return
     */
    public BlockingQueue
     
     
      
       getSubQueue() {
        int errorCount = 0;
        for (;;) {
            if (subMsgQueues.isEmpty()) {
                return null;
            }
            int index = (int) (System.nanoTime() % subMsgQueues.size());
            try {
                return subMsgQueues.get(index);
            } catch (Exception e) {
                //出现错误表示，在获取队列大小之后，队列进行了一次删除操作
                LOGGER.error("获取子队列出现错误", e);
                if ((++errorCount) < 3) {
                    continue;
                }
            }
        }
    }

使用的时候我们只需要往总队列里发消息。

//往消息队列里添加一条消息
        IMsgQueue messageQueue = MsgQueueFactory.getMessageQueue();
        Packet msg = Packet.createPacket(Packet64FrameType.
TYPE_DATA, "{}".getBytes(), (short) 1);
        messageQueue.put(msg);

总结

多生产者和多消费的场景使用非常之多，特别是需要处理任务时间比较长的场景，比如上传附件并处理，用户把文件上传到系统后，系统把文件丢到队列里，然后立刻返回告诉用户上传成功，最后消费者再去队列里取出文件处理。比如调用一个远程接口查询数据，如果远程服务接口查询时需要几十秒的时间，那么它可以提供一个申请查询的接口，这个接口把要申请查询任务放数据库中，然后该接口立刻返回。然后服务器端用线程轮询并获取申请任务进行处理，处理完之后发消息给调用方，让调用方再来调用另外一个接口拿数据。

另外Java中的线程池类其实就是一种生产者和消费者模式的实现方式，但是实现方法更高明。生产者把任务丢给线程池，线程池创建线程并处理任务，如果将要运行的任务数大于线程池的基本线程数就把任务扔到阻塞队列里，这种做法比只使用一个阻塞队列来实现生产者和消费者模式显然要高明很多，因为消费者能够处理直接就处理掉了，这样速度更快，而生产者先存，消费者再取这种方式显然慢一些。

我们的系统也可以使用线程池来实现多生产者消费者模式。比如创建N个不同规模的Java线程池来处理不同性质的任务，比如线程池1将数据读到内存之后，交给线程池2里的线程继续处理压缩数据。线程池1主要处理IO密集型任务，线程池2主要处理CPU密集型任务。