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.TimeoutExceptionIn 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