WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / Java

CompletableFuture — asynchrone Berechnungen verknüpfen

CompletableFuture<T> steht für ein zukünftiges Ergebnis und ermöglicht es, abhängige Verarbeitungsschritte zu verknüpfen, ohne nach jedem Schritt zu blockieren. Lerne Transformation, Komposition, Ergebniskombination, Fehlerbehandlung und Zeitlimits in Java SE 21 kennen.

Version: Java SE 21; repository runtime, production runtime not attested

Syntax

CompletableFuture<T> future = CompletableFuture.supplyAsync(supplier, executor);
CompletableFuture<U> mapped = future.thenApply(mapper);
CompletableFuture<U> composed = future.thenCompose(asyncMapper);
T result = future.join();

CompletableFuture<T> verbindet ein Future<T>-Ergebnis mit CompletionStage<T>-Stufen. CompletableFuture.supplyAsync übergibt eine Berechnung zur Ausführung; CompletableFuture.completedFuture erstellt ein bereits abgeschlossenes Ergebnis. CompletableFuture.completeExceptionally schließt ein noch nicht abgeschlossenes Future mit einem Fehler ab. Geltungsbereich: Java SE 21; Laufzeitumgebung des Repositorys, Produktionsumgebung nicht bestätigt.

CompletableFuture.thenApply wandelt ein erfolgreiches Ergebnis um; ein eigener Thread ist dabei nicht garantiert. CompletableFuture.thenApplyAsync übergibt die Funktion einem Executor zur Ausführung. Standardmäßig wird ForkJoinPool.commonPool() verwendet; liegt die Parallelität unter zwei, wird für jede Aufgabe ein Thread erstellt. Du kannst ausdrücklich einen eigenen Executor angeben. CompletableFuture.thenCompose flacht eine Funktion ab, die eine weitere Stufe zurückgibt, statt ein verschachteltes Ergebnis zu erzeugen. CompletableFuture.thenCombine kombiniert Werte, sobald beide Stufen erfolgreich abgeschlossen sind.

CompletableFuture.exceptionally berechnet nur im Fehlerfall einen Ersatzwert. CompletableFuture.allOf wartet auf alle Stufen, gibt CompletableFuture<Void> zurück und leitet einen Fehler weiter, falls eine Stufe fehlschlägt; Werte werden nicht gesammelt. CompletableFuture.anyOf gibt CompletableFuture<Object> mit dem Ergebnis oder Fehler einer der abgeschlossenen Stufen zurück – nicht unbedingt mit einem Erfolg. Die übrigen Aufgaben werden nicht abgebrochen.

CompletableFuture.join und CompletableFuture.get blockieren bis zum Abschluss. Fehler werden üblicherweise in die ungeprüfte CompletionException beziehungsweise die geprüfte ExecutionException verpackt; get kann außerdem InterruptedException auslösen. Bei einem Abbruch wird CancellationException ausgelöst. Vermeide blockierende Aufrufe innerhalb abhängiger Aufgaben.

CompletableFuture.completeOnTimeout schließt dasselbe Future mit einem Ersatzwert ab; CompletableFuture.orTimeout schließt es mit TimeoutException ab, sofern es nicht bereits abgeschlossen ist. Keine der Methoden stoppt die zugrunde liegende Berechnung. Dagegen begrenzt get(timeout, unit) nur die Wartezeit des Aufrufers.

Beispiele

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.Executors;

public class Main {
    public static void main(String[] args) {
        try (var executor = Executors.newFixedThreadPool(2)) {
            var base = CompletableFuture.supplyAsync(() -> 20, executor);
            var result = base
                .thenApply(n -> n + 1)
                .thenCompose(n -> CompletableFuture.completedFuture(n * 2))
                .thenCombine(CompletableFuture.completedFuture(8), Integer::sum);

            var failed = new CompletableFuture<Integer>();
            failed.completeExceptionally(new IllegalStateException("unavailable"));
            var recovered = failed.exceptionally(error -> -1);

            CompletableFuture.allOf(result, recovered).join();
            System.out.println("result=" + result.join());
            System.out.println("recovered=" + recovered.join());
        }
    }
}

Ergebnis

result=50
recovered=-1

Der angezeigte Code und das angegebene Ergebnis wurden in einer isolierten Umgebung mit der im Prüfnachweis für genau diese Version dokumentierten Methode verifiziert.

Quellen