Znalostná bázaCentrum skúšok
SKSlovenčina
Vybrať jazyk13

CKTIS / Java

CompletableFuture.get(): čakanie na výsledok

Použi `get()` na získanie výsledku alebo `get(timeout, unit)` na obmedzenie čakania. Na rozdiel od `join()` obe verzie deklarujú kontrolované výnimky.

Verzia: Java SE 21

Syntax

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 inštančná metóda triedy java.util.concurrent.CompletableFuture<T>. Volanie get() blokuje volajúce vlákno len vtedy, keď musí čakať na dokončenie. Ak je objekt už dokončený, metóda nečaká; pri úspešnom dokončení vráti výsledok typu T.

Obe preťažené verzie vyhodia InterruptedException, ak sa volajúce vlákno počas čakania preruší, alebo ExecutionException, ak výpočet zlyhá. Príčinu zlyhania zistíš pomocou getCause(). Pri zrušení samotného objektu sa vyhodí nekontrolovaná výnimka CancellationException. Kontrolované výnimky musíš zachytiť alebo deklarovať pomocou throws.

get(long timeout, TimeUnit unit) obmedzuje čas čakania, napríklad pri volaní future.get(2, TimeUnit.SECONDS). Ak limit uplynie pred dokončením, volanie vyhodí kontrolovanú výnimku TimeoutException; uplynutie limitu objekt nezruší ani nedokončí.

Aj join() môže blokovať a pri zrušení tiež vyhodí CancellationException, no nedeklaruje kontrolované výnimky: zlyhanie výpočtu oznámi nekontrolovanou výnimkou CompletionException. Ak chceš výsledok spracovať bez blokujúceho čítania na mieste volania, pripoj nadväzujúci krok, napríklad pomocou thenApply.

Prí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ýsledok

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

Nulový časový limit spôsobí `TimeoutException`, pretože `pending` ešte nie je dokončený. Po `complete(42)` vráti `get()` hodnotu `42` bez čakania. Nakoniec `get()` a `join()` ukážu rovnakú príčinu zlyhania zabalenú do dvoch rôznych výnimiek.

Súvisiace lekcie

  • Java · Lekcia 51 · Stredne pokročilá · Verzia: 2

Zdroje