Disruptor para Java: guia completo com exemplos práticos

1. O que é e para que serve

Disruptor é uma biblioteca de alta performance para comunicação entre threads (IPC) em Java, desenvolvida pela empresa LMAX. Ela foi criada para transferir dados entre threads com latência mínima e máxima taxa de transferência. Diferente de filas tradicionais (como LinkedBlockingQueue), o Disruptor utiliza um buffer circular (ring buffer) de tamanho fixo, eliminando a sobrecarga de alocação de memória, sincronização e coleta de lixo (garbage collection).

O principal problema que o Disruptor resolve é a "disputa" entre threads por recursos. Em filas tradicionais, vários produtores e consumidores competem por locks, causando espera e queda de desempenho. O Disruptor usa um mecanismo de "barreiras de sequência" (sequence barriers) e locking otimista (CAS — Compare-And-Swap), alcançando latências na casa dos microssegundos e throughput de milhões de mensagens por segundo.

A biblioteca é ideal para sistemas onde a velocidade de processamento de eventos é crítica: plataformas de trading, servidores de jogos, sistemas de processamento de logs e aplicações web de alta carga. O Disruptor é a base de diversos frameworks modernos, incluindo Apache Storm e algumas implementações de Event Sourcing.

2. Instalação

O Disruptor é distribuído via Maven Central. Para usar no seu projeto, adicione a dependência no seu pom.xml (Maven):

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

Para Gradle (build.gradle):

implementation 'com.lmax:disruptor:4.0.0'

Se você usa outro gerenciador de dependências, baixe o JAR diretamente do Maven Central.

3. Início rápido — exemplo mínimo funcional

Neste exemplo, vamos criar um Disruptor simples que recebe eventos de string e os exibe no console.

import com.lmax.disruptor.*;
import com.lmax.disruptor.dsl.Disruptor;
import com.lmax.disruptor.util.DaemonThreadFactory;

// 1. Define a classe do evento
public class StringEvent {
    private String value;

    public String getValue() { return value; }
    public void setValue(String value) { this.value = value; }
}

// 2. Fábrica de eventos (cria eventos vazios para reutilização)
public class StringEventFactory implements EventFactory<StringEvent> {
    @Override
    public StringEvent newInstance() {
        return new StringEvent();
    }
}

// 3. Manipulador de eventos (Consumer)
public class StringEventHandler implements EventHandler<StringEvent> {
    @Override
    public void onEvent(StringEvent event, long sequence, boolean endOfBatch) {
        System.out.println("Recebido: " + event.getValue());
    }
}

// 4. Classe principal
public class QuickStart {
    public static void main(String[] args) throws InterruptedException {
        // Tamanho do buffer circular (deve ser potência de 2)
        int bufferSize = 1024;

        // Cria o Disruptor
        Disruptor<StringEvent> disruptor = new Disruptor<>(
            new StringEventFactory(),
            bufferSize,
            DaemonThreadFactory.INSTANCE
        );

        // Conecta o manipulador
        disruptor.handleEventsWith(new StringEventHandler());

        // Inicia o Disruptor
        disruptor.start();

        // Obtém a referência ao RingBuffer
        RingBuffer<StringEvent> ringBuffer = disruptor.getRingBuffer();

        // Publica eventos
        for (int i = 0; i < 10; i++) {
            long sequence = ringBuffer.next(); // Reserva um slot
            try {
                StringEvent event = ringBuffer.