KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / Java

ExecutorService — taken, resultaten en afsluiten

ExecutorService scheidt het indienen van taken van het beheer van de uitvoering. Leer over submit, batchuitvoering met invokeAll en shutdown, en het verschil tussen afsluiten aanvragen en wachten tot de uitvoering is beëindigd.

Versie: Java SE 21 (repository runtime); production runtime not attested

Syntax

<T> Future<T> submit(Callable<T> task)
Future<?> submit(Runnable task)
<T> Future<T> submit(Runnable task, T result)
<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks) throws InterruptedException
void shutdown()

java.util.concurrent.ExecutorService breidt Executor uit met het volgen van resultaten en het beheren van beëindiging. Dit artikel behandelt Java SE 21, de runtime van de repository. De runtime in productie is niet bevestigd.

ExecutorService.submit retourneert een Future: voor Callable<T> levert dit het taakresultaat, voor Runnable is het resultaat null en voor submit(Runnable, T) is het de opgegeven waarde. Future.get() wacht indien nodig; een taakfout wordt gemeld als ExecutionException, annulering als CancellationException en een onderbreking tijdens het wachten als InterruptedException.

ExecutorService.invokeAll zonder time-out wacht totdat alle Callable-taken zijn voltooid. De geretourneerde futures behouden de invoervolgorde, niet de volgorde waarin taken klaar zijn. Voltooiing betekent niet dat een taak is geslaagd: haal resultaten en fouten op met get().

ExecutorService.shutdown weigert nieuwe taken, laat eerder geaccepteerde taken uitvoeren en wacht niet. Gebruik awaitTermination om te wachten; in Java SE 21 sluit close() in try-with-resources de service af en wacht. De expliciete shutdown() in het voorbeeld demonstreert de API, maar is overbodig vanwege close(). Langlopende taken kunnen het afsluiten vertragen.

Het voorbeeld gebruikt Executors.newFixedThreadPool(2). Deze factory heeft een onbegrensde wachtrij: twee threads beperken het aantal wachtende taken niet. Beschouw dit niet als automatische bescherming tegen overbelasting.

Voorbeelden

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

public class Main {
    public static void main(String[] args) throws Exception {
        try (ExecutorService pool = Executors.newFixedThreadPool(2)) {
            Future<Integer> single = pool.submit(() -> 6 * 7);
            List<Callable<Integer>> tasks = List.of(() -> 2 + 3, () -> 4 * 5);
            List<Future<Integer>> batch = pool.invokeAll(tasks);
            pool.shutdown();

            System.out.println(single.get());
            for (Future<Integer> result : batch) {
                System.out.println(result.get());
            }
        }
    }
}

Resultaat

42
5
20

De getoonde code en het opgegeven resultaat zijn in een geïsoleerde omgeving geverifieerd met de methode die in het verificatiebewijs voor exact deze versie is vastgelegd.

Bronnen