Using LMAX Disruptor as a High‑Performance In‑Memory Message Queue in Java

Background: In a project we needed a message queue and chose Disruptor instead of Kafka or RabbitMQ because of its speed and open‑source nature.

Disruptor Introduction: Disruptor is a high‑performance queue developed by the UK forex trading company LMAX to solve memory‑queue latency. It can handle up to 6 million orders per second and gained industry attention after a 2010 QCon talk.

Core Concepts:

Ring Buffer : a circular buffer that stores events; since version 3.0 its role is limited to storage and update.

Sequence : a monotonically increasing number that tracks the processing progress of each consumer, avoiding false sharing.

Sequencer : the core component with SingleProducerSequencer and MultiProducerSequencer implementations that manage data transfer between producers and consumers.

Sequence Barrier : maintains references to the main published sequence and dependent consumer sequences, deciding whether a consumer can process more events.

Wait Strategy : defines how a consumer waits for the next event (multiple strategies with different performance characteristics).

Event : the data exchanged between producer and consumer, defined by the user.

EventProcessor : holds a consumer’s sequence and runs the event loop.

EventHandler : user‑implemented interface that processes events.

Producer : user code that publishes events to the Disruptor.

Demo – Step‑by‑step implementation:

Add the Maven dependency:

<dependency>
    <groupId>com.lmax</groupId>
    <artifactId>disruptor</artifactId>
    <version>3.4.4</version>
</dependency>

Create the message model:

@Data
public class MessageModel {
    private String message;
}

Implement HelloEventFactory that creates MessageModel instances.

public class HelloEventFactory implements EventFactory<MessageModel> {
    @Override
    public MessageModel newInstance() {
        return new MessageModel();
    }
}

Implement the consumer HelloEventHandler.

@Slf4j
public class HelloEventHandler implements EventHandler<MessageModel> {
    @Override
    public void onEvent(MessageModel event, long sequence, boolean endOfBatch) {
        try {
            Thread.sleep(1000);
            log.info("Consumer start processing");
            if (event != null) {
                log.info("Consumed message: {}", event);
            }
        } catch (Exception e) {
            log.info("Consumer processing failed");
        }
        log.info("Consumer end processing");
    }
}

Provide a BeanManager to access Spring beans.

Configure the Disruptor bean ( MQManager) that creates the RingBuffer, sets the event factory, wait strategy, and registers the handler.

Define the service interface DisruptorMqService and its implementation DisruptorMqServiceImpl that publishes messages to the RingBuffer.

Create a test class DemoApplicationTests that sends a sample message and logs the result.

Test Run Result:

2020-04-05 14:31:18.543 INFO 7274 --- [main] DisruptorMqServiceImpl : record the message: 消息到了，Hello world!
2020-04-05 14:31:18.545 INFO 7274 --- [main] DisruptorMqServiceImpl : 往消息队列中添加消息：MessageModel(message=消息到了，Hello world!)
2020-04-05 14:31:18.545 INFO 7274 --- [main] DemoApplicationTests : 消息队列已发送完毕
2020-04-05 14:31:19.547 INFO 7274 --- [pool-1-thread-1] HelloEventHandler : 消费者处理消息开始
2020-04-05 14:31:19.547 INFO 7274 --- [pool-1-thread-1] HelloEventHandler : 消费者消费的信息是：MessageModel(message=消息到了，Hello world!)
2020-04-05 14:31:19.547 INFO 7274 --- [pool-1-thread-1] HelloEventHandler : 消费者处理消息结束

Summary: The producer‑consumer pattern is common, and many message‑queue solutions can achieve similar results, but Disruptor implements it entirely in memory with a lock‑free design, which explains its high efficiency.