Znalostní bázeCentrum zkoušek
CSČeština
Vybrat jazyk13

CKTIS / Java

CompletableFuture.get(): čekání na výsledek

Použij `get()` k získání výsledku nebo `get(timeout, unit)` k omezení doby čekání. Na rozdíl od `join()` obě varianty deklarují kontrolované výjimky.

Verze: 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

V Java SE 21 je CompletableFuture.get instanční metoda třídy java.util.concurrent.CompletableFuture<T>. Volání get() blokuje volající vlákno jen tehdy, když musí čekat na dokončení. Pokud je objekt už dokončený, metoda nečeká; při úspěšném dokončení vrátí výsledek typu T.

Obě přetížené varianty vyhodí InterruptedException, pokud je volající vlákno během čekání přerušeno, nebo ExecutionException, pokud výpočet selže. Příčinu selhání zjistíš pomocí getCause(). Při zrušení samotného objektu se vyhodí nekontrolovaná výjimka CancellationException. Kontrolované výjimky musíš zachytit nebo deklarovat pomocí throws.

get(long timeout, TimeUnit unit) omezuje dobu čekání, například při volání future.get(2, TimeUnit.SECONDS). Pokud limit vyprší před dokončením, volání vyhodí kontrolovanou výjimku TimeoutException; vypršení limitu objekt nezruší ani nedokončí.

Také join() může blokovat a při zrušení rovněž vyhodí CancellationException, ale nedeklaruje kontrolované výjimky: selhání výpočtu oznámí nekontrolovanou výjimkou CompletionException. Chceš-li výsledek zpracovat bez blokujícího čtení v místě volání, připoj navazující krok, například pomocí thenApply.

Příklady

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

Výsledek

Timed out
Result: 42
get cause: No result
join cause: No result

Nulový časový limit vyvolá `TimeoutException`, protože `pending` ještě není dokončený. Po `complete(42)` vrátí `get()` hodnotu `42` bez čekání. Nakonec `get()` a `join()` ukážou stejnou příčinu selhání zabalenou do dvou různých výjimek.

Související lekce

  • Java · Lekce 51 · Středně pokročilá · Verze: 2

Zdroje