CKTIS / Java
CompletableFuture.get() : attendre un résultat
Utilisez `get()` pour récupérer un résultat ou `get(timeout, unit)` pour limiter l’attente. Contrairement à `join()`, les deux formes déclarent des exceptions contrôlées.
Version : Java SE 21
Syntaxe
public T get() throws InterruptedException, ExecutionException
public T get(long timeout, java.util.concurrent.TimeUnit unit) throws InterruptedException, ExecutionException, java.util.concurrent.TimeoutExceptionDans Java SE 21, CompletableFuture.get est une méthode d’instance de java.util.concurrent.CompletableFuture<T>. Un appel à get() ne bloque le thread appelant que s’il doit attendre la fin du calcul. Si le futur est déjà terminé, il n’y a pas d’attente ; en cas de réussite, la méthode renvoie le résultat de type T.
Les deux surcharges lèvent InterruptedException si le thread appelant est interrompu pendant l’attente, ou ExecutionException si le calcul échoue. Utilisez getCause() pour examiner la cause de l’échec. L’annulation du futur lui-même entraîne une CancellationException non contrôlée. Les exceptions contrôlées doivent être interceptées ou déclarées avec throws.
get(long timeout, TimeUnit unit) limite l’attente, par exemple avec future.get(2, TimeUnit.SECONDS). Si le délai expire avant la fin du calcul, l’appel lève une TimeoutException contrôlée ; l’expiration du délai n’annule pas le futur et ne le fait pas non plus passer à l’état terminé.
join() peut aussi bloquer et lève également CancellationException en cas d’annulation, mais ne déclare pas d’exception contrôlée : un échec du calcul est signalé par une CompletionException non contrôlée. Pour traiter le résultat sans lecture bloquante au point d’appel, ajoutez une étape comme thenApply.
Exemples
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
public class Main {
public static void main(String[] args) throws InterruptedException, ExecutionException {
CompletableFuture<Integer> pending = new CompletableFuture<>();
try {
pending.get(0, TimeUnit.MILLISECONDS);
throw new AssertionError("Expected a timeout");
} catch (TimeoutException e) {
System.out.println("Timed out");
}
pending.complete(42);
System.out.println("Result: " + pending.get());
CompletableFuture<Integer> failed =
CompletableFuture.failedFuture(new IllegalStateException("No result"));
try {
failed.get();
} catch (ExecutionException e) {
System.out.println("get cause: " + e.getCause().getMessage());
}
try {
failed.join();
} catch (CompletionException e) {
System.out.println("join cause: " + e.getCause().getMessage());
}
}
}Résultat
Timed out Result: 42 get cause: No result join cause: No result
Le délai nul provoque `TimeoutException`, car `pending` n’est pas encore terminé. Après `complete(42)`, `get()` renvoie `42` sans attendre. Enfin, `get()` et `join()` présentent la même cause d’échec, enveloppée dans deux exceptions différentes.
Leçons associées
- Java · Leçon 51 · Intermédiaire · Version : 2