A cosa serve CompletableFuture in Java?

CompletableFuture viene utilizzato per l'esecuzione asincrona di compiti e la composizione di operazioni asincrone. Rappresenta il risultato di un'operazione asincrona che può essere completata in futuro.

Vantaggi principali e motivi per usarlo:

• Esecuzione asincrona: Permette di eseguire compiti in background senza bloccare il thread principale.
• Composizione di operazioni asincrone: Consente di concatenare più compiti asincroni, definendo come devono essere eseguiti sequenzialmente o in parallelo, e di elaborarne i risultati.
• Gestione delle eccezioni: Fornisce meccanismi per gestire errori in compiti asincroni.
• Flessibilità: Supporta diversi metodi per elaborare il risultato (ad esempio, applicare funzioni, eseguire il compito successivo) e definire i thread di esecuzione.

Esempi di utilizzo:

1. Eseguire più compiti indipendenti in parallelo e attendere che siano completati:

   // Esempio di esecuzione parallela di due compiti
   CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {
       // Operazione lunga 1
       return "Risultato 1";
   });
   
   CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
       // Operazione lunga 2
       return "Risultato 2";
   });
   
   CompletableFuture<Void> combinedFuture = CompletableFuture.allOf(future1, future2);
   
   combinedFuture.join(); // Attendere il completamento di entrambi i compiti
   

2. Eseguire operazioni asincrone sequenziali:

   // Esempio di esecuzione sequenziale di compiti
   CompletableFuture<String> initialFuture = CompletableFuture.supplyAsync(() -> "Valore iniziale");
   
   CompletableFuture<Integer> transformedFuture = initialFuture.thenApplyAsync(result -> {
       // Trasformare il risultato
       return result.length();
   });
   
   transformedFuture.thenAccept(length -> {
       System.out.println("Lunghezza della stringa: " + length);
   });
   

3. Gestione delle eccezioni:

   // Esempio di gestione delle eccezioni
   CompletableFuture<String> errorFuture = CompletableFuture.supplyAsync(() -> {
       if (true) {
           throw new RuntimeException("Si è verificato un errore");
       }
       return "Successo";
   }).exceptionally(ex -> {
       System.err.println("Gestione dell'errore: " + ex.getMessage());
       return "Errore gestito"; // Valore di riserva
   });
   
   System.out.println(errorFuture.join());