// El problema, en codi real de BiblioTech.
ExecutorService executor = Executors.newFixedThreadPool(4);

Future<Cataleg> f1 = executor.submit(() -> carregarCataleg());
Cataleg c = f1.get();                     // BLOQUEJA. El fil s'atura aqui.

Future<Double> f2 = executor.submit(() -> calcularMultes(c));
double total = f2.get();                  // BLOQUEJA un altre cop.

Future<Path> f3 = executor.submit(() -> exportar(total));
Path informe = f3.get();                  // I un altre cop.

// El mateix amb CompletableFuture: es DECLARA la cadena i es retorna
// immediatament. Cap fil no es bloqueja en cap moment.
CompletableFuture<Path> informe =
        CompletableFuture.supplyAsync(() -> carregarCataleg(), poolEs)
                         .thenApplyAsync(c -> calcularMultes(c), poolCalcul)
                         .thenApplyAsync(total -> exportar(total), poolEs)
                         .exceptionally(error -> camiDError(error));

System.out.println("[main] cadena llancada; el menu continua viu");
mostrarMenu();      // el fil principal NO ha esperat res

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;

// 1. supplyAsync: executa un Supplier i RETORNA un valor.
//    Es el punt d'entrada mes frequent.
CompletableFuture<Cataleg> f1 =
        CompletableFuture.supplyAsync(() -> carregarCataleg());

// Amb executor propi (recomanat, apartat 4):
CompletableFuture<Cataleg> f2 =
        CompletableFuture.supplyAsync(() -> carregarCataleg(), poolEs);

// 2. runAsync: executa un Runnable, NO retorna valor.
//    El tipus es CompletableFuture<Void>.
CompletableFuture<Void> f3 =
        CompletableFuture.runAsync(() -> registrarAuditoria("arrencada"), poolEs);

// 3. completedFuture: ja completat amb un valor. No executa res.
//    Util per a valors en memoria cau i per a proves.
CompletableFuture<Cataleg> f4 =
        CompletableFuture.completedFuture(catalegEnCache);

// 4. failedFuture (Java 9): ja completat amb una excepcio.
CompletableFuture<Cataleg> f5 =
        CompletableFuture.failedFuture(new BiblioTechException("cataleg no disponible"));

// 5. Buit, per completar-lo manualment despres (apartat 13).
CompletableFuture<Cataleg> f6 = new CompletableFuture<>();

/**
 * Retorna SEMPRE un CompletableFuture, tant si la dada es a la
 * memoria cau (resposta immediata) com si cal calcular-la (asincron).
 * Qui crida no ha de distingir els dos casos.
 */
public CompletableFuture<Fitxa> obtenirFitxa(String isbn) {
    Fitxa enCache = cache.get(isbn);
    if (enCache != null) {
        return CompletableFuture.completedFuture(enCache);   // ja llesta
    }
    return CompletableFuture.supplyAsync(() -> construirFitxa(isbn), poolEs);
}

// PERILLOS: E/S al pool comu.
// El pool comu te (nuclis - 1) fils i el COMPARTEIX tota la JVM:
// els streams parallels (10-04), altres llibreries i la resta del teu
// codi. Amb 7 fils i 10 lectures de fitxer lentes, el pool queda
// inservible per a tothom.
CompletableFuture.supplyAsync(() -> Files.readAllLines(camiEnorme));

// CORRECTE: executor propi per a E/S, dimensionat segons 08-05.
private static final ExecutorService POOL_ES = new ThreadPoolExecutor(
        16, 16, 0L, TimeUnit.MILLISECONDS,
        new ArrayBlockingQueue<>(200),
        r -> new Thread(r, "bibliotech-async-es-" + comptador.getAndIncrement()),
        new ThreadPoolExecutor.CallerRunsPolicy());

CompletableFuture.supplyAsync(() -> Files.readAllLines(camiEnorme), POOL_ES);

import java.util.concurrent.CompletableFuture;

CompletableFuture<Void> cadena =
    CompletableFuture
        // 1. Produeix un Cataleg
        .supplyAsync(() -> carregarCataleg(), POOL_ES)

        // 2. thenApply: Cataleg -> Double. Transforma.
        .thenApply(cataleg -> calcularMultesTotals(cataleg))

        // 3. thenApply: Double -> String. Una altra transformacio.
        .thenApply(total -> String.format("Multes pendents: %.2f EUR", total))

        // 4. thenAccept: consumeix el String, no produeix res.
        .thenAccept(text -> System.out.println(text))

        // 5. thenRun: no rep ni retorna. Per a efectes finals.
        .thenRun(() -> LOG.info("Informe de multes completat"));

System.out.println("[main] cadena declarada, continuo treballant");

// Metode que retorna un valor normal:
Double calcularMultes(Cataleg c) { ... }

// Metode que retorna un CompletableFuture (perque es asincron):
CompletableFuture<Double> calcularMultesAsync(Cataleg c) { ... }

// L'ERROR: thenApply amb una funcio que retorna CompletableFuture.
CompletableFuture<CompletableFuture<Double>> imbricat =
        CompletableFuture.supplyAsync(() -> carregarCataleg())
                         .thenApply(c -> calcularMultesAsync(c));

// Ara, per arribar al Double, cal desembolcallar DUES vegades:
Double d = imbricat.get().get();     // horrible, i bloqueja dues vegades

// LA SOLUCIO: thenCompose APLANA la imbricacio.
CompletableFuture<Double> pla =
        CompletableFuture.supplyAsync(() -> carregarCataleg())
                         .thenCompose(c -> calcularMultesAsync(c));

Double d2 = pla.join();              // un sol nivell

package com.nexussoftware.bibliotech.servei;

import java.util.concurrent.CompletableFuture;

public class ConsultaAsincrona {

    /** Sincron: retorna el valor directament. */
    private Material cercarMaterial(String isbn) { ... }

    /** Asincron: retorna un CompletableFuture. */
    private CompletableFuture<Fitxa> construirFitxaAsync(Material m) { ... }

    /** Sincron: transformacio barata. */
    private String formatar(Fitxa f) { ... }

    /**
     * Cadena que alterna operacions sincrones i asincrones.
     * Fixa't que thenCompose apareix exactament on la
     * funcio retorna un CompletableFuture.
     */
    public CompletableFuture<String> fitxaFormatada(String isbn) {
        return CompletableFuture
                .supplyAsync(() -> cercarMaterial(isbn), POOL_ES)   // -> Material
                .thenCompose(this::construirFitxaAsync)             // -> Fitxa (async)
                .thenApply(this::formatar);                         // -> String (sync)
    }
}

