KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / Java

Future.get: een taakresultaat ophalen of een fout afhandelen

Haal het resultaat van een asynchrone taak op en onderscheid een taakfout van een onderbreking, annulering, verstreken wachttijd of fout in de aanroep van `invokeAll` zelf.

Versie: Java SE 21

Syntax

java.util.concurrent.Future<V>
V get() throws InterruptedException, ExecutionException
V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException

Future.get haalt het resultaat op van een asynchrone berekening die wordt vertegenwoordigd door een java.util.concurrent.Future<V>. Zonder argumenten blokkeert get() zo nodig de aanroepende thread, zonder tijdslimiet. Bij succes geeft de methode een waarde van het type V terug. Dat kan null zijn als dat het taakresultaat was.

Als de taak een uitzondering gooit, gooit get() een ExecutionException. Gebruik getCause() om de oorspronkelijke uitzondering te bekijken. InterruptedException betekent daarentegen dat de aanroepende thread tijdens het wachten is onderbroken, niet dat de taak is mislukt. Is de taak geannuleerd, dan gooit get() de ongecontroleerde uitzondering CancellationException.

De overload get(long timeout, TimeUnit unit) heeft dezelfde mogelijke uitkomsten, maar begrenst de wachttijd. Verstrijkt die tijd tijdens het wachten, dan gooit de methode TimeoutException. Het verstrijken van de wachttijd annuleert de taak op zichzelf niet; je kunt get() later opnieuw aanroepen.

Wanneer ExecutorService.invokeAll(tasks) normaal terugkeert, zijn alle futures al afgerond en staan ze in de volgorde van de taken in de collectie. isDone() betekent niet dat een taak is geslaagd: get() op de bijbehorende future meldt de uitzondering van de taak als ExecutionException, niet invokeAll zelf. De aanroep van invokeAll kan zelf tijdens het wachten worden onderbroken (InterruptedException) of een taak niet kunnen inplannen (RejectedExecutionException). De overload van invokeAll met tijdslimiet annuleert onafgeronde taken voordat die terugkeert; get() op een geannuleerde future gooit CancellationException.

Voorbeelden

import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class FutureGetExample {
    public static void main(String[] args) throws InterruptedException {
        List<Callable<Integer>> tasks = List.of(
                () -> 21 * 2,
                () -> { throw new IllegalStateException("invalid input"); }
        );

        try (ExecutorService executor = Executors.newSingleThreadExecutor()) {
            List<Future<Integer>> futures = executor.invokeAll(tasks);
            System.out.println("invokeAll returned");
            for (Future<Integer> future : futures) {
                try {
                    System.out.println("Result: " + future.get());
                } catch (ExecutionException e) {
                    Throwable cause = e.getCause();
                    System.out.println("Task failed: " + cause.getClass().getSimpleName()
                            + ": " + cause.getMessage());
                }
            }
        }
    }
}

Resultaat

invokeAll returned
Result: 42
Task failed: IllegalStateException: invalid input

De eerste regel laat zien dat `invokeAll` normaal is teruggekeerd. De eerste `get()` geeft `42` terug; de tweede gooit `ExecutionException`. Het programma toont het type en de melding van de oorzaak, niet die van de omhullende uitzondering. Try-with-resources sluit de executor af.

Gerelateerde lessen

  • Java · Les 50 · Gemiddeld · Versie: 2

Bronnen