Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / Java

CompletableFuture.supplyAsync con un esecutore esplicito

Passa un tuo `Executor` per scegliere come eseguire il compito. Con `Runnable::run`, il compito viene eseguito subito nel thread chiamante, senza usare il pool comune.

Versione: Java SE 21

Sintassi

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

In Java SE 21, CompletableFuture.supplyAsync(Supplier,Executor) è un metodo statico di java.util.concurrent.CompletableFuture. Accetta un java.util.function.Supplier<U>, il cui metodo get() non richiede argomenti e restituisce un valore di tipo U, e un java.util.concurrent.Executor. Sottomette per l’esecuzione un compito che chiama get() e completa un nuovo CompletableFuture<U> con il valore restituito.

L’overload con un solo argomento, supplyAsync(supplier), usa ForkJoinPool.commonPool(). Se il pool non supporta un livello di parallelismo di almeno 2, Java crea un nuovo thread per ogni compito. Secondo la documentazione, l’overload con due argomenti usa l’esecutore fornito. OpenJDK 21 fa un’eccezione: se passi esplicitamente ForkJoinPool.commonPool() e il suo livello di parallelismo è inferiore a 2, il metodo usa invece un esecutore che crea un thread per ogni compito. Questo comportamento alternativo dell’overload con due argomenti è un dettaglio di implementazione che Java SE non garantisce. Async non garantisce né un altro thread né un ritorno immediato.

Con Executor sameThread = Runnable::run, execute chiama subito run() del compito nel thread chiamante. Nell’esempio il calcolo termina prima che supplyAsync restituisca il future, quindi join() legge 42 senza aspettare. Un compito lento o bloccante tratterrebbe il thread chiamante fino alla fine.

Se get() lancia un’eccezione, il future si completa eccezionalmente e join() lancia una CompletionException non controllata. Se invece è execute a lanciare una RejectedExecutionException, l’eccezione si propaga direttamente da supplyAsync, che in quel caso non restituisce alcun future. Nessuno dei due argomenti può essere null, ma il valore restituito da get() può esserlo.

Esempi

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

Risultato

before supplyAsync
same thread: true
after supplyAsync
result: 42

La riga `same thread: true` appare tra `before supplyAsync` e `after supplyAsync`: il fornitore viene eseguito nel thread chiamante prima che il metodo ritorni. Non c’è alcun pool da arrestare.

Lezioni correlate

  • Java · Lezione 51 · Intermedio · Versione: 2

Fonti