.thenApply(f)                  // 1. sense sufix
.thenApplyAsync(f)             // 2. amb sufix, executor per defecte
.thenApplyAsync(f, executor)   // 3. amb sufix i executor explicit

public class QuinFilExecuta {

    public static void main(String[] args) throws Exception {

        ExecutorService pool = Executors.newFixedThreadPool(2,
                r -> new Thread(r, "bibliotech-pool"));

        System.out.println("main executa a: " + Thread.currentThread().getName());

        CompletableFuture<String> f = CompletableFuture
                .supplyAsync(() -> {
                    traca("supplyAsync");
                    return "cataleg";
                }, pool)
                .thenApply(v -> {
                    traca("thenApply");          // el fil del pool
                    return v + "-processat";
                })
                .thenApplyAsync(v -> {
                    traca("thenApplyAsync");     // commonPool
                    return v + "-async";
                })
                .thenApplyAsync(v -> {
                    traca("thenApplyAsync(pool)"); // el pool que li donem
                    return v + "-propi";
                }, pool);

        System.out.println("resultat: " + f.join());
        pool.shutdown();
    }

    static void traca(String etapa) {
        System.out.printf("  %-24s -> %s%n", etapa, Thread.currentThread().getName());
    }
}

main executa a: main
  supplyAsync              -> bibliotech-pool
  thenApply                -> bibliotech-pool
  thenApplyAsync           -> ForkJoinPool.commonPool-worker-1
  thenApplyAsync(pool)     -> bibliotech-pool
resultat: cataleg-processat-async-propi

// MALAMENT: bloquejar en una etapa sense sufix ocupa el fil anterior,
// que podria ser un fil del pool comu o el mateix main.
.thenApply(cataleg -> escriureAlDisc(cataleg))       // 500 ms bloquejant

// BE: la feina pesada va a un pool dedicat.
.thenApplyAsync(cataleg -> escriureAlDisc(cataleg), POOL_ES)

package com.nexussoftware.bibliotech.servei;

import java.util.concurrent.CompletableFuture;

public class ResumAsincron {

    /**
     * Les dues consultes son independents i es llancen alhora.
     * El temps total es el de la MES LENTA, no la suma.
     */
    public CompletableFuture<String> resumComplet(String isbn) {

        CompletableFuture<Material> material =
                CompletableFuture.supplyAsync(() -> cataleg.cercar(isbn), POOL_ES);

        CompletableFuture<Integer> prestecs =
                CompletableFuture.supplyAsync(() -> registre.comptarPrestecs(isbn), POOL_ES);

        // thenCombine espera TOTS DOS i aplica la BiFunction (04-06).
        return material.thenCombine(prestecs, (m, n) ->
                String.format("%s (%s) - %d prestecs historics",
                        m.titol(), m.isbn(), n));
    }

    /** Tres o mes: s'encadenen els thenCombine. */
    public CompletableFuture<InformeComplet> informeComplet(String isbn) {

        CompletableFuture<Material> material =
                CompletableFuture.supplyAsync(() -> cataleg.cercar(isbn), POOL_ES);
        CompletableFuture<Integer> prestecs =
                CompletableFuture.supplyAsync(() -> registre.comptarPrestecs(isbn), POOL_ES);
        CompletableFuture<Double> multes =
                CompletableFuture.supplyAsync(() -> calculadora.multesDe(isbn), POOL_ES);

        return material
                .thenCombine(prestecs, ParcialMaterialPrestecs::new)
                .thenCombine(multes, (parcial, m) ->
                        new InformeComplet(parcial.material(), parcial.prestecs(), m));
    }

    private record ParcialMaterialPrestecs(Material material, int prestecs) { }
}

package com.nexussoftware.bibliotech.servei;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CompletableFuture;

public class AvisosAsincrons {

    /**
     * Envia tots els avisos en parallel i espera que acabin TOTS.
     *
     * El patro de recollida es sempre el mateix:
     *   1. Crear la llista de futurs.
     *   2. allOf(...) sobre l'array.
     *   3. thenApply que recorre els futurs i crida join()
     *      —segur, perque allOf garanteix que ja estan complets—.
     */
    public CompletableFuture<List<ResultatAvis>> enviarTots(List<Prestec> vencuts) {

        List<CompletableFuture<ResultatAvis>> futurs = new ArrayList<>();
        for (Prestec p : vencuts) {
            futurs.add(CompletableFuture.supplyAsync(() -> enviarAvis(p), POOL_ES));
        }

        // allOf rep un array, no una llista.
        CompletableFuture<Void> tots =
                CompletableFuture.allOf(futurs.toArray(new CompletableFuture[0]));

        return tots.thenApply(v -> {
            List<ResultatAvis> resultats = new ArrayList<>(futurs.size());
            for (CompletableFuture<ResultatAvis> f : futurs) {
                // join() aqui NO bloqueja: allOf ja ha garantit que
                // tots estan complets.
                resultats.add(f.join());
            }
            return resultats;
        });
    }

    /**
     * Variant TOLERANT A FALLADES: un avis fallit no tomba el conjunt.
     *
     * COMPTE: si un futur falla, l'allOf tambe falla i el seu join()
     * rellancaria l'excepcio. La solucio es blindar CADA futur amb
     * el seu propi exceptionally ABANS d'agregar-los.
     */
    public CompletableFuture<List<ResultatAvis>> enviarTotsTolerant(
            List<Prestec> vencuts) {

        List<CompletableFuture<ResultatAvis>> futurs = new ArrayList<>();
        for (Prestec p : vencuts) {
            futurs.add(CompletableFuture
                    .supplyAsync(() -> enviarAvis(p), POOL_ES)
                    .exceptionally(e -> ResultatAvis.fallada(p, e.getMessage())));
        }

        return CompletableFuture
                .allOf(futurs.toArray(new CompletableFuture[0]))
                .thenApply(v -> {
                    List<ResultatAvis> r = new ArrayList<>();
                    for (CompletableFuture<ResultatAvis> f : futurs) r.add(f.join());
                    return r;
                });
    }
}

// Tres fonts per al mateix cataleg; ens val la primera.
CompletableFuture<Cataleg> cache   = llegirDeCache();
CompletableFuture<Cataleg> fitxer  = llegirDelFitxerPrincipal();
CompletableFuture<Cataleg> reserva = llegirDeCopiaSeguretat();

CompletableFuture<Object> primer =
        CompletableFuture.anyOf(cache, fitxer, reserva);

Cataleg c = (Cataleg) primer.join();        // cal fer casting

package com.nexussoftware.bibliotech.servei;

