WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / Java

ExecutorService — Aufgaben, Ergebnisse und Beenden

ExecutorService trennt das Übermitteln von Aufgaben von der Verwaltung ihrer Ausführung. Lernen Sie submit, die gebündelte Ausführung mit invokeAll und shutdown kennen sowie den Unterschied zwischen dem Anfordern des Beendens und dem Warten auf die Beendigung.

Version: 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 erweitert Executor um die Verfolgung von Ergebnissen und die Verwaltung der Beendigung. Dieser Eintrag bezieht sich auf Java SE 21, die Laufzeitumgebung des Repositorys. Die Produktionslaufzeit ist nicht bestätigt.

ExecutorService.submit gibt ein Future zurück: Bei Callable<T> stellt es das Aufgabenergebnis bereit, bei Runnable ist das Ergebnis null, und bei submit(Runnable, T) ist es der übergebene Wert. Future.get() wartet bei Bedarf; es meldet einen Aufgabenfehler als ExecutionException, eine Stornierung als CancellationException und eine Unterbrechung während des Wartens als InterruptedException.

ExecutorService.invokeAll ohne Zeitlimit wartet darauf, dass alle Callable-Aufgaben abgeschlossen sind. Die zurückgegebenen Futures behalten die Eingabereihenfolge bei, nicht die Reihenfolge des Abschlusses. Der Abschluss bedeutet nicht automatisch Erfolg: Ergebnisse und Fehler werden mit get() abgerufen.

ExecutorService.shutdown nimmt keine neuen Aufgaben mehr an, lässt zuvor angenommene Aufgaben ausführen und wartet nicht. Verwenden Sie awaitTermination, um zu warten; in Java SE 21 beendet close() in try-with-resources den Dienst und wartet. Das ausdrückliche shutdown() im Beispiel demonstriert die API, ist wegen close() jedoch überflüssig. Lang laufende Aufgaben können das Schließen verzögern.

Das Beispiel verwendet Executors.newFixedThreadPool(2). Diese Factory hat eine unbegrenzte Warteschlange: Zwei Threads begrenzen nicht die Anzahl wartender Aufgaben. Betrachten Sie sie nicht als automatischen Schutz vor Überlastung.

Beispiele

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

Ergebnis

42
5
20

Der angezeigte Code und das angegebene Ergebnis wurden in einer isolierten Umgebung mit der im Prüfnachweis für genau diese Version dokumentierten Methode verifiziert.

Quellen