Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / Java

CompletableFuture — composer des calculs asynchrones

CompletableFuture<T> représente un résultat futur et permet d’enchaîner des étapes dépendantes sans bloquer après chacune d’elles. Découvrez les transformations, la composition, la combinaison de résultats, la gestion des erreurs et les délais d’attente dans Java SE 21.

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

Syntaxe

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> associe un résultat Future<T> à des étapes CompletionStage<T>. CompletableFuture.supplyAsync soumet un calcul à l’exécution ; CompletableFuture.completedFuture crée un résultat déjà terminé. CompletableFuture.completeExceptionally termine une future encore inachevée avec une erreur. Portée : Java SE 21 ; environnement d’exécution du dépôt, environnement de production non attesté.

CompletableFuture.thenApply transforme un résultat obtenu avec succès ; cela ne garantit pas l’utilisation d’un thread distinct. CompletableFuture.thenApplyAsync soumet la fonction à un exécuteur pour qu’il l’exécute. Par défaut, ForkJoinPool.commonPool() est utilisé ; si le parallélisme est inférieur à deux, un thread est créé pour chaque tâche. Vous pouvez fournir explicitement un exécuteur. CompletableFuture.thenCompose aplatit une fonction qui renvoie une autre étape, au lieu de créer un résultat imbriqué. CompletableFuture.thenCombine combine les valeurs une fois les deux étapes terminées avec succès.

CompletableFuture.exceptionally calcule une valeur de remplacement uniquement en cas d’échec. CompletableFuture.allOf attend la fin de toutes les étapes, renvoie CompletableFuture<Void> et propage l’échec si une étape échoue ; il ne collecte pas les valeurs. CompletableFuture.anyOf renvoie CompletableFuture<Object> contenant le résultat ou l’échec de l’une des étapes terminées — pas nécessairement une réussite. Il n’annule pas les autres tâches.

CompletableFuture.join et CompletableFuture.get bloquent jusqu’à la fin. En général, un échec est enveloppé dans CompletionException, non vérifiée, ou ExecutionException, vérifiée, respectivement ; get peut aussi lever InterruptedException. Une annulation lève CancellationException. Évitez de bloquer à l’intérieur de tâches dépendantes.

CompletableFuture.completeOnTimeout termine la même future avec une valeur de remplacement, tandis que CompletableFuture.orTimeout la termine avec TimeoutException, si elle n’est pas déjà terminée. Aucune de ces méthodes n’arrête le calcul sous-jacent. En revanche, get(timeout, unit) limite uniquement le temps d’attente de l’appelant.

Exemples

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

Résultat

result=50
recovered=-1

Le code affiché et le résultat déclaré ont été vérifiés dans un environnement isolé selon la méthode consignée dans la preuve de vérification de cette version exacte.

Sources