import java.util.concurrent.CompletableFuture;
import java.util.logging.Level;
import java.util.logging.Logger;

public class GestioErrorsAsincrona {

    private static final Logger LOG =
            Logger.getLogger(GestioErrorsAsincrona.class.getName());

    /** 1. exceptionally: valor de reserva si alguna cosa falla. */
    public CompletableFuture<Cataleg> carregarAmbReserva() {
        return CompletableFuture
                .supplyAsync(() -> carregarDelFitxer(), POOL_ES)
                .exceptionally(error -> {
                    // 'error' es una CompletionException que EMBOLCALLA la causa.
                    LOG.log(Level.WARNING, "Fallada en carregar; faig servir la reserva",
                            error.getCause());
                    return Cataleg.buit();        // la cadena CONTINUA
                });
    }

    /** 2. handle: s'executa sempre, i unifica els dos camins. */
    public CompletableFuture<String> informeAmbHandle() {
        return CompletableFuture
                .supplyAsync(() -> generarInforme(), POOL_ES)
                .handle((resultat, error) -> {
                    // Exactament un dels dos es null.
                    if (error != null) {
                        LOG.log(Level.SEVERE, "Informe fallit", error);
                        return "INFORME NO DISPONIBLE: " + causaDe(error).getMessage();
                    }
                    return "INFORME OK: " + resultat;
                });
    }

    /** 3. whenComplete: observa sense alterar. Ideal per a traces i metriques. */
    public CompletableFuture<Cataleg> carregarAmbTraca() {
        long inici = System.nanoTime();
        return CompletableFuture
                .supplyAsync(() -> carregarDelFitxer(), POOL_ES)
                .whenComplete((cataleg, error) -> {
                    long ms = (System.nanoTime() - inici) / 1_000_000;
                    if (error != null) {
                        LOG.log(Level.WARNING, "Carrega fallida en " + ms + " ms", error);
                    } else {
                        LOG.log(Level.INFO, "Cataleg carregat en {0} ms ({1} materials)",
                                new Object[] { ms, cataleg.mida() });
                    }
                    // Retornar alguna cosa aqui NO canviaria el resultat:
                    // whenComplete nomes OBSERVA. L'error continua propagant-se.
                });
    }

    /** Utilitat: desembolcallar la causa real. */
    static Throwable causaDe(Throwable t) {
        return (t instanceof java.util.concurrent.CompletionException
                || t instanceof java.util.concurrent.ExecutionException)
                && t.getCause() != null ? t.getCause() : t;
    }
}

CompletableFuture<Path> informe = CompletableFuture
        .supplyAsync(() -> carregarCataleg(), POOL_ES)
        .thenApplyAsync(this::calcularMultes, POOL_CALCUL)
        .thenApplyAsync(this::exportar, POOL_ES)
        .whenComplete((cami, error) -> registrarMetrica(cami, error))   // observar
        .exceptionally(error -> {                                       // gestionar
            LOG.log(Level.SEVERE, "Cadena d'informe fallida", error);
            return Path.of("informes/error.txt");
        });

public class PropagacioErrors {

    public static void main(String[] args) {

        CompletableFuture<String> cadena = CompletableFuture
                .supplyAsync(() -> {
                    System.out.println("  etapa 1: OK");
                    return "cataleg";
                })
                .thenApply(v -> {
                    System.out.println("  etapa 2: llancant excepcio");
                    throw new IllegalStateException("cataleg corrupte");
                })
                .thenApply(v -> {
                    System.out.println("  etapa 3: NO S'EXECUTA");
                    return v + "-processat";
                })
                .thenApply(v -> {
                    System.out.println("  etapa 4: TAMPOC");
                    return v.toUpperCase();
                })
                .exceptionally(error -> {
                    System.out.println("  gestor: capturat " + error.getClass().getSimpleName());
                    System.out.println("          causa real: "
                            + error.getCause().getClass().getSimpleName()
                            + ": " + error.getCause().getMessage());
                    return "VALOR-DE-RESERVA";
                })
                .thenApply(v -> {
                    System.out.println("  etapa 5: SI que s'executa, amb la reserva");
                    return v.toLowerCase();
                });

        System.out.println("resultat: " + cadena.join());
    }
}

  etapa 1: OK
  etapa 2: llancant excepcio
  gestor: capturat CompletionException
          causa real: IllegalStateException: cataleg corrupte
  etapa 5: SI que s'executa, amb la reserva
resultat: valor-de-reserva

// PARANY: sembla que l'exceptionally protegeix tota la cadena.
CompletableFuture<Path> f = CompletableFuture
        .supplyAsync(() -> carregarCataleg())
        .exceptionally(e -> Cataleg.buit())         // protegeix el de DALT
        .thenApply(c -> calcularMultes(c))           // <-- SENSE protegir
        .thenApply(m -> exportar(m));                // <-- SENSE protegir

// Si calcularMultes o exportar fallen, l'excepcio surt per join()
// i ningu no la gestiona. L'exceptionally ha quedat massa amunt.

// CORRECTE: el gestor al FINAL de la cadena.
CompletableFuture<Path> g = CompletableFuture
        .supplyAsync(() -> carregarCataleg())
        .thenApply(c -> calcularMultes(c))
        .thenApply(m -> exportar(m))
        .exceptionally(e -> {                        // protegeix TOT l'anterior
            LOG.log(Level.SEVERE, "Cadena fallida", e);
            return Path.of("informes/error.txt");
        });

// Si aquesta cadena falla, NO PASSA RES VISIBLE. No hi ha traca,
// no hi ha log, no hi ha excepcio. La fallada simplement desapareix.
CompletableFuture.supplyAsync(() -> carregarCataleg())
                 .thenAccept(c -> catalegGlobal = c);

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.TimeUnit;

// orTimeout: si no es completa dins del termini, FALLA amb TimeoutException.
CompletableFuture<Cataleg> ambTermini = CompletableFuture
        .supplyAsync(() -> carregarCataleg(), POOL_ES)
        .orTimeout(5, TimeUnit.SECONDS)
        .exceptionally(error -> {
            if (causaDe(error) instanceof java.util.concurrent.TimeoutException) {
                LOG.warning("La carrega ha excedit els 5 segons");
            }
            return Cataleg.buit();
        });

// completeOnTimeout: si no es completa dins del termini, es completa
// amb el VALOR PER DEFECTE. No falla.
CompletableFuture<Cataleg> ambDefecte = CompletableFuture
        .supplyAsync(() -> carregarCataleg(), POOL_ES)
        .completeOnTimeout(Cataleg.buit(), 5, TimeUnit.SECONDS);

