CKTIS / Java
CompletableFuture: skladanie krokov, časové limity a executory
Skladajte kroky v Java SE 21, zotavujte sa z chýb, koordinujte viac objektov future a explicitne vyberajte executory pre asynchrónne úlohy.
Verzia: 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 patrí do balíka java.util.concurrent. Statická metóda completedFuture(value) vytvorí už úspešne dokončený objekt future. thenApply transformuje úspešný výsledok na hodnotu v novom kroku. Ak funkcia vracia CompletionStage, použite thenCompose: nový krok prevezme výsledok vráteného kroku vrátane prípadného zlyhania, namiesto toho, aby obsahoval samotný krok ako hodnotu. thenCombine zavolá funkciu s oboma výsledkami len vtedy, keď oba kroky uspejú; ani jeden z nich nespúšťa.
completeExceptionally(cause) dokončí ten istý objekt future výnimkou a vráti true, iba ak ho dokončilo práve toto volanie. exceptionally vytvorí nový krok, ktorý posunie úspešný výsledok ďalej alebo vypočíta náhradnú hodnotu z výnimky. join() v prípade potreby blokuje, vráti výsledok, pri zlyhaní vyhodí nekontrolovanú výnimku CompletionException alebo pri zrušení objektu future vyhodí CancellationException. join() volajte radšej na hranici programu, než aby ste v reťazci blokovali pracovné vlákna.
Statická metóda allOf vracia CompletableFuture<Void>, ktorý čaká na dokončenie všetkých vstupov, aj keď niektorý zlyhá. Ak niektorý zlyhá, zlyhá aj tento objekt future. Nezhromažďuje hodnoty; po úspechu ich čítajte jednotlivo. Bez vstupov je už dokončený s hodnotou null. Statická metóda anyOf vracia CompletableFuture<Object>, ktorý sa dokončí s výsledkom alebo výnimkou jedného zo vstupov, keď sa zistí jeho dokončenie. Ak je pri volaní už dokončených viacero vstupov, API nezaručuje výber toho, ktorý sa dokončil najskôr. Nečaká na prvý úspech a ostatné vstupy neruší. Bez vstupov zostáva nedokončený.
Ak objekt future po uplynutí časového limitu stále nie je dokončený, completeOnTimeout(value, timeout, unit) ho úspešne dokončí s náhradnou hodnotou, zatiaľ čo orTimeout(timeout, unit) ho dokončí výnimkou TimeoutException. Obe metódy sú dostupné od Java 9. Nastavujú a vracajú ten istý objekt, nemenia už určený výsledok a neprerušujú výpočet. Limit platí pre dokončenie objektu future, nie iba pre volajúceho, ktorý čaká v join().
supplyAsync(supplier, io) spustí dodávateľa prostredníctvom io a thenApplyAsync(fn, cpu) po úspechu vykoná transformáciu prostredníctvom cpu. Nasledujúce kroky tieto executory nededia. Bez explicitného Executor používa CompletableFuture štandardne ForkJoinPool.commonPool(), alebo nové vlákno na každú úlohu, ak fond nepodporuje paralelizmus aspoň dva. Podtriedy môžu zmeniť predvolený executor inštančných metód. Metódy bez Async, napríklad thenCombine, nezaručujú konkrétny executor ani vlákno a pri pripravených vstupoch môžu funkciu vykonať priamo. Na výber executora pre spojenie použite thenCombineAsync(other, fn, executor).
Príklady
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());
}
}
}Výsledok
composed=10 recovered=-1 any=ready all=ready,done fallback=0, same=true timeout=TimeoutException async=17
Väčšina krokov v prvej kompozícii používa už dostupné výsledky. Objekty future s časovým limitom nemajú úlohu, ktorá by ich dokončila, takže výsledok nezávisí od toho, či výpočet predbehne časový limit. `io` a `cpu` sú dva samostatné ukážkové executory; try-with-resources oba zatvorí. Nepredpokladajte konkrétny uplynutý čas ani vlákno pre `thenCombine`.
Súvisiace lekcie
- Java · Lekcia 41 · Pokročilá · Verzia: 2
- Java · Lekcia 42 · Pokročilá · Verzia: 2