How RocketMQ Guarantees Strict Message Ordering

Ordered Message Definition

Ordered message means consumption order exactly matches production order. Two categories: global order (FIFO across the entire topic) and partition order (local order within the same order ID). RocketMQ primarily guarantees partition order.

Causes of Disorder

Production stage : default round‑robin sends messages to different MessageQueues; messages of the same order may land in different queues, causing a later‑sent message to be consumed first.

Consumption stage : multiple consumer instances in a consumer group pull from different MessageQueues in parallel; even if stored sequentially, parallel consumption can break order.

Core Mechanism for Ordered Messages

Send all messages that must stay ordered to the same MessageQueue and let a single consumer thread process that queue.

1. Production – Ensure messages enter the same queue

Producer selects a specific MessageQueue via MessageQueueSelector. Commonly the business key (e.g., orderId) is used as a hash key.

// Pseudo‑code example
SendResult sendResult = producer.send(msg, new MessageQueueSelector() {
    @Override
    public MessageQueue select(List<MessageQueue> mqs, Message msg, Object arg) {
        String orderId = (String) arg;
        int index = Math.abs(orderId.hashCode()) % mqs.size();
        return mqs.get(index);
    }
}, orderId); // pass orderId as arg

This routes all messages of the same order (create, pay, ship) to the same MessageQueue.

2. Storage – Queues are naturally ordered

Each MessageQueue on the broker is an ever‑expanding array (Commit Log + Consume Queue). Messages are written sequentially to the Commit Log, and within a single MessageQueue the storage order matches the send order, providing a natural guarantee of order.

3. Consumption – Single‑threaded ordered pull

When a consumer is configured for ordered consumption ( registerMessageListener(new MessageListenerOrderly())), RocketMQ adds a lock to each MessageQueue. Within a consumer group a given queue is assigned to only one consumer instance, which runs a single thread that pulls messages synchronously; the next batch is fetched only after the previous batch is processed successfully.

// Ordered consumption listener
consumer.registerMessageListener(new MessageListenerOrderly() {
    @Override
    public ConsumeOrderlyStatus consumeMessage(List<MessageExt> msgs, ConsumeOrderlyContext context) {
        for (MessageExt msg : msgs) {
            System.out.println("Received message: " + new String(msg.getBody()));
        }
        return ConsumeOrderlyStatus.SUCCESS;
    }
});

If a message fails, RocketMQ retries locally with back‑off intervals (1 s, 5 s, 10 s, …) and blocks further consumption of that queue until the failure is resolved.

Limitations

Performance degradation : serial processing reduces throughput compared with parallel consumption.

High fault sensitivity : a permanently failing message blocks the entire queue, requiring manual intervention.

When to Use Ordered Messages

Order lifecycle: create → pay → ship → receive.

Database binlog synchronization.

If occasional minor ordering inconsistencies are acceptable, the regular concurrent consumption mode should be chosen for better performance.