package com.nexussoftware.bibliotech.persistencia;

import java.util.concurrent.CompletableFuture;

public class AdaptadorCallbacks {

    /**
     * API antiga basada en callbacks. Es incomoda de compondre:
     * imbricar-ne tres produeix la "piramide de la mort".
     */
    interface LectorAmbCallback {
        void llegirAsync(String isbn, Callback<Material> callback);
    }

    interface Callback<T> {
        void alCompletar(T resultat);
        void alFallar(Throwable error);
    }

    private final LectorAmbCallback lector;

    public AdaptadorCallbacks(LectorAmbCallback lector) { this.lector = lector; }

    /**
     * Converteix l'API de callbacks en un CompletableFuture componible.
     * Es el patro estandard per modernitzar codi heretat sense tocar-lo.
     */
    public CompletableFuture<Material> llegir(String isbn) {

        // 1. Futur buit, sense tasca associada.
        CompletableFuture<Material> futur = new CompletableFuture<>();

        // 2. Es llanca l'operacio amb un callback que el completa.
        lector.llegirAsync(isbn, new Callback<Material>() {
            @Override
            public void alCompletar(Material m) {
                futur.complete(m);                     // exit
            }
            @Override
            public void alFallar(Throwable error) {
                futur.completeExceptionally(error);    // fallada
            }
        });

        // 3. Es retorna immediatament, sense esperar el callback.
        return futur;
    }

    /**
     * I ara l'API antiga es componible com qualsevol altra:
     * tres lectures en parallel i combinacio, sense imbricacio.
     */
    public CompletableFuture<String> compararTres(String i1, String i2, String i3) {
        return llegir(i1)
                .thenCombine(llegir(i2), (a, b) -> a.titol() + " / " + b.titol())
                .thenCombine(llegir(i3), (parell, c) -> parell + " / " + c.titol());
    }
}

CompletableFuture<Cataleg> f =
        CompletableFuture.supplyAsync(() -> carregarCatalegLent(), POOL_ES);

TimeUnit.SECONDS.sleep(1);
boolean cancellat = f.cancel(true);       // el 'true' s'IGNORA

System.out.println("cancel(): " + cancellat);             // true
System.out.println("isCancelled(): " + f.isCancelled());  // true
// PERO: el fil de POOL_ES continua executant carregarCatalegLent()
// fins al final. El parametre mayInterruptIfRunning NO FA RES.

package com.nexussoftware.bibliotech.persistencia;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.atomic.AtomicBoolean;

/**
 * Cancellacio REAL d'una tasca asincrona: un marcador compartit
 * que la tasca consulta. Es la interrupcio cooperativa de 08-02
 * adaptada a CompletableFuture, que no pot interrompre per si sol.
 */
public class ImportacioCancellable {

    private final AtomicBoolean cancellada = new AtomicBoolean(false);
    private final CompletableFuture<Informe> futur;

    public ImportacioCancellable(Path fitxer) {
        this.futur = CompletableFuture.supplyAsync(() -> importar(fitxer), POOL_ES);
    }

    private Informe importar(Path fitxer) {
        int processades = 0;
        for (String linia : llegirLinies(fitxer)) {

            // PUNT DE CANCELLACIO explicit.
            if (cancellada.get() || Thread.currentThread().isInterrupted()) {
                throw new CancellationException(
                        "Importacio cancellada despres de " + processades + " linies");
            }
            processar(linia);
            processades++;
        }
        return new Informe(processades);
    }

    /** Cancellacio que SI atura la feina. */
    public void cancellar() {
        cancellada.set(true);         // la tasca ho veura i avortara
        futur.cancel(false);          // i el futur es completa ja
    }

    public CompletableFuture<Informe> futur() { return futur; }
}

// PESSIM: join() dins d'una etapa bloqueja un fil del pool.
// Amb prou cadenes aixi, el pool s'exhaureix i tot s'atura.
.thenApply(cataleg -> {
    Double multes = calcularMultesAsync(cataleg).join();    // BLOQUEJA
    return multes;
})

// CORRECTE: thenCompose aplana sense bloquejar ningu.
.thenCompose(cataleg -> calcularMultesAsync(cataleg))

// get(): llanca ExecutionException i InterruptedException, totes dues COMPROVADES.
try {
    Cataleg c = futur.get();
} catch (ExecutionException | InterruptedException e) { ... }

// join(): llanca CompletionException, NO comprovada. Mes comode
// dins de lambdes, on una excepcio comprovada no compila.
Cataleg c = futur.join();

// MALAMENT: una sola expressio de vint linies.

// BE: cada pas amb nom.
public CompletableFuture<Path> generarInformeMensual() {
    return carregarCataleg()
            .thenCompose(this::enriquirAmbPrestecs)
            .thenApplyAsync(this::calcularMultes, POOL_CALCUL)
            .thenApplyAsync(this::formatar, POOL_CALCUL)
            .thenApplyAsync(this::escriureFitxer, POOL_ES)
            .orTimeout(60, TimeUnit.SECONDS)
            .whenComplete(this::registrarMetriques)
            .exceptionally(this::informeDError);
}

package com.nexussoftware.bibliotech.servei;

import com.nexussoftware.bibliotech.domini.*;

import java.nio.file.Path;
import java.util.List;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * Generacio asincrona de l'informe mensual de BiblioTech.
 *
 * La cadena completa:
 *   1. Carregar el cataleg (E/S)          -- en parallel amb 2
 *   2. Carregar els prestecs actius (E/S) -- en parallel amb 1
 *   3. Combinar tots dos
 *   4. Calcular les multes (CPU)
 *   5. Formatar l'informe (CPU)
 *   6. Escriure el fitxer (E/S)
 *
 * CAP fil no es bloqueja esperant: el menu continua atenent l'usuari
 * durant tota l'operacio.
 */
public class GeneradorInformeAsincron implements AutoCloseable {

    private static final Logger LOG =
            Logger.getLogger(GeneradorInformeAsincron.class.getName());

    /** Pool d'E/S: molts fils perque gairebe tot es espera (08-01). */
    private final ExecutorService poolEs;
    /** Pool de calcul: un fil per nucli. */
    private final ExecutorService poolCalcul;

    private final CatalegConcurrent cataleg;
    private final RegistrePrestecsSegur registre;
    private final CalculadoraMultes calculadora;

