Ce este CompletableFuture?

CompletableFuture în Java 8+ reprezintă o extensie a modelului Future, adăugând capabilități de programare asincronă și compoziție de sarcini.

Implementă interfețele CompletionStage și Future. CompletionStage definește contractul pentru execuția asincronă și compoziția pașilor de calcul.

Caracteristici cheie:

• Operații non-blocante: Permite executarea sarcinilor asincron, fără a bloca firul principal.
• Compoziție: Oferă o API bogată pentru legarea și combinarea rezultatelor mai multor operații asincrone.
• Gestionarea excepțiilor: Mecanisme încorporate pentru gestionarea erorilor în fluxurile asincrone.
• Creare: Se pot crea CompletableFuture completate, necompletate sau cu erori.
• Dependențe: Permite crearea de lanțuri de sarcini dependente, unde execuția uneia depinde de finalizarea alteia.
• Executare paralelă: Metode precum allOf și anyOf pentru executarea paralelă a mai multor sarcini.

Exemple de utilizare:

1. Creare și finalizare:

   // Crearea unui CompletableFuture completat
   CompletableFuture<String> completedFuture = CompletableFuture.completedFuture("Salut");
   
   // Crearea unui CompletableFuture necompletat și finalizarea ulterioară
   CompletableFuture<String> future = new CompletableFuture<>();
   // ... efectuarea muncii asincrone ...
   future.complete("Gata");
   // Sau în caz de eroare
   // future.completeExceptionally(new RuntimeException("Eroare"));
   

2. Executarea unei sarcini asincrone:

   CompletableFuture<String> asyncFuture = CompletableFuture.supplyAsync(() -> {
       // Muncă asincronă (de exemplu, citirea din fișier, solicitare de rețea)
       try {
           Thread.sleep(1000);
       } catch (InterruptedException e) {
           throw new IllegalStateException(e);
       }
       return "Rezultat asincron";
   });
   

3. Compoziție cu thenApply:

   CompletableFuture<Integer> result = CompletableFuture.supplyAsync(() -> 10)
       .thenApply(x -> x * 2); // Rezultatul pasului anterior este transmis funcției
   

4. Compoziție cu thenCombine:

   CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> 10);
   CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> 20);
   
   CompletableFuture<Integer> combinedFuture = future1.thenCombine(future2, (res1, res2) -> res1 + res2); // Combinarea rezultatelor a două CompletableFuture
   

5. Gestionarea finalizării cu thenAccept:

   CompletableFuture.supplyAsync(() -> "Rezultat final")
       .thenAccept(result -> System.out.println("Sarcina finalizată cu rezultat: " + result)); // Executarea unei acțiuni după finalizare fără returnarea unei valori
   

6. Gestionarea excepțiilor cu exceptionally:

   CompletableFuture<String> futureWithException = CompletableFuture.supplyAsync(() -> {
       throw new RuntimeException("Ceva nu a mers bine");
   }).exceptionally(ex -> {
       System.err.println("Eroare apărută: " + ex.getMessage());
       return "Valoare implicită"; // Returnează o valoare implicită în caz de eroare
   });
   

CompletableFuture simplifică semnificativ scrierea codului asincron și non-blocant în Java, făcându-l mai ușor de citit și întreținut comparativ cu callback-urile tradiționale sau apelurile blocante Future.get().