Why RocketMQ Is So Fast: 10 Core Performance Techniques Explained

RocketMQ is a popular open‑source message middleware from Alibaba, renowned for its high throughput in both sending and pulling messages.

Batch Message Sending

RocketMQ supports sending multiple messages in a single request, reducing the number of network round‑trips between client and broker.

<code>public class Producer {
    public static void main(String[] args) throws Exception {
        // Create a producer with group "sanyouProducer"
        DefaultMQProducer producer = new DefaultMQProducer("sanyouProducer");
        // Set NameServer address
        producer.setNamesrvAddr("192.168.200.143:9876");
        producer.start();

        // Prepare a batch of messages
        List<Message> messages = new ArrayList<>();
        messages.add(new Message("sanyouTopic", "三友的java日记 0".getBytes()));
        messages.add(new Message("sanyouTopic", "三友的java日记 1".getBytes()));
        messages.add(new Message("sanyouTopic", "三友的java日记 2".getBytes()));

        // Send the batch and print the result
        SendResult sendResult = producer.send(messages);
        System.out.printf("%s%n", sendResult);

        producer.shutdown();
    }
}
</code>

When using batch messages, the following constraints apply:

All messages must share the same Topic.

Delay and transactional messages are not supported.

The total size of a batch (including normal messages) must not exceed 4 MiB.

Message Compression

If a message exceeds 4 KB, RocketMQ automatically compresses it before transmission, reducing bandwidth usage and storage space. Batch messages are exempt from compression.

High‑Performance Network Model

RocketMQ relies on Netty for its network communication layer. Netty provides asynchronous, event‑driven I/O, zero‑copy buffers, and built‑in SSL/TLS support, which together deliver low latency and high throughput.

Zero‑Copy Technology

To persist messages efficiently, RocketMQ uses zero‑copy techniques such as mmap() and sendfile() , which eliminate unnecessary CPU memory copies and reduce context switches.

mmap()

Memory‑mapped files map a file directly into the process address space, allowing the application to read or write the file as if it were ordinary memory, thus avoiding a CPU copy between user and kernel buffers.

<code>FileChannel fileChannel = new RandomAccessFile("test.txt", "rw").getChannel();
MappedByteBuffer mappedByteBuffer = fileChannel.map(FileChannel.MapMode.READ_WRITE, 0, fileChannel.size());
</code>

sendfile()

The sendfile() system call transfers data from a file descriptor directly to a socket, bypassing user‑space buffers and cutting two context switches.

<code>FileChannel channel = FileChannel.open(Paths.get("./test.txt"), StandardOpenOption.WRITE, StandardOpenOption.CREATE);
// Transfer data to the target channel
channel.transferTo(position, len, target);
</code>

Sequential Write

Messages are written to disk sequentially, which minimizes disk head movement and seek time, further boosting write speed.

Efficient Data Storage Structures

CommitLog

All incoming messages are appended to the CommitLog file. The file is split into 1 GiB segments, and each entry contains the message payload plus metadata such as Topic, queue ID, and producer address.

ConsumeQueue

For each queue, RocketMQ maintains a ConsumeQueue index file. Each index entry is 20 bytes and stores the offset in CommitLog, the message length, and the tag hash. This index enables O(1) lookup of messages during consumption.

Asynchronous Processing

Asynchronous flushing: a background thread flushes PageCache to disk every 0.5 s.

Asynchronous master‑slave replication: the master pushes newly written CommitLog segments to slaves via a dedicated thread.

Batch Processing

Both message pulling and consumer offset commits are performed in batches, reducing network round‑trips and improving overall throughput.

Lock Optimizations

RocketMQ uses ReentrantLock for write serialization and provides an optional CAS‑based lock for low‑contention scenarios. Atomic classes (e.g., AtomicInteger , AtomicLong ) replace traditional synchronized blocks in many places.

Thread‑Pool Isolation

Separate thread pools handle storage requests and pull requests, preventing a slowdown in one type of operation from affecting the other.

Summary

By combining batch operations, compression, Netty‑based networking, zero‑copy I/O, sequential disk writes, optimized index structures, asynchronous flushing/replication, lock refinements, and isolated thread pools, RocketMQ achieves the high performance that developers appreciate.