    public GeneradorInformeAsincron(CatalegConcurrent cataleg,
                                    RegistrePrestecsSegur registre,
                                    CalculadoraMultes calculadora) {
        this.cataleg = cataleg;
        this.registre = registre;
        this.calculadora = calculadora;

        AtomicInteger nEs = new AtomicInteger(1);
        this.poolEs = new ThreadPoolExecutor(
                16, 16, 0L, TimeUnit.MILLISECONDS,
                new ArrayBlockingQueue<>(200),
                r -> new Thread(r, "bibliotech-async-es-" + nEs.getAndIncrement()),
                new ThreadPoolExecutor.CallerRunsPolicy());

        AtomicInteger nCpu = new AtomicInteger(1);
        this.poolCalcul = Executors.newFixedThreadPool(
                Runtime.getRuntime().availableProcessors(),
                r -> new Thread(r, "bibliotech-async-cpu-" + nCpu.getAndIncrement()));
    }

    // ---------- ETAPES ----------

    private CompletableFuture<List<Material>> carregarMaterials() {
        return CompletableFuture.supplyAsync(() -> {
            traca("carregant materials");
            dormir(400);                       // E/S simulada
            return cataleg.perTipus(TipusMaterial.LLIBRE);
        }, poolEs);
    }

    private CompletableFuture<List<Prestec>> carregarPrestecsActius() {
        return CompletableFuture.supplyAsync(() -> {
            traca("carregant prestecs");
            dormir(500);                       // E/S simulada, EN PARALLEL
            return registre.totsElsActius();
        }, poolEs);
    }

    /** Etapa de CPU: es mana al pool de calcul explicitament. */
    private DadesInforme calcular(List<Material> materials, List<Prestec> prestecs) {
        traca("calculant multes");
        double total = 0;
        int vencuts = 0;
        for (Prestec p : prestecs) {
            double m = calculadora.calcular(p);
            if (m > 0) { total += m; vencuts++; }
        }
        return new DadesInforme(materials.size(), prestecs.size(), vencuts, total);
    }

    private String formatar(DadesInforme d) {
        traca("formatant");
        return """
               ===========================================
                 BiblioTech - Informe mensual de multes
                 Nexus Software
               ===========================================
                 Materials al cataleg  : %d
                 Prestecs actius       : %d
                 Prestecs vencuts      : %d
                 Multes acumulades     : %.2f EUR
               ===========================================
               """.formatted(d.materials(), d.prestecs(), d.vencuts(), d.multes());
    }

    private Path escriure(String contingut) {
        traca("escrivint fitxer");
        dormir(300);                           // E/S simulada
        Path desti = Path.of("informes", "multes-mensual.txt");
        // Al codi real: EscripturaAtomica.escriure(desti, contingut) de 07-06
        return desti;
    }

    // ---------- LA CADENA ----------

    /**
     * Declara tota la cadena i RETORNA IMMEDIATAMENT.
     * El fil que crida no espera res.
     */
    public CompletableFuture<Path> generar() {

        long inici = System.nanoTime();

        // 1 i 2 arrenquen ALHORA: no s'encadenen, es combinen.
        CompletableFuture<List<Material>> materials = carregarMaterials();
        CompletableFuture<List<Prestec>> prestecs = carregarPrestecsActius();

        return materials
                // 3. Esperar tots dos i combinar-los. La feina es mana al
                //    pool de calcul amb thenCombineAsync, per no ocupar
                //    un fil d'E/S amb feina de CPU.
                .thenCombineAsync(prestecs, this::calcular, poolCalcul)

                // 4. Formatar: CPU, mateix pool.
                .thenApplyAsync(this::formatar, poolCalcul)

                // 5. Escriure: E/S, pool d'E/S.
                .thenApplyAsync(this::escriure, poolEs)

                // 6. Termini global.
                .orTimeout(30, TimeUnit.SECONDS)

                // 7. Observar sense alterar: metriques.
                .whenComplete((cami, error) -> {
                    long ms = (System.nanoTime() - inici) / 1_000_000;
                    if (error == null) {
                        LOG.log(Level.INFO, "Informe generat en {0} ms: {1}",
                                new Object[] { ms, cami });
                    } else {
                        LOG.log(Level.SEVERE, "Informe fallit despres de " + ms + " ms", error);
                    }
                })

                // 8. Gestionar: al FINAL, per cobrir tota la cadena.
                .exceptionally(error -> {
                    Throwable causa = causaDe(error);
                    if (causa instanceof TimeoutException) {
                        LOG.warning("L'informe ha excedit els 30 segons");
                    }
                    return Path.of("informes", "informe-no-disponible.txt");
                });
    }

    // ---------- AUXILIARS ----------

    record DadesInforme(int materials, int prestecs, int vencuts, double multes) { }

    static Throwable causaDe(Throwable t) {
        return (t instanceof CompletionException || t instanceof ExecutionException)
                && t.getCause() != null ? t.getCause() : t;
    }

    private static void traca(String etapa) {
        System.out.printf("      [%s] %s%n", Thread.currentThread().getName(), etapa);
    }

    private static void dormir(long ms) {
        try { TimeUnit.MILLISECONDS.sleep(ms); }
        catch (InterruptedException e) { Thread.currentThread().interrupt(); }
    }

    @Override
    public void close() {
        for (ExecutorService ex : List.of(poolCalcul, poolEs)) {
            ex.shutdown();
            try {
                if (!ex.awaitTermination(15, TimeUnit.SECONDS)) ex.shutdownNow();
            } catch (InterruptedException e) {
                ex.shutdownNow();
                Thread.currentThread().interrupt();
            }
        }
    }
}

package com.nexussoftware.bibliotech.presentacio;

import java.nio.file.Path;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.TimeUnit;

public class MenuAmbInformeAsincron {

    public static void main(String[] args) throws Exception {

        try (GeneradorInformeAsincron generador = new GeneradorInformeAsincron(
                cataleg, registre, calculadora)) {

            System.out.println("=== BiblioTech - Nexus Software ===");
            System.out.println("Llancant informe mensual en segon pla...\n");

            // La cadena sencera es declara i retorna a l'instant.
            CompletableFuture<Path> informe = generador.generar();

            // Registrem que fer en acabar. NO esperem.
            informe.thenAccept(cami ->
                    System.out.println("\n>>> Informe llest a: " + cami));

            // El menu continua atenent l'usuari.
            for (int i = 1; i <= 8; i++) {
                System.out.printf("  [menu] opcio %d atesa (el menu NO esta bloquejat)%n", i);
                TimeUnit.MILLISECONDS.sleep(200);
            }

            // Nomes al final, si de veritat cal el resultat, s'espera.
            Path cami = informe.get(30, TimeUnit.SECONDS);
            System.out.println("\n[main] confirmat: " + cami);
        }
    }
}

