Vorbește despre conceptul clasei CompletableFuture…

CompletableFuture este o clasă în Java 8+ care implementează interfețele Future și CompletionStage. Reprezintă o calculare asincronă care poate fi finalizată (sau eșua) într-un anumit moment în viitor și asupra căreia se pot executa acțiuni ulterioare în mod declarativ, fără blocarea firului principal.

Principalele caracteristici:

Executare asincronă: Permite lansarea de sarcini într-un fir separat (sau pool de fire).
Compoziție: Se pot combina mai multe CompletableFuture, creând lanțuri de acțiuni dependente.
Gestionarea excepțiilor: Oferă metode pentru tratarea erorilor în calculele asincrone.
Operații non-blocante: Rezultatul sau excepția sunt gestionate atunci când future-ul se finalizează, fără așteptare explicită (get()).

Metode cheie:

Creare:
- supplyAsync(Supplier<T> supplier): Rulează un Supplier asincron și returnează un CompletableFuture cu rezultatul său.
- runAsync(Runnable runnable): Rulează un Runnable asincron și returnează un CompletableFuture<Void>.
- completedFuture(T value): Creează un CompletableFuture deja finalizat cu o valoare dată.
Transformare:
- thenApply(Function<T, U> fn): Aplică o funcție când future-ul se finalizează.
- thenAccept(Consumer<T> action): Execută o acțiune asupra rezultatului când future-ul se finalizează.
- thenRun(Runnable action): Execută o acțiune când future-ul se finalizează, ignorând rezultatul.
- thenCompose(Function<T, CompletionStage<U>> fn): Permite construirea de lanțuri în care rezultatul unui future este folosit pentru a crea altul.
Combinare:
- thenCombine(CompletionStage<U> other, BiFunction<T, U, V> fn): Combină rezultatele a două future-uri.
- allOf(CompletableFuture<?>... cfs): Returnează un CompletableFuture<Void> care se finalizează când toate future-urile date se finalizează.
- anyOf(CompletableFuture<?>... cfs): Returnează un CompletableFuture<Object> care se finalizează când oricare dintre future-urile date se finalizează.
Gestionarea excepțiilor:
- exceptionally(Function<Throwable, T> fn): Gestionează excepțiile, returnând o valoare alternativă.
- handle(BiFunction<T, Throwable, U> fn): Gestionează atât rezultatul, cât și excepția.

Exemplu:

// Pornirea unei sarcini asincrone
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    try {
        Thread.sleep(1000); // Simulare de muncă îndelungată
    } catch (InterruptedException e) {
        throw new IllegalStateException(e);
    }
    return "Rezultatul operației asincrone";
});

// Executarea unei acțiuni după finalizarea sarcinii (fără blocare)
future.thenAccept(result -> {
    System.out.println("Rezultat obținut: " + result);
});

// O altă acțiune dependentă de prima
future.thenApply(String::toUpperCase)
      .thenAccept(upperCaseResult -> {
          System.out.println("Rezultat în majuscule: " + upperCaseResult);
      });

// Așteptarea finalizării tuturor sarcinilor (în aplicații reale, se evită de obicei utilizarea explicită a get/join)
// future.join();

CompletableFuture este un instrument puternic pentru scrierea de cod reactiv și non-blocant în Java, simplificând semnificativ lucrul cu asincronia comparativ cu interfața clasică Future.

Vorbește despre conceptul clasei CompletableFuture.