KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / Java

CompletableFuture.get(): wachten op een resultaat

Gebruik `get()` om het resultaat op te halen of `get(timeout, unit)` om de wachttijd te begrenzen. Anders dan `join()` declareren beide varianten checked exceptions.

Versie: 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 is CompletableFuture.get een instantiemethode van java.util.concurrent.CompletableFuture<T>. Een aanroep van get() blokkeert de aanroepende thread alleen als die op voltooiing moet wachten. Is de future al voltooid, dan hoeft de thread niet te wachten; bij succesvolle voltooiing geeft de methode het resultaat van type T terug.

Beide overloads gooien InterruptedException als de aanroepende thread tijdens het wachten wordt onderbroken, of ExecutionException als de berekening mislukt. Met getCause() kun je de oorzaak bekijken. Is de future zelf geannuleerd, dan wordt de unchecked exception CancellationException gegooid. Checked exceptions moet je afvangen of declareren met throws.

get(long timeout, TimeUnit unit) begrenst de wachttijd, bijvoorbeeld met future.get(2, TimeUnit.SECONDS). Verstrijkt die tijd vóór voltooiing, dan gooit de aanroep de checked exception TimeoutException. Het verstrijken van de tijd annuleert of voltooit de future niet.

Ook join() kan blokkeren en gooit bij annulering eveneens CancellationException, maar declareert geen checked exceptions: een mislukte berekening wordt gemeld als de unchecked exception CompletionException. Wil je het resultaat verwerken zonder op die plek te blokkeren, koppel dan een vervolgstap met bijvoorbeeld thenApply.

Voorbeelden

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

Resultaat

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

De wachttijd van nul leidt tot `TimeoutException`, omdat `pending` nog niet voltooid is. Na `complete(42)` geeft `get()` zonder wachten `42` terug. Tot slot tonen `get()` en `join()` dezelfde oorzaak van de fout, verpakt in twee verschillende exceptions.

Gerelateerde lessen

  • Java · Les 51 · Gemiddeld · Versie: 2

Bronnen