=== BiblioTech - Nexus Software ===
Llancant informe mensual en segon pla...

  [menu] opcio 1 atesa (el menu NO esta bloquejat)
      [bibliotech-async-es-1] carregant materials
      [bibliotech-async-es-2] carregant prestecs
  [menu] opcio 2 atesa (el menu NO esta bloquejat)
  [menu] opcio 3 atesa (el menu NO esta bloquejat)
      [bibliotech-async-cpu-1] calculant multes
      [bibliotech-async-cpu-1] formatant
  [menu] opcio 4 atesa (el menu NO esta bloquejat)
      [bibliotech-async-es-3] escrivint fitxer

>>> Informe llest a: informes/multes-mensual.txt
  [menu] opcio 5 atesa (el menu NO esta bloquejat)
  [menu] opcio 6 atesa (el menu NO esta bloquejat)
  [menu] opcio 7 atesa (el menu NO esta bloquejat)
  [menu] opcio 8 atesa (el menu NO esta bloquejat)
INFO: Informe generat en 812 ms: informes/multes-mensual.txt

[main] confirmat: informes/multes-mensual.txt

// Amb CompletableFuture: asincron, componible, i de lectura exigent.
CompletableFuture<Path> f = CompletableFuture
        .supplyAsync(() -> carregarCataleg(), poolEs)
        .thenApplyAsync(this::calcularMultes, poolCpu)
        .thenApplyAsync(this::exportar, poolEs)
        .exceptionally(this::reserva);

// Amb fils virtuals: codi SEQUENCIAL normal, amb try/catch normal,
// que bloqueja un fil virtual —el cost del qual es de nanosegons—.
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    executor.submit(() -> {
        Cataleg c = carregarCataleg();      // "bloqueja", pero es baratissim
        double m = calcularMultes(c);
        return exportar(m);
    });
}

Future<Cataleg> f1 = executor.submit(() -> carregarCataleg());
Cataleg c = f1.get();
Future<List<Prestec>> f2 = executor.submit(() -> carregarPrestecs(c));
List<Prestec> p = f2.get();
Future<Double> f3 = executor.submit(() -> calcularMultes(p));
double total = f3.get();
Future<Path> f4 = executor.submit(() -> exportar(total));
Path informe = f4.get();

package com.nexussoftware.bibliotech.servei;

import java.nio.file.Path;
import java.util.List;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;

public class CadenaInforme {

    private final ExecutorService poolEs;
    private final ExecutorService poolCpu;

    public CadenaInforme() {
        AtomicInteger a = new AtomicInteger(1);
        this.poolEs = Executors.newFixedThreadPool(8,
                r -> new Thread(r, "informe-es-" + a.getAndIncrement()));
        AtomicInteger b = new AtomicInteger(1);
        this.poolCpu = Executors.newFixedThreadPool(
                Runtime.getRuntime().availableProcessors(),
                r -> new Thread(r, "informe-cpu-" + b.getAndIncrement()));
    }

    // --- Operacions simulades ---

    private Cataleg carregarCataleg() {
        dormir(300);
        return new Cataleg();
    }

    /**
     * ASINCRONA: retorna un CompletableFuture, no un valor.
     * Per aixo s'encadena amb thenCompose i no amb thenApply.
     */
    private CompletableFuture<List<Prestec>> carregarPrestecsAsync(Cataleg c) {
        return CompletableFuture.supplyAsync(() -> {
            dormir(300);
            return List.<Prestec>of();
        }, poolEs);
    }

    private double calcularMultes(List<Prestec> p) {
        dormir(300);
        return 137.50;
    }

    private Path exportar(double total) {
        dormir(300);
        return Path.of("informes/multes.txt");
    }

    // --- VERSIO BLOCANT (l'original) ---

    public Path versioAmbFuture() throws Exception {
        ExecutorService ex = Executors.newFixedThreadPool(4);
        try {
            Future<Cataleg> f1 = ex.submit(this::carregarCataleg);
            Cataleg c = f1.get();                                  // BLOQUEJA

            Future<List<Prestec>> f2 = ex.submit(() -> {
                dormir(300); return List.<Prestec>of();
            });
            List<Prestec> p = f2.get();                            // BLOQUEJA

            Future<Double> f3 = ex.submit(() -> calcularMultes(p));
            double total = f3.get();                               // BLOQUEJA

            Future<Path> f4 = ex.submit(() -> exportar(total));
            return f4.get();                                       // BLOQUEJA
        } finally {
            ex.shutdown();
        }
    }

    // --- VERSIO ASINCRONA ---

    public CompletableFuture<Path> versioAmbCompletableFuture() {

        long inici = System.nanoTime();

        return CompletableFuture
                // 1. E/S: pool d'E/S
                .supplyAsync(this::carregarCataleg, poolEs)

                // 2. thenCompose perque carregarPrestecsAsync retorna
                //    un CompletableFuture. Amb thenApply obtindriem
                //    CompletableFuture<CompletableFuture<List<Prestec>>>.
                .thenCompose(this::carregarPrestecsAsync)

                // 3. CPU: pool de calcul
                .thenApplyAsync(this::calcularMultes, poolCpu)

                // 4. E/S: pool d'E/S
                .thenApplyAsync(this::exportar, poolEs)

                // 5. Termini global
                .orTimeout(20, TimeUnit.SECONDS)

                // 6. Observar sense alterar
                .whenComplete((cami, error) -> {
                    long ms = (System.nanoTime() - inici) / 1_000_000;
                    System.out.printf("  [cadena] acabada en %d ms (%s)%n",
                            ms, error == null ? "OK" : "ERROR");
                })

                // 7. Gestionar al FINAL: cobreix totes les etapes anteriors
                .exceptionally(error -> {
                    System.err.println("  [cadena] fallada: " + causaDe(error).getMessage());
                    return Path.of("informes/no-disponible.txt");
                });
    }

    static Throwable causaDe(Throwable t) {
        return (t instanceof CompletionException || t instanceof ExecutionException)
                && t.getCause() != null ? t.getCause() : t;
    }

    static void dormir(long ms) {
        try { TimeUnit.MILLISECONDS.sleep(ms); }
        catch (InterruptedException e) { Thread.currentThread().interrupt(); }
    }

    public void tancar() {
        poolEs.shutdown();
        poolCpu.shutdown();
    }

