Parla del concetto di classe CompletableFuture.

CompletableFuture è una classe in Java 8+ che implementa le interfacce Future e CompletionStage. Rappresenta un calcolo asincrono che può essere completato (o fallire) in un momento futuro e su cui è possibile eseguire azioni successive in modo dichiarativo, senza bloccare il thread principale.

Le principali funzionalità:

• Esecuzione asincrona: Permette di avviare compiti in un thread separato (o in un pool di thread).
• Composizione: È possibile combinare più CompletableFuture, creando catene di azioni dipendenti.
• Gestione delle eccezioni: Fornisce metodi per gestire gli errori nei calcoli asincroni.
• Operazioni non bloccanti: Il risultato o l'eccezione vengono gestiti quando il future si completa, senza attesa esplicita (get()).

Metodi chiave:

• Creazione:
  • supplyAsync(Supplier<T> supplier): Esegue un Supplier in modo asincrono e restituisce un CompletableFuture con il suo risultato.
  • runAsync(Runnable runnable): Esegue un Runnable in modo asincrono e restituisce un CompletableFuture<Void>.
  • completedFuture(T value): Crea un CompletableFuture già completato con un valore dato.
• Trasformazione:
  • thenApply(Function<T, U> fn): Applica una funzione quando il future si completa.
  • thenAccept(Consumer<T> action): Esegue un'azione sul risultato quando il future si completa.
  • thenRun(Runnable action): Esegue un'azione quando il future si completa, ignorando il risultato.
  • thenCompose(Function<T, CompletionStage<U>> fn): Permette di costruire catene in cui il risultato di un future viene usato per creare un altro.
• Combinazione:
  • thenCombine(CompletionStage<U> other, BiFunction<T, U, V> fn): Combina i risultati di due futures.
  • allOf(CompletableFuture<?>... cfs): Restituisce un CompletableFuture<Void> che si completa quando tutti i futures passati si completano.
  • anyOf(CompletableFuture<?>... cfs): Restituisce un CompletableFuture<Object> che si completa quando uno qualsiasi dei futures passati si completa.
• Gestione delle eccezioni:
  • exceptionally(Function<Throwable, T> fn): Gestisce le eccezioni restituendo un valore alternativo.
  • handle(BiFunction<T, Throwable, U> fn): Gestisce sia il risultato che l'eccezione.

Esempio:

// Avviare un compito asincrono
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    try {
        Thread.sleep(1000); // Simulazione di un lavoro lungo
    } catch (InterruptedException e) {
        throw new IllegalStateException(e);
    }
    return "Risultato dell'operazione asincrona";
});

// Eseguire un'azione dopo che il compito termina (senza bloccare)
future.thenAccept(result -> {
    System.out.println("Risultato ottenuto: " + result);
});

// Un'altra azione dipendente dalla prima
future.thenApply(String::toUpperCase)
      .thenAccept(upperCaseResult -> {
          System.out.println("Risultato in maiuscolo: " + upperCaseResult);
      });

// Attendere che tutti i compiti siano completati (nelle applicazioni reali si evita di usare get/join esplicitamente)
// future.join();

CompletableFuture è uno strumento potente per scrivere codice reattivo e non bloccante in Java, semplificando notevolmente la gestione dell'asincronia rispetto all'interfaccia Future classica.