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