RocketMQ中的消息顺序与并发处理如何平衡？

用心去追梦

于 2024-09-24 10:26:50 发布

阅读量855

点赞数 22

文章标签： java-rocketmq rocketmq java

本文链接：https://blog.csdn.net/qq_33240556/article/details/142482918

版权

在 RocketMQ 中，消息顺序和并发处理是两个相互矛盾的需求。一方面，某些业务场景要求消息严格按照发送顺序被消费；另一方面，为了提高系统的吞吐量和性能，我们又希望尽可能地并行处理消息。RocketMQ 提供了一些机制来平衡这两个需求。

消息顺序

RocketMQ 支持两种类型的消息顺序：

全局顺序：一个 Topic 下的所有消息都严格按照发送顺序被消费。
分区顺序：一个 Topic 下的每个队列（Queue）内的消息都严格按照发送顺序被消费，但不同队列之间没有顺序保证。

全局顺序

单个队列：要实现全局顺序，可以将所有消息发送到同一个队列中。这样消费者就可以按照消息发送的顺序来消费消息。
性能问题：由于所有消息都在同一个队列中，这会成为系统的瓶颈，限制了系统的吞吐量。

分区顺序

多个队列：通过为不同的消息设置不同的 Message Key，可以将消息路由到特定的队列中。这样每个队列内的消息可以保持顺序。
负载均衡：通过这种方式，可以将消息分散到多个队列中，从而实现一定程度的并发处理。

并发处理

为了提高系统的吞吐量，RocketMQ 支持多线程并发消费消息。以下是几种常见的并发处理方式：

多消费者实例：在一个消费者组内启动多个消费者实例，每个实例可以独立地从不同的队列中拉取消息进行处理。
多线程消费：在单个消费者实例内部使用多线程来处理消息。可以通过配置 consumeThreadMin 和 consumeThreadMax 参数来控制消费者实例中的线程数。

平衡策略

为了平衡消息顺序和并发处理，可以采取以下几种策略：

合理划分队列：
- 根据业务需求，将消息划分为不同的队列。例如，对于需要严格顺序的消息，可以将其发送到同一个队列；对于不需要严格顺序的消息，则可以均匀分布到多个队列中。
- 通过 Message Key 或者自定义的路由算法，确保相关联的消息被发送到同一个队列中。
混合模式：
- 对于部分需要顺序处理的消息，使用分区顺序；对于其他不需要顺序处理的消息，使用集群模式（多消费者实例或多线程消费）来提高并发处理能力。
消费者端优化：
- 在消费者端，可以通过合理的线程池配置来平衡顺序性和并发性。例如，对于顺序消费，可以使用单线程或固定大小的线程池；对于并发消费，可以使用动态调整大小的线程池。
批量处理：
- 在不影响顺序性的前提下，可以考虑批量处理消息。例如，在确保同一批次的消息来自同一个队列的情况下，可以在消费者端批量处理这些消息。
监控与调优：
- 通过监控系统性能指标（如消息积压、消费延迟等），不断调整队列数量、线程池大小等参数，以达到最佳的性能和可靠性。

示例代码

以下是一个简单的示例，展示了如何在 RocketMQ 中实现分区顺序消费：

生产者

import org.apache.rocketmq.client.producer.DefaultMQProducer;
import org.apache.rocketmq.common.message.Message;

public class OrderedProducer {
    public static void main(String[] args) throws Exception {
        DefaultMQProducer producer = new DefaultMQProducer("OrderedProducerGroup");
        producer.setNamesrvAddr("localhost:9876");
        producer.start();

        // 发送消息到不同的队列
        for (int i = 0; i < 10; i++) {
            Message msg = new Message("OrderedTopic", "OrderID_" + i % 4, ("Hello RocketMQ " + i).getBytes());
            producer.send(msg);
        }

        producer.shutdown();
    }
}

消费者

import org.apache.rocketmq.client.consumer.DefaultMQPushConsumer;
import org.apache.rocketmq.client.consumer.listener.ConsumeOrderlyContext;
import org.apache.rocketmq.client.consumer.listener.ConsumeOrderlyStatus;
import org.apache.rocketmq.client.consumer.listener.MessageListenerOrderly;
import org.apache.rocketmq.common.message.MessageExt;

import java.util.List;
import java.util.concurrent.atomic.AtomicLong;

public class OrderedConsumer {
    public static void main(String[] args) throws Exception {
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("OrderedConsumerGroup");
        consumer.setNamesrvAddr("localhost:9876");

        // 订阅 Topic
        consumer.subscribe("OrderedTopic", "*");

        // 设置顺序消费监听器
        consumer.registerMessageListener(new MessageListenerOrderly() {
            AtomicLong consumeTimes = new AtomicLong(0);

            @Override
            public ConsumeOrderlyStatus consumeMessage(List<MessageExt> msgs, ConsumeOrderlyContext context) {
                context.setAutoCommit(true); // 自动提交
                for (MessageExt msg : msgs) {
                    System.out.println("Receive message: " + new String(msg.getBody()));
                }

                this.consumeTimes.incrementAndGet();
                if ((this.consumeTimes.get() % 2) == 0) {
                    return ConsumeOrderlyStatus.SUCCESS;
                } else if ((this.consumeTimes.get() % 3) == 0) {
                    return ConsumeOrderlyStatus.ROLLBACK;
                } else if ((this.consumeTimes.get() % 4) == 0) {
                    return ConsumeOrderlyStatus.COMMIT;
                } else if ((this.consumeTimes.get() % 5) == 0) {
                    context.setSuspendCurrentQueueTimeMillis(3000); // 暂停当前队列 3 秒钟
                    return ConsumeOrderlyStatus.SUSPEND_CURRENT_QUEUE_A_MOMENT;
                }

                return ConsumeOrderlyStatus.SUCCESS;
            }
        });

        consumer.start();
    }
}