CodeGym /Cursos /JAVA 25 SELF /Combinando CompletableFuture: thenCombine, allOf, anyOf

Combinando CompletableFuture: thenCombine, allOf, anyOf

JAVA 25 SELF
Nível 55, Lição 2
Disponível

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
thenCombine
Você precisa combinar os resultados de duas tarefas Resultado combinado
allOf
É preciso aguardar a conclusão de todas as tarefas
Void
anyOf
É 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.

1
Tarefa
JAVA 25 SELF, nível 55, lição 2
Bloqueado
Coordenação de Entregas: Aguardando Todas as Cargas
Coordenação de Entregas: Aguardando Todas as Cargas
1
Tarefa
JAVA 25 SELF, nível 55, lição 2
Bloqueado
Montagem da Saudação: Unindo Fragmentos de Fala
Montagem da Saudação: Unindo Fragmentos de Fala
Comentários
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION