CKTIS / Java
CompletableFuture: Komposition, Zeitlimits und Executor
Verknüpfe Stufen in Java SE 21, behandle Fehler, koordiniere mehrere Futures und wähle Executor für asynchrone Aufgaben ausdrücklich aus.
Version: Java SE 21
Syntax
import java.util.concurrent.CompletableFuture;
CompletableFuture.completedFuture(value)
future.thenApply(value -> mappedValue)
future.thenCompose(value -> nextStage)
future.thenCombine(otherStage, (left, right) -> combinedValue)
future.completeExceptionally(cause)
future.exceptionally(cause -> fallbackValue)
CompletableFuture.allOf(future1, future2)
CompletableFuture.anyOf(future1, future2)
future.completeOnTimeout(fallbackValue, timeout, unit)
future.orTimeout(timeout, unit)
CompletableFuture.supplyAsync(() -> value)
CompletableFuture.supplyAsync(() -> value, io)
future.thenApplyAsync(value -> mappedValue)
future.thenApplyAsync(value -> mappedValue, cpu)
future.join()CompletableFuture gehört zu java.util.concurrent. Die statische Methode completedFuture(value) erzeugt ein bereits erfolgreich abgeschlossenes Future. thenApply bildet ein erfolgreiches Ergebnis auf einen Wert in einer neuen Stufe ab. Verwende thenCompose, wenn die Funktion eine CompletionStage zurückgibt: Die neue Stufe übernimmt deren Ausgang, statt die Stufe selbst als Wert zu enthalten. thenCombine ruft die Funktion erst mit beiden Ergebnissen auf, wenn beide Stufen erfolgreich sind; es startet keine davon.
completeExceptionally(cause) schließt dasselbe Future mit einem Fehler ab und liefert nur dann true, wenn dieser Aufruf den Abschluss bewirkt hat. exceptionally erzeugt eine neue Stufe, die ein erfolgreiches Ergebnis unverändert weitergibt oder aus der Ausnahme einen Ersatzwert berechnet. join() blockiert bei Bedarf. Es liefert das Ergebnis, wirft bei einem Fehler eine ungeprüfte CompletionException oder bei einem abgebrochenen Future eine CancellationException. Rufe join() lieber am Rand des Programms auf, statt Arbeitsthreads in einer Kette zu blockieren.
Die statische Methode allOf liefert ein CompletableFuture<Void>, das auf alle Eingaben wartet, auch wenn eine fehlschlägt. Dann schlägt es ebenfalls fehl. Es sammelt keine Werte; lies diese nach Erfolg einzeln aus. Ohne Eingaben ist es bereits mit null abgeschlossen. Die statische Methode anyOf liefert ein CompletableFuture<Object>, das mit dem Ergebnis oder der Ausnahme einer Eingabe abgeschlossen wird, sobald deren Abschluss erkannt wird. Sind beim Aufruf bereits mehrere Eingaben abgeschlossen, garantiert die API nicht, dass sie die zeitlich zuerst abgeschlossene Eingabe auswählt. Es wartet nicht auf einen Erfolg und bricht die anderen Eingaben nicht ab. Ohne Eingaben bleibt es offen.
Ist das Future bei Ablauf des Zeitlimits noch offen, schließt completeOnTimeout(value, timeout, unit) es erfolgreich mit dem Ersatzwert ab; orTimeout(timeout, unit) schließt es mit einer TimeoutException ab. Beide Methoden gibt es seit Java 9. Sie konfigurieren dasselbe Future und geben es zurück, ändern kein bereits feststehendes Ergebnis und unterbrechen die Berechnung nicht. Das Zeitlimit gilt für den Abschluss des Futures, nicht nur für einen in join() wartenden Aufrufer.
supplyAsync(supplier, io) führt den Supplier über io aus; thenApplyAsync(fn, cpu) führt die Umwandlung nach Erfolg über cpu aus. Nachfolgende Stufen erben diese Executor nicht. Ohne expliziten Executor verwendet CompletableFuture normalerweise ForkJoinPool.commonPool(), bei fehlender Parallelität von mindestens zwei jedoch einen neuen Thread pro Aufgabe. Unterklassen können die Vorgabe für Instanzmethoden überschreiben. Methoden ohne Async wie thenCombine garantieren keinen bestimmten Executor oder Thread und können bei vorliegenden Eingaben direkt laufen. Verwende thenCombineAsync(other, fn, executor), um den Executor für die Kombination festzulegen.
Beispiele
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionException;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
public class Main {
public static void main(String[] args) {
var composed = CompletableFuture.completedFuture(2)
.thenApply(n -> n + 1)
.thenCompose(n -> CompletableFuture.completedFuture(n * 2))
.thenCombine(CompletableFuture.completedFuture(4), Integer::sum);
System.out.println("composed=" + composed.join());
var failed = new CompletableFuture<Integer>();
failed.completeExceptionally(new IllegalStateException("unavailable"));
System.out.println("recovered=" + failed.exceptionally(error -> -1).join());
var ready = CompletableFuture.completedFuture("ready");
var pending = new CompletableFuture<String>();
System.out.println("any=" + CompletableFuture.anyOf(ready, pending).join());
var all = CompletableFuture.allOf(ready, pending);
pending.complete("done");
all.join();
System.out.println("all=" + ready.join() + "," + pending.join());
var fallback = new CompletableFuture<Integer>();
var same = fallback.completeOnTimeout(0, 10, TimeUnit.MILLISECONDS);
System.out.println("fallback=" + same.join() + ", same=" + (same == fallback));
var deadline = new CompletableFuture<Integer>();
try {
deadline.orTimeout(10, TimeUnit.MILLISECONDS).join();
} catch (CompletionException error) {
System.out.println("timeout=" + error.getCause().getClass().getSimpleName());
}
try (var io = Executors.newSingleThreadExecutor();
var cpu = Executors.newSingleThreadExecutor()) {
var loaded = CompletableFuture.supplyAsync(() -> 7, io);
var offset = CompletableFuture.supplyAsync(() -> 3, io);
var total = loaded.thenApplyAsync(n -> n * 2, cpu)
.thenCombine(offset, Integer::sum);
System.out.println("async=" + total.join());
}
}
}Ergebnis
composed=10 recovered=-1 any=ready all=ready,done fallback=0, same=true timeout=TimeoutException async=17
Die meisten Stufen der ersten Komposition verwenden bereits verfügbare Ergebnisse. Die Futures mit Zeitlimit haben keine Produzenten; ihr Ausgang hängt nicht von einem Wettlauf mit einer Berechnung ab. `io` und `cpu` sind getrennte Executor zur Demonstration; try-with-resources schließt beide. Verlasse dich weder auf eine bestimmte Laufzeit noch auf einen bestimmten Thread für `thenCombine`.
Zugehörige Lektionen
- Java · Lektion 41 · Fortgeschritten · Version: 2
- Java · Lektion 42 · Fortgeschritten · Version: 2