KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / Java

CompletableFuture — asynchrone berekeningen samenstellen

CompletableFuture<T> vertegenwoordigt een toekomstig resultaat en laat je afhankelijke stappen koppelen zonder na elke stap te blokkeren. Leer over transformaties, compositie, het combineren van resultaten, foutherstel en time-outs in Java SE 21.

Versie: 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> combineert een Future<T>-resultaat met CompletionStage<T>-stappen. CompletableFuture.supplyAsync dient een berekening in voor uitvoering; CompletableFuture.completedFuture maakt een al voltooide uitkomst. CompletableFuture.completeExceptionally voltooit een nog niet afgeronde future met een fout. Reikwijdte: Java SE 21; runtimeomgeving van de repository, productieomgeving niet bevestigd.

CompletableFuture.thenApply transformeert een succesvol resultaat; een aparte thread is niet gegarandeerd. CompletableFuture.thenApplyAsync dient de functie in bij een executor voor uitvoering. Standaard wordt ForkJoinPool.commonPool() gebruikt; als het parallellisme lager is dan twee, wordt voor elke taak een thread gemaakt. Je kunt expliciet een executor opgeven. CompletableFuture.thenCompose vlakt een functie af die een volgende stap retourneert, in plaats van een genest resultaat te maken. CompletableFuture.thenCombine combineert waarden nadat beide stappen succesvol zijn voltooid.

CompletableFuture.exceptionally berekent alleen bij een fout een vervangende waarde. CompletableFuture.allOf wacht op alle stappen, retourneert CompletableFuture<Void> en geeft een fout door als een stap mislukt; het verzamelt geen waarden. CompletableFuture.anyOf retourneert CompletableFuture<Object> met het resultaat of de fout van een van de stappen die voltooit — dat hoeft geen succes te zijn. De overige taken worden niet geannuleerd.

CompletableFuture.join en CompletableFuture.get blokkeren totdat de bewerking is voltooid. Een fout wordt doorgaans verpakt in respectievelijk de ongecontroleerde CompletionException of de gecontroleerde ExecutionException; get kan ook InterruptedException gooien. Annulering gooit CancellationException. Vermijd blokkeren binnen afhankelijke taken.

CompletableFuture.completeOnTimeout voltooit dezelfde future met een vervangende waarde, terwijl CompletableFuture.orTimeout deze voltooit met TimeoutException, tenzij deze al voltooid is. Geen van beide methoden stopt de onderliggende berekening. get(timeout, unit) beperkt daarentegen alleen de wachttijd van de aanroeper.

Voorbeelden

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());
        }
    }
}

Resultaat

result=50
recovered=-1

De getoonde code en het opgegeven resultaat zijn in een geïsoleerde omgeving geverifieerd met de methode die in het verificatiebewijs voor exact deze versie is vastgelegd.

Bronnen