    public static void main(String[] args) throws Exception {
        CadenaInforme ci = new CadenaInforme();
        try {
            System.out.println("=== VERSIO AMB FUTURE (blocant) ===");
            long t1 = System.nanoTime();
            Path p1 = ci.versioAmbFuture();
            long ms1 = (System.nanoTime() - t1) / 1_000_000;
            System.out.println("  resultat: " + p1 + "  (" + ms1 + " ms)");
            System.out.println("  el fil main ha estat bloquejat 4 vegades\n");

            System.out.println("=== VERSIO AMB COMPLETABLEFUTURE ===");
            long t2 = System.nanoTime();
            CompletableFuture<Path> f = ci.versioAmbCompletableFuture();
            long msDeclaracio = (System.nanoTime() - t2) / 1_000_000;
            System.out.println("  cadena declarada en " + msDeclaracio + " ms");
            System.out.println("  el fil main continua lliure; faig altres coses...");

            for (int i = 1; i <= 5; i++) {
                System.out.println("    feina del main " + i);
                TimeUnit.MILLISECONDS.sleep(150);
            }

            Path p2 = f.get(20, TimeUnit.SECONDS);
            long ms2 = (System.nanoTime() - t2) / 1_000_000;
            System.out.println("  resultat: " + p2 + "  (" + ms2 + " ms)");
        } finally {
            ci.tancar();
        }
    }
}

=== VERSIO AMB FUTURE (blocant) ===
  resultat: informes/multes.txt  (1214 ms)
  el fil main ha estat bloquejat 4 vegades

=== VERSIO AMB COMPLETABLEFUTURE ===
  cadena declarada en 3 ms
  el fil main continua lliure; faig altres coses...
    feina del main 1
    feina del main 2
    feina del main 3
    feina del main 4
    feina del main 5
  [cadena] acabada en 1208 ms (OK)
  resultat: informes/multes.txt  (1211 ms)

package com.nexussoftware.bibliotech.servei;

import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;

public class ServeiFitxes implements AutoCloseable {

    record DadesMaterial(String titol, String autor, String isbn) {
        static DadesMaterial desconegut(String isbn) {
            return new DadesMaterial("(titol no disponible)", "(autor desconegut)", isbn);
        }
    }

    record FitxaCompleta(DadesMaterial material, int prestecs, double valoracio) {
        static FitxaCompleta minima(String isbn) {
            return new FitxaCompleta(DadesMaterial.desconegut(isbn), -1, -1.0);
        }
        @Override public String toString() {
            return String.format("%s / %s [%s] - %s prestecs - valoracio %s",
                    material.titol(), material.autor(), material.isbn(),
                    prestecs < 0 ? "?" : prestecs,
                    valoracio < 0 ? "?" : String.format("%.1f", valoracio));
        }
    }

    private final ExecutorService pool;
    private final boolean fallarValoracions;

    public ServeiFitxes(boolean fallarValoracions) {
        this.fallarValoracions = fallarValoracions;
        AtomicInteger n = new AtomicInteger(1);
        this.pool = Executors.newFixedThreadPool(8,
                r -> new Thread(r, "fitxes-" + n.getAndIncrement()));
    }

    // --- Les tres consultes, cadascuna amb la seva reserva ---

    private CompletableFuture<DadesMaterial> consultarMaterial(String isbn) {
        return CompletableFuture.supplyAsync(() -> {
            dormir(400);
            return new DadesMaterial("Java Eficac", "J. Bloch", isbn);
        }, pool)
        // Reserva INDIVIDUAL: si aquesta consulta falla, el conjunt
        // continua endavant amb un valor degradat.
        .exceptionally(e -> {
            System.err.println("  [reserva] material no disponible: " + causaDe(e).getMessage());
            return DadesMaterial.desconegut(isbn);
        });
    }

    private CompletableFuture<Integer> consultarPrestecs(String isbn) {
        return CompletableFuture.supplyAsync(() -> {
            dormir(600);                       // la mes lenta: marca el total
            return 47;
        }, pool)
        .exceptionally(e -> -1);
    }

    private CompletableFuture<Double> consultarValoracio(String isbn) {
        return CompletableFuture.supplyAsync(() -> {
            dormir(300);
            if (fallarValoracions) {
                throw new IllegalStateException("servei de valoracions caigut");
            }
            return 4.6;
        }, pool)
        .exceptionally(e -> {
            System.err.println("  [reserva] valoracio no disponible: "
                    + causaDe(e).getMessage());
            return -1.0;
        });
    }

    // --- La combinacio ---

    public CompletableFuture<FitxaCompleta> fitxaCompleta(String isbn) {

        // Les TRES es llancen alhora: l'assignacio ja dispara la feina.
        CompletableFuture<DadesMaterial> material  = consultarMaterial(isbn);
        CompletableFuture<Integer>       prestecs  = consultarPrestecs(isbn);
        CompletableFuture<Double>        valoracio = consultarValoracio(isbn);

        return material
                // thenCombine encadenat: primer material+prestecs...
                .thenCombine(prestecs, (m, p) -> new Object[] { m, p })
                // ...i despres el parell amb la valoracio.
                .thenCombine(valoracio, (parell, v) -> new FitxaCompleta(
                        (DadesMaterial) parell[0], (Integer) parell[1], v))
                // Si el conjunt triga massa, fitxa minima en lloc de fallada.
                .completeOnTimeout(FitxaCompleta.minima(isbn), 2, TimeUnit.SECONDS);
    }

    static Throwable causaDe(Throwable t) {
        return (t instanceof CompletionException || t instanceof ExecutionException)
                && t.getCause() != null ? t.getCause() : t;
    }

    static void dormir(long ms) {
        try { TimeUnit.MILLISECONDS.sleep(ms); }
        catch (InterruptedException e) { Thread.currentThread().interrupt(); }
    }

    @Override public void close() { pool.shutdown(); }

    public static void main(String[] args) throws Exception {

        System.out.println("=== CAS NORMAL ===");
        try (ServeiFitxes s = new ServeiFitxes(false)) {
            long t = System.nanoTime();
            FitxaCompleta f = s.fitxaCompleta("978-0000000001").get();
            System.out.println("  " + f);
            System.out.printf("  temps: %d ms (sequencial serien 1300)%n",
                    (System.nanoTime() - t) / 1_000_000);
        }

        System.out.println("\n=== AMB EL SERVEI DE VALORACIONS CAIGUT ===");
        try (ServeiFitxes s = new ServeiFitxes(true)) {
            long t = System.nanoTime();
            FitxaCompleta f = s.fitxaCompleta("978-0000000001").get();
            System.out.println("  " + f);
            System.out.printf("  temps: %d ms%n", (System.nanoTime() - t) / 1_000_000);
            System.out.println("  La fitxa es construeix igual: degradacio, no fallada (06-07).");
        }
    }
}

