WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / Java

CompletableFuture.get(): auf ein Ergebnis warten

Mit `get()` rufst du das Ergebnis ab; `get(timeout, unit)` begrenzt die Wartezeit. Anders als `join()` deklarieren beide Varianten geprüfte Ausnahmen.

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

In Java SE 21 ist CompletableFuture.get eine Instanzmethode von java.util.concurrent.CompletableFuture<T>. Ein Aufruf von get() blockiert den aufrufenden Thread nur, wenn er auf den Abschluss warten muss. Ist das Future bereits abgeschlossen, entfällt die Wartezeit; bei erfolgreichem Abschluss liefert die Methode das Ergebnis vom Typ T.

Beide Überladungen werfen InterruptedException, wenn der aufrufende Thread beim Warten unterbrochen wird, oder ExecutionException, wenn die Berechnung fehlschlägt. Mit getCause() kannst du die Fehlerursache abrufen. Wurde das Future selbst abgebrochen, wird die ungeprüfte CancellationException geworfen. Geprüfte Ausnahmen musst du abfangen oder mit throws deklarieren.

get(long timeout, TimeUnit unit) begrenzt die Wartezeit, etwa mit future.get(2, TimeUnit.SECONDS). Läuft die Frist vor dem Abschluss ab, wirft der Aufruf die geprüfte TimeoutException. Der Fristablauf bricht das Future weder ab noch schließt er es ab.

Auch join() kann blockieren und wirft bei Abbruch ebenfalls CancellationException, deklariert aber keine geprüften Ausnahmen: Ein Berechnungsfehler wird als ungeprüfte CompletionException gemeldet. Um das Ergebnis ohne blockierenden Abruf an der Aufrufstelle zu verarbeiten, hänge eine Folgestufe wie thenApply an.

Beispiele

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

Ergebnis

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

Das Zeitlimit null führt zu `TimeoutException`, da `pending` noch nicht abgeschlossen ist. Nach `complete(42)` liefert `get()` den Wert `42` ohne Wartezeit. Anschließend zeigen `get()` und `join()` dieselbe Fehlerursache in zwei verschiedenen Ausnahmehüllen.

Zugehörige Lektionen

  • Java · Lektion 51 · Mittlere Stufe · Version: 2

Quellen