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

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.TimeoutException

Dans 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

Sources