Disruptor para Java: guía completa con ejemplos prácticos

1. ¿Qué es y para qué sirve?

Disruptor es una biblioteca de alto rendimiento para la comunicación entre hilos (IPC) en Java, desarrollada por la empresa LMAX. Está diseñada para transferir datos entre hilos con latencias mínimas y el máximo rendimiento posible. A diferencia de las colas tradicionales (como LinkedBlockingQueue), Disruptor utiliza un búfer circular (ring buffer) de tamaño fijo, lo que evita la sobrecarga de asignación de memoria, sincronización y recolección de basura.

El principal problema que resuelve Disruptor es la "competencia" entre hilos por los recursos. En las colas tradicionales, varios productores y consumidores compiten por bloqueos, lo que genera tiempos de inactividad y reduce el rendimiento. Disruptor emplea un mecanismo de "barreras de secuencia" (sequence barriers) y bloqueo optimista (CAS — Compare-And-Swap), logrando latencias de microsegundos y un rendimiento de millones de mensajes por segundo.

Esta biblioteca es ideal para sistemas donde la velocidad de procesamiento de eventos es crítica: plataformas de trading, servidores de juegos, sistemas de procesamiento de logs y aplicaciones web de alta carga. Disruptor es la base de muchos frameworks modernos, incluyendo Apache Storm y algunas implementaciones de Event Sourcing.

2. Instalación

Disruptor se distribuye a través de Maven Central. Para usarlo en tu proyecto, agrega la dependencia a tu archivo 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'

Si usas otro gestor de dependencias, descarga el JAR desde Maven Central.

3. Inicio rápido — ejemplo mínimo funcional

En este ejemplo crearemos un Disruptor simple que recibe eventos de tipo String y los imprime en consola.

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

// 1. Definimos la clase del 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 (crea eventos vacíos para reutilizarlos)
public class StringEventFactory implements EventFactory<StringEvent> {
    @Override
    public StringEvent newInstance() {
        return new StringEvent();
    }
}

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

// 4. Clase principal
public class QuickStart {
    public static void main(String[] args) throws InterruptedException {
        // Tamaño del búfer circular (debe ser una potencia de 2)
        int bufferSize = 1024;

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

        // Conectamos el manejador
        disruptor.handleEventsWith(new StringEventHandler());

        // Iniciamos el Disruptor
        disruptor.start();

        // Obtenemos la referencia al RingBuffer
        RingBuffer<StringEvent> ringBuffer = disruptor.getRingBuffer();

        // Publicamos eventos
        for (int i = 0; i < 10; i++) {
            long sequence = ringBuffer.next(); // Reservamos un slot
            try {
                StringEvent event = ringBuffer.