1. Combinando CompletableFuture
Na vida real, raramente tudo vem de uma única fonte: o perfil do usuário e seus pedidos podem ser carregados em paralelo, dados de dois microsserviços — combinados, e às vezes queremos apenas processar a primeira resposta que chegar. A abordagem síncrona faz esperar em fila; a classe CompletableFuture permite iniciar tudo ao mesmo tempo e combinar os resultados de forma elegante. Ela fornece métodos específicos para isso: thenCombine, allOf, anyOf. Vamos analisar cada um por ordem.
Tarefas paralelas: duas chamadas assíncronas
Como isso ficaria de forma síncrona:
String name = loadUserName(); // demorado
int balance = loadUserBalance(); // demorado
System.out.println("Nome: " + name + ", Saldo: " + balance);
Problema: a segunda chamada começará apenas após a conclusão da primeira.
Abordagem assíncrona
Com CompletableFuture, ambas as tarefas podem ser iniciadas ao mesmo tempo:
CompletableFuture<String> nameFuture = CompletableFuture.supplyAsync(() -> loadUserName());
CompletableFuture<Integer> balanceFuture = CompletableFuture.supplyAsync(() -> loadUserBalance());
Mas como obter ambos os resultados e processá-los juntos? Para isso serve thenCombine.
2. thenCombine: combinando os resultados de duas tarefas
O método thenCombine permite combinar dois CompletableFuture e executar uma ação quando ambas as tarefas terminarem. Ele retorna um novo CompletableFuture com o resultado da combinação.
Assinatura:
<A, B, C> CompletableFuture<C> thenCombine(
CompletionStage<? extends B> other,
BiFunction<? super A, ? super B, ? extends C> fn
)
- A — tipo do resultado do primeiro future,
- B — tipo do segundo,
- C — tipo do resultado combinado.
Exemplo
CompletableFuture<String> nameFuture = CompletableFuture.supplyAsync(() -> loadUserName());
CompletableFuture<Integer> balanceFuture = CompletableFuture.supplyAsync(() -> loadUserBalance());
CompletableFuture<String> resultFuture = nameFuture.thenCombine(
balanceFuture,
(name, balance) -> "Nome: " + name + ", Saldo: " + balance
);
resultFuture.thenAccept(System.out::println);
Como funciona:
- Ambos os futures iniciam em paralelo.
- Assim que ambos terminam, a função (name, balance) -> ... é chamada.
- O future resultante contém a string com o resultado.
Mini-exemplo com números
CompletableFuture<Integer> f1 = CompletableFuture.supplyAsync(() -> 2);
CompletableFuture<Integer> f2 = CompletableFuture.supplyAsync(() -> 3);
CompletableFuture<Integer> sum = f1.thenCombine(f2, Integer::sum);
sum.thenAccept(result -> System.out.println("Soma: " + result));
Saída:
Soma: 5
Variante assíncrona
Se a combinação for uma operação pesada, use thenCombineAsync:
f1.thenCombineAsync(f2, (a, b) -> a * b);
3. allOf: quando há muitas tarefas
E se não tivermos duas tarefas, mas uma dezena? Por exemplo, queremos carregar em paralelo dados de dez usuários de uma só vez. Para isso, há o método CompletableFuture.allOf.
Descrição
CompletableFuture.allOf(f1, f2, ..., fn) retorna um novo future que será concluído quando todas as tarefas passadas forem concluídas. Mas há um detalhe: esse future não contém resultado — seu tipo é sempre CompletableFuture<Void>. Para obter os resultados, é preciso “buscar” separadamente a partir dos futures originais.
Exemplo
CompletableFuture<String> f1 = CompletableFuture.supplyAsync(() -> "Primeiro");
CompletableFuture<String> f2 = CompletableFuture.supplyAsync(() -> "Segundo");
CompletableFuture<Void> all = CompletableFuture.allOf(f1, f2);
all.thenRun(() -> {
// Todas as tarefas foram concluídas!
String s1 = f1.join(); // join() — como get(), mas lança unchecked exception
String s2 = f2.join();
System.out.println(s1 + " & " + s2);
});
Saída:
Primeiro & Segundo
Exemplo com array de tarefas
List<CompletableFuture<String>> futures = new ArrayList<>();
for (int i = 0; i < 5; i++) {
int id = i;
futures.add(CompletableFuture.supplyAsync(() -> "Usuário " + id));
}
CompletableFuture<Void> all = CompletableFuture.allOf(futures.toArray(new CompletableFuture[0]));
all.thenRun(() -> {
for (CompletableFuture<String> f : futures) {
System.out.println(f.join());
}
});
O que acontece:
- Todas as tarefas iniciam em paralelo.
- allOf será concluído quando todas as tarefas terminarem.
- No bloco thenRun podemos obter os resultados via join().
Esquema visual
[Future1] \
[Future2] ----> [allOf] ---> thenRun
[Future3] /
4. anyOf: aguardando a primeira tarefa a terminar
Às vezes, não precisamos esperar todas, mas sim obter o resultado da tarefa mais rápida. Por exemplo, solicitamos dados a dois servidores — usamos os dados de quem responder primeiro. Para isso, existe CompletableFuture.anyOf.
Descrição
CompletableFuture.anyOf(f1, f2, ..., fn) retorna um future que será concluído quando qualquer uma das tarefas passadas terminar. O tipo do resultado é CompletableFuture<Object>, pois os tipos das tarefas podem ser diferentes.
Exemplo
CompletableFuture<String> fast = CompletableFuture.supplyAsync(() -> {
sleep(500);
return "Servidor rápido";
});
CompletableFuture<String> slow = CompletableFuture.supplyAsync(() -> {
sleep(2000);
return "Servidor lento";
});
CompletableFuture<Object> any = CompletableFuture.anyOf(fast, slow);
any.thenAccept(result -> System.out.println("Recebido: " + result));
Saída:
Recebido: Servidor rápido
Exemplo com tipos diferentes
É possível combinar tarefas de tipos diferentes, mas nesse caso o resultado será do tipo Object, e será necessário fazer casting explícito.
5. Detalhes úteis
Recomendações
- allOf não retorna um array de resultados. É preciso manter os futures originais para obter seus valores via join() ou get().
- anyOf retorna o primeiro resultado concluído, mas com tipo Object. Se todas as tarefas forem do mesmo tipo, você pode fazer casting.
- Se uma das tarefas em allOf terminar com erro — o future resultante também terminará com erro.
- Para thenCombine, ambas as tarefas devem terminar com sucesso; caso contrário — exceção.
Tabela comparativa dos métodos
| Método | Quando usar | Tipo de resultado |
|---|---|---|
|
Você precisa combinar os resultados de duas tarefas | Resultado combinado |
|
É preciso aguardar a conclusão de todas as tarefas | |
|
É preciso aguardar a conclusão de qualquer uma das tarefas | Object (resultado da primeira tarefa) |
6. Erros comuns ao combinar CompletableFuture
Erro nº 1: Aguardar o resultado via get()/join() na thread principal.
Se você escreve código assíncrono, mas no final ainda chama get() ou join(), você bloqueia a thread e perde todas as vantagens da assincronia. Prefira usar thenAccept/thenRun para processar o resultado sem bloqueio.
Erro nº 2: Não armazenar referências aos futures originais ao usar allOf.
Se você chamar CompletableFuture.allOf(f1, f2, f3), mas não salvar f1, f2, f3 — não conseguirá obter seus resultados. allOf retorna apenas Void!
Erro nº 3: Não tratar erros na cadeia.
Se uma das tarefas terminar com erro, todo o allOf ou thenCombine também terminará com erro. Use os métodos de tratamento de erros (exceptionally, handle, whenComplete) para não perder exceções.
Erro nº 4: Incompatibilidade de tipos com anyOf.
anyOf retorna um Object. Se seus futures retornam tipos diferentes, será preciso descobrir o que chegou primeiro. É melhor usar tipos de tarefa iguais, se possível.
Erro nº 5: Cadeias muito complexas sem comentários.
Quando o código cresce, as cadeias de futures podem virar “espaguete”. Não hesite em dividir a cadeia em variáveis separadas e comentar os passos.
GO TO FULL VERSION