O que é CompletableFuture?

O CompletableFuture em Java 8+ representa uma extensão do modelo Future, adicionando capacidades de programação assíncrona e composição de tarefas.

Ele implementa as interfaces CompletionStage e Future. CompletionStage define o contrato para execução assíncrona e composição de etapas de cálculo.

Características principais:

• Operações não bloqueantes: Permite executar tarefas de forma assíncrona sem bloquear a thread principal.
• Composição: Fornece uma API rica para vincular e combinar resultados de múltiplas operações assíncronas.
• Manipulação de exceções: Mecanismos integrados para gerenciar erros em fluxos assíncronos.
• Criação: Pode criar CompletableFuture concluídos, não concluídos ou com erro.
• Dependências: Permite criar cadeias de tarefas dependentes, onde a execução de uma depende da finalização de outra.
• Execução paralela: Métodos como allOf e anyOf para executar várias tarefas em paralelo.

Exemplos de uso:

1. Criação e finalização:

   // Criar um CompletableFuture concluído
   CompletableFuture<String> completedFuture = CompletableFuture.completedFuture("Hello");
   
   // Criar um CompletableFuture não concluído e concluí-lo mais tarde
   CompletableFuture<String> future = new CompletableFuture<>();
   // ... realizar trabalho assíncrono ...
   future.complete("Done");
   // Ou em caso de erro
   // future.completeExceptionally(new RuntimeException("Erro"));
   

2. Executar tarefa assíncrona:

   CompletableFuture<String> asyncFuture = CompletableFuture.supplyAsync(() -> {
       // Trabalho assíncrono (por exemplo, ler um arquivo, requisição de rede)
       try {
           Thread.sleep(1000);
       } catch (InterruptedException e) {
           throw new IllegalStateException(e);
       }
       return "Resultado Assíncrono";
   });
   

3. Composição com thenApply:

   CompletableFuture<Integer> result = CompletableFuture.supplyAsync(() -> 10)
       .thenApply(x -> x * 2); // O resultado do passo anterior é passado para a função
   

4. Composição com thenCombine:

   CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> 10);
   CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> 20);
   
   CompletableFuture<Integer> combinedFuture = future1.thenCombine(future2, (res1, res2) -> res1 + res2); // Combina os resultados de dois CompletableFuture
   

5. Manipulação de finalização com thenAccept:

   CompletableFuture.supplyAsync(() -> "Resultado final")
       .thenAccept(result -> System.out.println("Tarefa finalizada com resultado: " + result)); // Executa uma ação após a finalização sem retornar valor
   

6. Manipulação de exceções com exceptionally:

   CompletableFuture<String> futureWithException = CompletableFuture.supplyAsync(() -> {
       throw new RuntimeException("Algo deu errado");
   }).exceptionally(ex -> {
       System.err.println("Erro ocorrido: " + ex.getMessage());
       return "Valor padrão"; // Retorna valor padrão em caso de erro
   });
   

CompletableFuture simplifica bastante a escrita de código assíncrono e não bloqueante em Java, tornando-o mais legível e fácil de manter em comparação com callbacks tradicionais ou chamadas bloqueantes Future.get().