Aufgabenwarteschlangen in Java: Von ThreadPoolExecutor bis Disruptor

Aufgabenwarteschlangen in Java: Von integrierten Mechanismen bis zu modernen Frameworks

Aufgabenwarteschlangen (Task Queues) sind ein grundlegendes Muster für den Bau skalierbarer und ausfallsicherer Java-Anwendungen. Sie ermöglichen es, die Geschäftslogik von der Thread-Verwaltung zu trennen, die Last zu verteilen und Aufgaben asynchron zu verarbeiten. In diesem Artikel analysieren wir die wichtigsten Implementierungen von Aufgabenwarteschlangen in Java, ihre Architektur, Codebeispiele und Anwendungsszenarien.

1. Integrierte Mechanismen: ThreadPoolExecutor und BlockingQueue

Die Standardbibliothek von Java (java.util.concurrent) bietet eine leistungsstarke Reihe von Werkzeugen für die Arbeit mit Aufgabenwarteschlangen. Grundlage ist die Klasse ThreadPoolExecutor, die einen Thread-Pool verwaltet und eine Warteschlange zur Speicherung wartender Aufgaben nutzt.

Basisbeispiel:

import java.util.concurrent.*;

public class TaskQueueExample {    public static void main(String[] args) {        // Erstellen eines Thread-Pools: corePoolSize=2, maxPoolSize=4, Warteschlange für 100 Aufgaben        ThreadPoolExecutor executor = new ThreadPoolExecutor(            2, // corePoolSize            4, // maximumPoolSize            60, // keepAliveTime            TimeUnit.SECONDS,            new LinkedBlockingQueue<>(100) // Aufgabenwarteschlange        );

        // Aufgaben senden        for (int i = 0; i < 10; i++) {            final int taskId = i;            executor.submit(() -> {                System.out.println("Aufgabe " + taskId + " wird ausgeführt von Thread " +                                    Thread.currentThread().getName());                try {                    Thread.sleep(1000);                } catch (InterruptedException e) {                    Thread.currentThread().interrupt();                }            });        }

        // Korrektes Beenden        executor.shutdown();    }}

Arten von Warteschlangen für ThreadPoolExecutor:

• LinkedBlockingQueue — unbegrenzte Warteschlange basierend auf einer verketteten Liste. Geeignet für Systeme, bei denen die Anzahl der Aufgaben im Voraus unbekannt ist.
• ArrayBlockingQueue — begrenzte Warteschlange basierend auf einem Array. Ermöglicht die Kontrolle der maximalen Anzahl wartender Aufgaben.
• SynchronousQueue — Warteschlange ohne Kapazität: Jeder put() wartet auf ein take(). Wird für die direkte Weiterleitung von Aufgaben an Threads verwendet.
• PriorityBlockingQueue — Warteschlange mit Priorität. Aufgaben werden nach einem angegebenen Comparator sortiert.

2. Producer-Consumer-Architektur basierend auf Warteschlangen

Das klassische Producer-Consumer-Muster lässt sich einfach mit BlockingQueue umsetzen. Produzenten (Producers) legen Aufgaben in die Warteschlange, und Konsumenten (Consumers) entnehmen sie zur Verarbeitung.

Implementierungsbeispiel:

import java.util.concurrent.*;

public class ProducerConsumerExample {    private static final BlockingQueue<String> queue = new LinkedBlockingQueue<>(5);

    static class Producer implements Runnable {        @Override        public void run() {            try {                for (int i = 0; i < 10; i++) {                    String task = "Aufgabe-" + i;                    queue.put(task); // blockiert, wenn die Warteschlange voll ist                    System.out.println("Produziert: " + task);                    Thread.sleep(100);                }            } catch (InterruptedException e) {                Thread.currentThread().interrupt();            }        }    }

    static class Consumer implements Runnable {        @Override        public void run() {            try {                while (true) {                    String task = queue.take(); // blockiert, wenn die Warteschlange leer ist                    System.out.printl