Erzählen Sie uns vom Konzept der Klasse…

CompletableFuture ist eine Klasse in Java 8+, die die Schnittstellen Future und CompletionStage implementiert. Sie stellt eine asynchrone Berechnung dar, die zu einem bestimmten Zeitpunkt in der Zukunft abgeschlossen (oder fehlschlagen) kann, und auf deren Ergebnis man deklarativ nachfolgende Aktionen ausführen kann, ohne den Haupt-Thread zu blockieren.

Hauptfunktionen:

Asynchrone Ausführung: Ermöglicht das Starten von Aufgaben in einem separaten Thread (oder Thread-Pool).
Komposition: Es ist möglich, mehrere CompletableFuture zu kombinieren und abhängige Aktionsketten zu erstellen.
Fehlerbehandlung: Bietet Methoden zur Handhabung von Fehlern bei asynchronen Berechnungen.
Nicht-blockierende Operationen: Das Ergebnis oder die Ausnahme werden behandelt, wenn der Future abgeschlossen ist, ohne explizit zu warten (get()).

Schlüsselmethoden:

Erstellung:
- supplyAsync(Supplier<T> supplier): Führt einen Supplier asynchron aus und gibt ein CompletableFuture mit seinem Ergebnis zurück.
- runAsync(Runnable runnable): Führt ein Runnable asynchron aus und gibt ein CompletableFuture<Void> zurück.
- completedFuture(T value): Erstellt ein bereits abgeschlossenes CompletableFuture mit einem vorgegebenen Wert.
Transformation:
- thenApply(Function<T, U> fn): Wendet eine Funktion an, wenn der Future abgeschlossen ist.
- thenAccept(Consumer<T> action): Führt eine Aktion auf dem Ergebnis aus, wenn der Future abgeschlossen ist.
- thenRun(Runnable action): Führt eine Aktion aus, wenn der Future abgeschlossen ist, ohne das Ergebnis zu berücksichtigen.
- thenCompose(Function<T, CompletionStage<U>> fn): Ermöglicht das Erstellen von Ketten, bei denen das Ergebnis eines Futures zur Erstellung eines anderen verwendet wird.
Kombination:
- thenCombine(CompletionStage<U> other, BiFunction<T, U, V> fn): Kombiniert die Ergebnisse zweier Futures.
- allOf(CompletableFuture<?>... cfs): Gibt ein CompletableFuture<Void> zurück, das abgeschlossen wird, wenn alle übergebenen Futures abgeschlossen sind.
- anyOf(CompletableFuture<?>... cfs): Gibt ein CompletableFuture<Object> zurück, das abgeschlossen wird, wenn einer der übergebenen Futures abgeschlossen ist.
Fehlerbehandlung:
- exceptionally(Function<Throwable, T> fn): Behandelt Ausnahmen und gibt einen alternativen Wert zurück.
- handle(BiFunction<T, Throwable, U> fn): Behandelt sowohl das Ergebnis als auch Ausnahmen.

Beispiel:

// Asynchrone Aufgabe starten
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    try {
        Thread.sleep(1000); // Simulation einer langen Arbeit
    } catch (InterruptedException e) {
        throw new IllegalStateException(e);
    }
    return "Ergebnis der asynchronen Operation";
});

// Aktion nach Abschluss der Aufgabe ausführen (nicht blockierend)
future.thenAccept(result -> {
    System.out.println("Erhaltenes Ergebnis: " + result);
});

// Eine weitere Aktion, die von der ersten abhängt
future.thenApply(String::toUpperCase)
      .thenAccept(upperCaseResult -> {
          System.out.println("Ergebnis in Großbuchstaben: " + upperCaseResult);
      });

// Warten auf alle Aufgaben (in echten Anwendungen wird die explizite Verwendung von get/join meist vermieden)
// future.join();

CompletableFuture ist ein mächtiges Werkzeug, um reaktive und nicht-blockierende Codes in Java zu schreiben, was die Arbeit mit Asynchronität im Vergleich zur klassischen Future-Schnittstelle erheblich vereinfacht.

Erzählen Sie uns vom Konzept der Klasse CompletableFuture.