WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / Java

CompletableFuture.supplyAsync mit explizitem Executor

Mit einem eigenen `Executor` legst du fest, wie die Aufgabe ausgeführt wird. `Runnable::run` führt sie sofort im aufrufenden Thread statt im gemeinsamen Pool aus.

Version: Java SE 21

Syntax

public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier, Executor executor)

In Java SE 21 ist CompletableFuture.supplyAsync(Supplier,Executor) eine statische Methode von java.util.concurrent.CompletableFuture. Sie nimmt einen java.util.function.Supplier<U>, dessen Methode get() keine Argumente benötigt und einen Wert vom Typ U liefert, sowie einen java.util.concurrent.Executor entgegen. Sie reicht eine Aufgabe zur Ausführung ein, die get() aufruft und ein neues CompletableFuture<U> mit dem zurückgegebenen Wert abschließt.

Die Überladung mit einem Argument, supplyAsync(supplier), verwendet ForkJoinPool.commonPool(). Unterstützt dieser Pool keinen Parallelitätsgrad von mindestens 2, erstellt Java pro Aufgabe einen neuen Thread. Laut Dokumentation verwendet die Überladung mit zwei Argumenten den übergebenen Executor. In OpenJDK 21 gibt es eine Ausnahme: Übergibst du ausdrücklich ForkJoinPool.commonPool() und liegt dessen Parallelitätsgrad unter 2, verwendet die Methode stattdessen einen Executor, der pro Aufgabe einen neuen Thread startet. Dieses Ausweichverhalten der Überladung mit zwei Argumenten ist ein Implementierungsdetail und wird von Java SE nicht garantiert. Async garantiert weder einen anderen Thread noch eine sofortige Rückkehr.

Bei Executor sameThread = Runnable::run ruft execute die Methode run() der Aufgabe sofort im aufrufenden Thread auf. Im Beispiel endet die Berechnung, bevor supplyAsync zurückkehrt. Daher liefert join() den Wert 42, ohne zu warten. Eine langsame oder blockierende Aufgabe würde den aufrufenden Thread bis zu ihrem Ende aufhalten.

Wirft get() eine Ausnahme, wird das Future mit einer Ausnahme abgeschlossen, und join() wirft eine ungeprüfte CompletionException. Wirft hingegen execute selbst eine RejectedExecutionException, wird sie direkt von supplyAsync weitergegeben; die Methode gibt dann kein Future zurück. Keines der beiden Argumente darf null sein, das Ergebnis von get() hingegen schon.

Beispiele

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.Executor;

public class Main {
    public static void main(String[] args) {
        Executor sameThread = Runnable::run;
        Thread caller = Thread.currentThread();

        System.out.println("before supplyAsync");
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            System.out.println("same thread: " + (Thread.currentThread() == caller));
            return 42;
        }, sameThread);
        System.out.println("after supplyAsync");
        System.out.println("result: " + future.join());
    }
}

Ergebnis

before supplyAsync
same thread: true
after supplyAsync
result: 42

Die Zeile `same thread: true` erscheint zwischen `before supplyAsync` und `after supplyAsync`. Der Supplier läuft also vor der Rückkehr der Methode im aufrufenden Thread. Es gibt keinen Pool, der heruntergefahren werden muss.

Zugehörige Lektionen

  • Java · Lektion 51 · Mittlere Stufe · Version: 2

Quellen