RocketMQ 核心原理 - MQ实现批量消息处理

作者简介：大家好，我是smart哥，前中兴通讯、美团架构师，现某互联网公司CTO

联系qq：184480602，加我进群，大家一起学习，一起进步，一起对抗互联网寒冬

学习必须往深处挖，挖的越深，基础越扎实！

阶段1、深入多线程

阶段2、深入多线程设计模式

阶段3、深入juc源码解析

阶段4、深入jdk其余源码解析

阶段5、深入jvm源码解析

码哥源码部分

码哥讲源码-原理源码篇【2024年最新大厂关于线程池使用的场景题】

码哥讲源码【炸雷啦！炸雷啦！黄光头他终于跑路啦！】

码哥讲源码-【jvm课程前置知识及c/c++调试环境搭建】

​​​​​​码哥讲源码-原理源码篇【揭秘join方法的唤醒本质上决定于jvm的底层析构函数】

码哥源码-原理源码篇【Doug Lea为什么要将成员变量赋值给局部变量后再操作？】

码哥讲源码【你水不是你的错,但是你胡说八道就是你不对了！】

码哥讲源码【谁再说Spring不支持多线程事务，你给我抽他！】

终结B站没人能讲清楚红黑树的历史，不服等你来踢馆！

打脸系列【020-3小时讲解MESI协议和volatile之间的关系，那些将x86下的验证结果当作最终结果的水货们请闭嘴】

1 背景

在互联网业务的实际应用场景中，消息的批量处理是非常必要的，因为我们时刻面临着大量数据的并发执行。
例如，我们在一个业务交互的时候会有大量的分支行为需要异步去处理，但是这些动作又是在不同的业务粒度上的，所以我们需要多次调用MQ写入消息，可能有多次的连接和消息发送。
这个写MySQL数据库是一样的，多次建连和写入，跟一次建连和批量数据库，性能是完全不能比的。
所以我们需要有MQ有批量消息的能力来对我们的业务数据进行快速处理。

2 批量消息实现过程

Rocket MQ的批量消息，可以提高消息的吞吐能力和处理效率，降低下游系统的API调用频率，同时对消息服务的稳定性也有帮助。

2.1 批量消息的特点

• 批量消息具有相同的topic。
• 批量消息具有相同的waitStoreMsgOK属性。
• 批量消息不支持延迟消息。
• 批量消息的大小不超过4M（4.4版本之后要求不超过1M）。

2.2 批量消息的使用场景

• 消息的吞吐能力和处理效率：通过将多条消息打包成一批进行发送，可以减少网络传输开销和消息处理的时间，从而提高整体的消息处理效率。
• 下游系统的API调用频率：通过将多条消息合并成一条批量消息进行发送，可以减少下游系统接收和处理消息的次数，从而降低API调用频率，减轻下游系统的负载压力。

2.3 批量消息的发送示例

Rocket MQ提供了批量发送消息的功能，可以通过调用DefaultMQProducer的send()方法，将多条消息以列表的形式发送给指定的topic。
以下是一个简单的示例代码：

    DefaultMQProducer producer = new DefaultMQProducer("BatchProducerGroupName_1");
    String topic = "BatchSendTest_1";
    producer.start();  
    List<Message> msgs = new ArrayList<>();  
    msgs.add(new Message(topic, "Tag1", "OrderID-063105013", "Hello world".getBytes()));  
    msgs.add(new Message(topic, "Tag1", "OrderID-063105014", "Brand".getBytes()));  
    msgs.add(new Message(topic, "Tag1", "OrderID-063105015", "handsome boy ".getBytes()));  
    try {
       producer.send(msgs);
    } catch (Exception e) {
       e.printStackTrace();
       // 处理异常
    }
    finally { 
      // 如果不再发送消息，关闭生产者Producer
      producer.shutdown();
    }

在以上示例代码中，创建了一个DefaultMQProducer实例，并调用其start()方法启动生产者。
然后构造了一个包含三条消息的列表，通过调用producer的send()方法将列表中的消息发送给指定的topic。
如果消息的总长度可能大于1MB时，这时候最好把消息进行分割，参考下面的代码：

    public class ListSplitter implements Iterator<List<Message>> {
        private final int SIZE_LIMIT = 1024 * 1024;
        private final List<Message> messages;
        private int currIndex;
        public ListSplitter(List<Message> messages) {
                this.messages = messages;
        }
        @Override public boolean hasNext() {
            return currIndex < messages.size();
        }
        @Override public List<Message> next() {
            int nextIndex = currIndex;
            int totalSize = 0;
            for (; nextIndex < messages.size(); nextIndex++) {
                Message message = messages.get(nextIndex);
                int tmpSize = message.getTopic().length() + message.getBody().length;
                Map<String, String> properties = message.getProperties();
                for (Map.Entry<String, String> entry : properties.entrySet()) {
                    tmpSize += entry.getKey().length() + entry.getValue().length();
                }
                tmpSize = tmpSize + 20; //for log overhead
                if (tmpSize > SIZE_LIMIT) {
                    //it is unexpected that single message exceeds the SIZE_LIMIT
                    //here just let it go, otherwise it will block the splitting process
                    if (nextIndex - currIndex == 0) {
                       //if the next sublist has no element, add this one and then break, otherwise just break
                       nextIndex++;  
                    }
                    break;
                }
                if (tmpSize + totalSize > SIZE_LIMIT) {
                    break;
                } else {
                    totalSize += tmpSize;
                }
        
            }
            List<Message> subList = messages.subList(currIndex, nextIndex);
            currIndex = nextIndex;
            return subList;
        }
    }
    //then you could split the large list into small ones:
    ListSplitter splitter = new ListSplitter(messages);
    while (splitter.hasNext()) {
       try {
           List<Message>  listItem = splitter.next();
           producer.send(listItem);
       } catch (Exception e) {
           e.printStackTrace();
           // handle the error
       }
    }

可以看出来，Rocket MQ的批量消息可以提高消息的吞吐能力和处理效率，降低下游系统的API调用频率，是一种优化消息传输和处理的有效手段。

3 总结

• 对于同类型、同特征的消息，可以聚合进行批量发送，减少MQ的连接发送次数，能够显著提升性能。
• 批量发送消息须有相同的topic，相同的waitStoreMsgOK，且不能是延时消息。