Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / Java

CompletableFuture.supplyAsync com um executor explícito

Passe o seu próprio `Executor` para escolher como executar a tarefa. Com `Runnable::run`, a tarefa corre imediatamente na thread que faz a chamada, sem usar a pool comum.

Versão: Java SE 21

Sintaxe

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

Em Java SE 21, CompletableFuture.supplyAsync(Supplier,Executor) é um método estático de java.util.concurrent.CompletableFuture. Recebe um java.util.function.Supplier<U>, cujo método get() não recebe argumentos e devolve um valor do tipo U, e um java.util.concurrent.Executor. Submete para execução uma tarefa que chama get() e conclui um novo CompletableFuture<U> com o valor devolvido.

A sobrecarga com um único argumento, supplyAsync(supplier), usa ForkJoinPool.commonPool(). Se essa pool não suportar um nível de paralelismo de pelo menos 2, Java cria uma nova thread por tarefa. Segundo a documentação, a sobrecarga com dois argumentos usa o executor fornecido. O OpenJDK 21 faz uma exceção: se passar explicitamente ForkJoinPool.commonPool() e o nível de paralelismo da pool for inferior a 2, o método usa em seu lugar um executor que cria uma thread por tarefa. Este comportamento alternativo da sobrecarga com dois argumentos é um pormenor de implementação que a Java SE não garante. Async não garante que se use outra thread nem que o método retorne de imediato.

Com Executor sameThread = Runnable::run, execute chama de imediato run() da tarefa na thread que faz a chamada. No exemplo, o cálculo acaba antes de supplyAsync devolver o future, pelo que join() obtém 42 sem esperar. Uma tarefa lenta ou bloqueante reteria a thread que faz a chamada até terminar.

Se get() lançar uma exceção, o future termina excecionalmente e join() lança uma CompletionException não verificada. Se for o próprio execute a lançar RejectedExecutionException, a exceção propaga-se diretamente de supplyAsync, que nesse caso não devolve nenhum future. Nenhum dos dois argumentos pode ser null, mas o valor devolvido por get() pode sê-lo.

Exemplos

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

Resultado

before supplyAsync
same thread: true
after supplyAsync
result: 42

A linha `same thread: true` aparece entre `before supplyAsync` e `after supplyAsync`. Isto mostra que o fornecedor corre na thread que faz a chamada antes de o método retornar. Não há nenhuma pool para encerrar.

Lições relacionadas

  • Java · Lição 51 · Intermédio · Versão: 2

Fontes