Baza znanjaIzpitno središče
SLSlovenščina
Izberi jezik13

CKTIS / Java

CompletableFuture.get(): čakanje na rezultat

Uporabi `get()` za prevzem rezultata ali `get(timeout, unit)` za omejitev čakanja. V nasprotju z `join()` obe različici deklarirata preverjane izjeme.

Različica: Java SE 21

Sintaksa

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 metoda primerka razreda java.util.concurrent.CompletableFuture<T>. Klic get() blokira klicno nit le, če mora počakati na dokončanje. Če je objekt že dokončan, metoda ne čaka; ob uspešnem dokončanju vrne rezultat tipa T.

Obe različici metode vržeta InterruptedException, če je klicna nit med čakanjem prekinjena, ali ExecutionException, če izračun spodleti. Vzrok napake lahko preveriš z getCause(). Če je preklican sam objekt CompletableFuture, metoda vrže nepreverjano izjemo CancellationException. Preverjane izjeme moraš ujeti ali deklarirati z throws.

get(long timeout, TimeUnit unit) omeji čas čakanja, na primer pri klicu future.get(2, TimeUnit.SECONDS). Če rok poteče pred dokončanjem, klic vrže preverjano izjemo TimeoutException; iztek roka objekta ne prekliče niti ga ne dokonča.

Tudi join() lahko blokira in ob preklicu prav tako vrže CancellationException, vendar ne deklarira preverjanih izjem: neuspeh izračuna sporoči z nepreverjano izjemo CompletionException. Če želiš rezultat obdelati brez blokirajočega branja na mestu klica, dodaj naslednjo stopnjo, na primer z thenApply.

Primeri

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

Rezultat

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

Časovna omejitev nič povzroči `TimeoutException`, ker `pending` še ni dokončan. Po `complete(42)` metoda `get()` brez čakanja vrne `42`. Na koncu `get()` in `join()` pokažeta isti vzrok napake, ovit v dve različni izjemi.

Povezane lekcije

  • Java · Lekcija 51 · Srednja · Različica: 2

Viri