=== CAS NORMAL ===
  Java Eficac / J. Bloch [978-0000000001] - 47 prestecs - valoracio 4.6
  temps: 612 ms (sequencial serien 1300)

=== AMB EL SERVEI DE VALORACIONS CAIGUT ===
  [reserva] valoracio no disponible: servei de valoracions caigut
  Java Eficac / J. Bloch [978-0000000001] - 47 prestecs - valoracio ?
  temps: 608 ms
  La fitxa es construeix igual: degradacio, no fallada (06-07).

package com.nexussoftware.bibliotech.servei;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.LongAdder;

public class EnviamentAvisosAsincron implements AutoCloseable {

    record Avis(String id, String empleat) { }

    record ResultatAvis(String id, boolean correcte, String detall) {
        static ResultatAvis exit(Avis a) {
            return new ResultatAvis(a.id(), true, "enviat");
        }
        static ResultatAvis fallada(Avis a, String motiu) {
            return new ResultatAvis(a.id(), false, motiu);
        }
    }

    record ResumEnviament(int total, int enviats, int fallits, long ms) {
        double percentatge() { return total == 0 ? 0 : 100.0 * enviats / total; }
    }

    private final ExecutorService poolEs;
    private final LongAdder completats = new LongAdder();

    public EnviamentAvisosAsincron() {
        AtomicInteger n = new AtomicInteger(1);
        this.poolEs = new ThreadPoolExecutor(
                16, 16, 0L, TimeUnit.MILLISECONDS,
                new ArrayBlockingQueue<>(300),
                r -> new Thread(r, "bibliotech-avis-" + n.getAndIncrement()),
                new ThreadPoolExecutor.CallerRunsPolicy());
    }

    /** Enviament individual: 250 ms d'E/S i fallada simulada en alguns. */
    private ResultatAvis enviar(Avis a) {
        try {
            TimeUnit.MILLISECONDS.sleep(250);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new CompletionException(e);
        }
        if (a.id().hashCode() % 29 == 0) {
            throw new IllegalStateException("empleat sense adreca de contacte");
        }
        return ResultatAvis.exit(a);
    }

    /** La cadena completa. Retorna immediatament. */
    public CompletableFuture<ResumEnviament> enviarTots(List<Avis> avisos) {

        long inici = System.nanoTime();
        final int total = avisos.size();

        // 1-2. Un futur per avis, BLINDAT amb el seu propi exceptionally.
        //      Sense aquest blindatge, una sola fallada faria fallar tot l'allOf.
        List<CompletableFuture<ResultatAvis>> futurs = new ArrayList<>(total);
        for (Avis a : avisos) {
            futurs.add(CompletableFuture
                    .supplyAsync(() -> enviar(a), poolEs)
                    .exceptionally(e -> ResultatAvis.fallada(a, causaDe(e).getMessage()))
                    // Es compta en acabar, amb exit o amb fallada:
                    // aixi el main pot mostrar progres sense bloquejar-se.
                    .whenComplete((r, e) -> completats.increment()));
        }

        // 3. Agregar.
        CompletableFuture<Void> tots =
                CompletableFuture.allOf(futurs.toArray(new CompletableFuture[0]));

        return tots
                // 4. Recollir i resumir.
                .thenApply(v -> {
                    int ok = 0, ko = 0;
                    for (CompletableFuture<ResultatAvis> f : futurs) {
                        // join() no bloqueja: allOf garanteix que estan complets.
                        if (f.join().correcte()) ok++; else ko++;
                    }
                    return new ResumEnviament(total, ok, ko,
                            (System.nanoTime() - inici) / 1_000_000);
                })
                // 5. Termini global i gestor final.
                .orTimeout(60, TimeUnit.SECONDS)
                .exceptionally(e -> {
                    System.err.println("Enviament massiu fallit: " + causaDe(e).getMessage());
                    return new ResumEnviament(total, 0, total,
                            (System.nanoTime() - inici) / 1_000_000);
                });
    }

    public long completats() { return completats.sum(); }

    static Throwable causaDe(Throwable t) {
        return (t instanceof CompletionException || t instanceof ExecutionException)
                && t.getCause() != null ? t.getCause() : t;
    }

    @Override public void close() {
        poolEs.shutdown();
        try {
            if (!poolEs.awaitTermination(30, TimeUnit.SECONDS)) poolEs.shutdownNow();
        } catch (InterruptedException e) {
            poolEs.shutdownNow();
            Thread.currentThread().interrupt();
        }
    }

    public static void main(String[] args) throws Exception {

        List<Avis> avisos = new ArrayList<>();
        for (int i = 1; i <= 200; i++) {
            avisos.add(new Avis("AV-" + i, "empleat-" + (i % 20)));
        }

        try (EnviamentAvisosAsincron servei = new EnviamentAvisosAsincron()) {

            System.out.println("=== ENVIAMENT ASINCRON DE 200 AVISOS ===");
            System.out.println("Sequencial serien " + (200 * 250 / 1000) + " s\n");

            // 6. La cadena es declara i retorna: main NO es bloqueja.
            CompletableFuture<ResumEnviament> cadena = servei.enviarTots(avisos);

            // Progres, llegint el LongAdder que les tasques incrementen.
            while (!cadena.isDone()) {
                long fets = servei.completats();
                System.out.printf("\r  [%s] %d/200 (%.0f%%)",
                        barra(fets, 200), fets, 100.0 * fets / 200);
                TimeUnit.MILLISECONDS.sleep(250);
            }

            ResumEnviament r = cadena.get();
            System.out.printf("\r  [%s] 200/200 (100%%)%n%n", barra(200, 200));
            System.out.println("=== RESUM ===");
            System.out.println("Total     : " + r.total());
            System.out.println("Enviats   : " + r.enviats());
            System.out.println("Fallits   : " + r.fallits());
            System.out.println("Temps     : " + r.ms() + " ms");
            System.out.printf ("Exit      : %.1f%%%n", r.percentatge());
            System.out.printf ("Acceleracio: %.1fx%n", 200 * 250.0 / r.ms());
        }
    }

    static String barra(long fets, long total) {
        int amplada = 30;
        int plens = (int) (amplada * fets / total);
        return "#".repeat(plens) + "-".repeat(amplada - plens);
    }
}

=== ENVIAMENT ASINCRON DE 200 AVISOS ===
Sequencial serien 50 s

  [##############################] 200/200 (100%)

=== RESUM ===
Total     : 200
Enviats   : 193
Fallits   : 7
Temps     : 3387 ms
Exit      : 96.5%
Acceleracio: 14.8x