Baza wiedzyCentrum egzaminacyjne
PLPolski
Wybierz język13

CKTIS / Java

CompletableFuture.get(): oczekiwanie na wynik

Użyj `get()`, aby odebrać wynik, lub `get(timeout, unit)`, aby ograniczyć czas oczekiwania. Oba warianty deklarują wyjątki sprawdzane, w odróżnieniu od `join()`.

Wersja: Java SE 21

Składnia

public T get() throws InterruptedException, ExecutionException
public T get(long timeout, java.util.concurrent.TimeUnit unit) throws InterruptedException, ExecutionException, java.util.concurrent.TimeoutException

W Java SE 21 CompletableFuture.get to metoda instancji klasy java.util.concurrent.CompletableFuture<T>. Wywołanie get() blokuje wątek wywołujący tylko wtedy, gdy musi czekać na zakończenie. Jeśli obiekt jest już zakończony, metoda nie czeka; przy pomyślnym zakończeniu zwraca wynik typu T.

Oba przeciążenia zgłaszają InterruptedException, gdy wątek wywołujący zostanie przerwany podczas oczekiwania, lub ExecutionException, gdy obliczenie zakończy się błędem. Przyczynę błędu odczytasz przez getCause(). Anulowanie samego obiektu CompletableFuture powoduje zgłoszenie niesprawdzanego CancellationException. Wyjątki sprawdzane trzeba przechwycić albo zadeklarować w throws.

get(long timeout, TimeUnit unit) ogranicza czas oczekiwania, np. future.get(2, TimeUnit.SECONDS). Jeśli limit upłynie przed zakończeniem, wywołanie zgłasza sprawdzany TimeoutException; nie anuluje ani nie kończy przez to obiektu CompletableFuture.

join() też może blokować i również zgłasza CancellationException w razie anulowania, ale nie deklaruje wyjątków sprawdzanych: błąd obliczenia zgłasza jako niesprawdzany CompletionException. Jeśli chcesz przetworzyć wynik bez blokującego odczytu w bieżącym miejscu, dołącz kolejny etap, np. thenApply.

Przykłady

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

Wynik

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

Zerowy limit daje `TimeoutException`, bo `pending` nie jest jeszcze zakończony. Po `complete(42)` metoda `get()` zwraca `42` bez oczekiwania. Na końcu `get()` i `join()` pokazują tę samą przyczynę błędu opakowaną w dwa różne wyjątki.

Powiązane lekcje

  • Java · Lekcja 51 · Średniozaawansowany · Wersja: 2

Źródła