CKTIS / Java
CompletableFuture : composition, délais et exécuteurs
Composez des étapes en Java SE 21, récupérez après une erreur, coordonnez plusieurs futurs et choisissez explicitement les exécuteurs des tâches asynchrones.
Version : Java SE 21
Syntaxe
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 appartient à java.util.concurrent. La méthode statique completedFuture(value) crée un futur déjà terminé avec succès. thenApply transforme un résultat réussi en une valeur dans une nouvelle étape. Utilisez thenCompose si la fonction renvoie un CompletionStage : la nouvelle étape suit l’issue de cette étape au lieu de la contenir comme valeur. thenCombine appelle la fonction avec les deux résultats seulement si les deux étapes réussissent ; il ne démarre aucune des deux.
completeExceptionally(cause) termine le même futur en échec et renvoie true uniquement si cet appel l’a terminé. exceptionally crée une nouvelle étape qui transmet le résultat en cas de succès ou calcule une valeur de repli à partir de l’exception. join() bloque si nécessaire, puis renvoie le résultat, lance une CompletionException non contrôlée en cas d’échec ou lance CancellationException si le futur a été annulé. Préférez appeler join() à la frontière du programme plutôt que de bloquer des threads de travail dans la chaîne.
La méthode statique allOf renvoie un CompletableFuture<Void> qui attend la fin de toutes les entrées, même si l’une échoue. Il échoue si une entrée échoue et ne rassemble pas les valeurs. Après un succès, lisez celles-ci séparément. Sans entrée, il est déjà terminé avec null. La méthode statique anyOf renvoie un CompletableFuture<Object> qui se termine avec le résultat ou l’exception d’une entrée dès que la fin de cette entrée est détectée. Si plusieurs entrées sont déjà terminées lors de l’appel, l’API ne garantit pas qu’elle choisira celle qui s’est terminée le plus tôt. La méthode n’attend pas un premier succès et n’annule pas les autres entrées. Sans entrée, ce futur reste incomplet.
Si le futur est toujours incomplet à l’expiration du délai, completeOnTimeout(value, timeout, unit) le termine normalement avec la valeur de repli, tandis que orTimeout(timeout, unit) le termine avec TimeoutException. Ces deux méthodes existent depuis Java 9. Elles configurent et renvoient le même futur, ne modifient pas une issue déjà établie et n’interrompent pas le calcul. Le délai porte sur l’achèvement du futur, pas seulement sur l’attente d’un appelant dans join().
supplyAsync(supplier, io) exécute le fournisseur via io, et thenApplyAsync(fn, cpu) exécute la transformation via cpu après un succès. Les étapes suivantes n’héritent pas de ces exécuteurs. Sans Executor explicite, CompletableFuture utilise normalement ForkJoinPool.commonPool(), ou un nouveau thread par tâche si ce pool ne permet pas un parallélisme d’au moins deux. Les sous-classes peuvent redéfinir la valeur par défaut des méthodes d’instance. Les méthodes sans Async, comme thenCombine, ne garantissent ni exécuteur ni thread particulier et peuvent s’exécuter directement si les entrées sont prêtes. Pour choisir l’exécuteur de la combinaison, utilisez thenCombineAsync(other, fn, executor).
Exemples
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());
}
}
}Résultat
composed=10 recovered=-1 any=ready all=ready,done fallback=0, same=true timeout=TimeoutException async=17
La plupart des étapes de la première composition utilisent des résultats déjà disponibles. Aucun calcul ne produit les futurs soumis à un délai, de sorte que leur issue ne dépend pas d’une course avec un calcul. `io` et `cpu` sont deux exécuteurs distincts de démonstration ; le bloc try-with-resources ferme les deux. Ne supposez ni durée précise ni thread particulier pour `thenCombine`.
Leçons associées
- Java · Leçon 41 · Avancé · Version : 2
- Java · Leçon 42 · Avancé · Version : 2