Disruptor für Java: Vollständiges Tutorial mit Codebeispielen

1. Was ist der Disruptor und wozu braucht man ihn?

Der Disruptor ist eine hochperformante Bibliothek für die Inter-Thread-Kommunikation (IPC) in Java, entwickelt von der Firma LMAX. Sie wurde konzipiert, um Daten zwischen Threads mit minimalen Latenzen und maximalem Durchsatz zu übertragen. Im Gegensatz zu traditionellen Warteschlangen (z. B. LinkedBlockingQueue) nutzt der Disruptor einen Ringpuffer (Ring Buffer) mit fester Größe. Dadurch werden Overhead durch Speicherallokation, Synchronisation und Garbage Collection vermieden.

Das Hauptproblem, das der Disruptor löst, ist der „Wettbewerb“ von Threads um Ressourcen. In traditionellen Warteschlangen konkurrieren mehrere Producer und Consumer um Sperren (Locks), was zu Leerlaufzeiten und Leistungseinbußen führt. Der Disruptor verwendet einen Mechanismus namens „Sequence Barriers“ und optimistische Sperren (CAS – Compare-And-Swap), um Latenzen im Mikrosekundenbereich und einen Durchsatz von Millionen Nachrichten pro Sekunde zu erreichen.

Die Bibliothek ist ideal für Systeme, bei denen die Geschwindigkeit der Ereignisverarbeitung kritisch ist: Börsenplattformen, Spieleserver, Logverarbeitungssysteme und hochlastige Webanwendungen. Der Disruptor bildet die Grundlage für viele moderne Frameworks, darunter Apache Storm und einige Implementierungen von Event Sourcing.

2. Installation

Der Disruptor wird über Maven Central vertrieben. Fügen Sie für die Nutzung in Ihrem Projekt die folgende Abhängigkeit in Ihre pom.xml (Maven) ein:

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

Für Gradle (build.gradle):

implementation 'com.lmax:disruptor:4.0.0'

Wenn Sie einen anderen Abhängigkeitsmanager verwenden, laden Sie das JAR von Maven Central herunter.

3. Schnellstart – Ein minimales funktionierendes Beispiel

In diesem Beispiel erstellen wir einen einfachen Disruptor, der String-Ereignisse entgegennimmt und auf der Konsole ausgibt.

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

// 1. Ereignisklasse definieren
public class StringEvent {
    private String value;

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

// 2. Ereignisfabrik (erzeugt leere Ereignisse zur Wiederverwendung)
public class StringEventFactory implements EventFactory<StringEvent> {
    @Override
    public StringEvent newInstance() {
        return new StringEvent();
    }
}

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

// 4. Hauptklasse
public class QuickStart {
    public static void main(String[] args) throws InterruptedException {
        // Größe des Ringpuffers (muss eine Zweierpotenz sein)
        int bufferSize = 1024;

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

        // Ereignisbehandler anmelden
        disruptor.handleEventsWith(new StringEventHandler());

        // Disruptor starten
        disruptor.start();

        // Referenz auf den RingBuffer holen
        RingBuffer<StringEvent> ringBuffer = disruptor.getRingBuffer();

        // Ereignisse veröffentlichen
        for (int i = 0; i < 10; i++) {
            long sequence = ringBuffer.next(); // Slot reservieren
            try {
                StringEvent event = ringBuffer.