Was ist CompletableFuture?

CompletableFuture in Java 8+ stellt eine Erweiterung des Future-Modells dar, die asynchrone Programmierung und Aufgabenkomposition ermöglicht.

Es implementiert die Schnittstellen CompletionStage und Future. CompletionStage legt den Vertrag für asynchrone Ausführung und Komposition von Berechnungsschritten fest.

Wichtige Merkmale:

• Nicht-blockierende Operationen: Ermöglicht die asynchrone Ausführung von Aufgaben, ohne den Haupt-Thread zu blockieren.
• Komposition: Bietet eine reiche API zum Verknüpfen und Kombinieren von Ergebnissen mehrerer asynchroner Operationen.
• Fehlerbehandlung: Eingebaute Mechanismen zur Fehlerbehandlung in asynchronen Flüssen.
• Erstellung: Es können abgeschlossene, nicht abgeschlossene oder fehlerhafte CompletableFuture-Objekte erstellt werden.
• Abhängigkeiten: Ermöglicht das Erstellen von Ketten abhängiger Aufgaben, bei denen die Ausführung einer von der Beendigung einer anderen abhängt.
• Parallele Ausführung: Methoden wie allOf und anyOf für die parallele Ausführung mehrerer Aufgaben.

Anwendungsbeispiele:

1. Erstellung und Abschluss:

   // Erstellen eines abgeschlossenen CompletableFuture
   CompletableFuture<String> completedFuture = CompletableFuture.completedFuture("Hallo");
   
   // Erstellen eines nicht abgeschlossenen CompletableFuture und späteres Abschließen
   CompletableFuture<String> future = new CompletableFuture<>();
   // ... asynchrone Arbeit ausführen ...
   future.complete("Fertig");
   // Oder im Fehlerfall
   // future.completeExceptionally(new RuntimeException("Fehler"));
   

2. Ausführen einer asynchronen Aufgabe:

   CompletableFuture<String> asyncFuture = CompletableFuture.supplyAsync(() -> {
       // Asynchrone Arbeit (z.B. Datei lesen, Netzwerkanfrage)
       try {
           Thread.sleep(1000);
       } catch (InterruptedException e) {
           throw new IllegalStateException(e);
       }
       return "Asynchrones Ergebnis";
   });
   

3. Komposition mit thenApply:

   CompletableFuture<Integer> result = CompletableFuture.supplyAsync(() -> 10)
       .thenApply(x -> x * 2); // Das Ergebnis des vorherigen Schritts wird an die Funktion übergeben
   

4. Komposition mit thenCombine:

   CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> 10);
   CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> 20);
   
   CompletableFuture<Integer> combinedFuture = future1.thenCombine(future2, (res1, res2) -> res1 + res2); // Ergebnisse zweier CompletableFutures zusammenführen
   

5. Behandlung des Abschlusses mit thenAccept:

   CompletableFuture.supplyAsync(() -> "Endergebnis")
       .thenAccept(result -> System.out.println("Aufgabe beendet mit Ergebnis: " + result)); // Aktion nach Abschluss ausführen ohne Rückgabewert
   

6. Fehlerbehandlung mit exceptionally:

   CompletableFuture<String> futureWithException = CompletableFuture.supplyAsync(() -> {
       throw new RuntimeException("Etwas ist schief gelaufen");
   }).exceptionally(ex -> {
       System.err.println("Fehler aufgetreten: " + ex.getMessage());
       return "Standardwert"; // Rückgabe eines Standardwerts bei Fehler
   });
   

CompletableFuture vereinfacht die asynchrone und nicht-blockierende Programmierung in Java erheblich, macht den Code lesbarer und wartbarer im Vergleich zu traditionellen Callbacks oder blockierenden Aufrufen wie Future.get().