Como o framework Executor e CompletableFuture ajudam com trabalho assíncrono?

Question

Accepted Answer

O **framework Executor** gerencia pools de threads para que você envie *tarefas* em vez de criar threads manualmente, e **`CompletableFuture`** compõe operações assíncronas de forma declarativa. Juntos, são a forma moderna de fazer trabalho concorrente/assíncrono em Java — evitando o custo e a complexidade do gerenciamento raw de threads. ## O problema com threads raw ```java // ❌ creating a thread per task is expensive and unbounded → can exhaust resources for (Task t : tasks) { new Thread(() -> process(t)).start(); // 10,000 tasks → 10,000 threads → crash } ``` ## ExecutorService — pools de threads gerenciados ```java // ✅ a fixed pool reuses a bounded set of threads for many tasks ExecutorService executor = Executors.newFixedThreadPool(10); Future future = executor.submit(() -> compute()); // submit a task Integer result = future.get(); // blocks until the result is ready executor.shutdown(); // stop accepting tasks; let running ones finish ``` Um `ExecutorService` separa o *quê* (tarefas) do *como* (gerenciamento de threads) — ele reutiliza um pool limitado de threads, prevenindo exaustão de recursos e o overhead da criação constante de threads. ## A limitação do Future ```java Future f = executor.submit(task); f.get(); // ❌ BLOCKS the calling thread; can't chain/combine without blocking ``` `Future.get()` bloqueia, e você não pode facilmente encadear operações dependentes ou combinar resultados — o que é exatamente o que `CompletableFuture` resolve. ## CompletableFuture — composável e assíncrono ```java CompletableFuture.supplyAsync(() -> fetchUser(id)) // run async, returns a value .thenApply(user -> user.getName()) // transform the result (non-blocking) .thenApply(String::toUpperCase) .thenAccept(name -> System.out.println(name)) // consume the final result .exceptionally(ex -> { log(ex); return null; }); // handle errors in the chain ``` `CompletableFuture` permite que você construa **pipelines non-blocking** — transformando (`thenApply`), encadeando chamadas assíncronas dependentes (`thenCompose`), e tratando erros (`exceptionally`) — sem bloquear threads. ## Combinando múltiplas operações assíncronas ```java // run two independent async calls in PARALLEL and combine their results CompletableFuture userF = CompletableFuture.supplyAsync(() -> fetchUser(id)); CompletableFuture orderF = CompletableFuture.supplyAsync(() -> fetchOrder(id)); userF.thenCombine(orderF, (user, order) -> buildProfile(user, order)) .thenAccept(profile -> render(profile)); // wait for many to complete CompletableFuture.allOf(f1, f2, f3).join(); // all done ``` `thenCombine`, `allOf`, e `anyOf` coordenam múltiplas tarefas assíncronas elegantemente — executando trabalho independente em paralelo e combinando resultados. ## Por que isso importa O framework Executor e CompletableFuture são a **forma moderna e correta** de lidar com concorrência e trabalho assíncrono em Java, substituindo o gerenciamento manual de threads propenso a erros. Pools de threads (ExecutorService) evitam a exaustão de recursos e o overhead de criar uma thread por tarefa — essencial para servidores escaláveis. CompletableFuture resolve a limitação de bloqueio do Future ao permitir **pipelines compostos e non-blocking** que encadeiam, transformam, combinam e tratam erros de operações assíncronas de forma declarativa — crucial para serviços eficientes ligados a I/O que devem coordenar muitas chamadas concorrentes (banco de dados, API, microsserviços). Compreender estes (sobre threads raw e Futures bloqueantes) é fundamental para construir aplicações Java concorrentes performáticas e escaláveis, e é uma competência-chave de nível sênior.