CKTIS / Java
Future.get : récupérer le résultat d’une tâche ou traiter son échec
Récupérez le résultat d’une tâche asynchrone et distinguez son échec d’une interruption, d’une annulation, d’un délai dépassé ou d’un échec de l’appel à `invokeAll` lui-même.
Version : Java SE 21
Syntaxe
java.util.concurrent.Future<V>
V get() throws InterruptedException, ExecutionException
V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutExceptionFuture.get récupère le résultat d’un calcul asynchrone représenté par un java.util.concurrent.Future<V>. Sans argument, get() bloque si nécessaire le thread appelant, sans limite de temps. En cas de réussite, la méthode renvoie une valeur de type V, éventuellement null si c’est le résultat de la tâche.
Si la tâche lève une exception, get() lève une ExecutionException. Utilisez getCause() pour examiner l’exception d’origine. À l’inverse, InterruptedException signifie que le thread appelant a été interrompu pendant l’attente, et non que la tâche a échoué. Si la tâche a été annulée, get() lève l’exception non vérifiée CancellationException.
La surcharge get(long timeout, TimeUnit unit) a les mêmes issues possibles, mais limite la durée de l’attente. Si ce délai expire pendant l’attente, elle lève TimeoutException. L’expiration du délai n’annule pas la tâche à elle seule : vous pouvez rappeler get() plus tard.
Lorsque ExecutorService.invokeAll(tasks) se termine normalement, les objets Future sont déjà dans un état terminal et suivent l’ordre des tâches dans la collection. isDone() n’implique pas une réussite : c’est get() sur le Future de la tâche qui signale son exception sous la forme d’une ExecutionException, et non invokeAll. L’appel à invokeAll peut lui-même être interrompu pendant l’attente (InterruptedException) ou ne pas pouvoir planifier une tâche (RejectedExecutionException). La surcharge d’invokeAll avec délai annule les tâches non terminées avant de rendre la main ; get() sur un Future annulé lève CancellationException.
Exemples
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class FutureGetExample {
public static void main(String[] args) throws InterruptedException {
List<Callable<Integer>> tasks = List.of(
() -> 21 * 2,
() -> { throw new IllegalStateException("invalid input"); }
);
try (ExecutorService executor = Executors.newSingleThreadExecutor()) {
List<Future<Integer>> futures = executor.invokeAll(tasks);
System.out.println("invokeAll returned");
for (Future<Integer> future : futures) {
try {
System.out.println("Result: " + future.get());
} catch (ExecutionException e) {
Throwable cause = e.getCause();
System.out.println("Task failed: " + cause.getClass().getSimpleName()
+ ": " + cause.getMessage());
}
}
}
}
}Résultat
invokeAll returned Result: 42 Task failed: IllegalStateException: invalid input
La première ligne montre que `invokeAll` a rendu la main normalement. Le premier `get()` renvoie `42` ; le second lève `ExecutionException`. Le programme affiche le type et le message de la cause, pas ceux de l’exception qui l’encapsule. Le bloc try-with-resources ferme l’exécuteur.
Leçons associées
- Java · Leçon 50 · Intermédiaire · Version : 2