// EL QUE FEIES: un fil per tasca, gestio manual completa.
Thread[] fils = new Thread[200];
for (int i = 0; i < 200; i++) {
    fils[i] = new Thread(new TascaAvis(avisos.get(i)), "bibliotech-avisos-" + i);
    fils[i].start();
}
for (Thread f : fils) {
    f.join();
}
// I el resultat de cada tasca? Camps volatile i llegir-los a ma.
// I si una falla? Un gestor d'excepcions no capturades.
// I si vull cancellar-ho tot? interrupt() als 200, un per un.
// I si son 200.000 avisos? OutOfMemoryError.

// EL QUE FARAS: descriure tasques, l'executor les colloca.
ExecutorService executor = Executors.newFixedThreadPool(8);
List<Future<ResultatAvis>> futurs = new ArrayList<>();

for (Avis a : avisos) {
    futurs.add(executor.submit(new TascaAvis(a)));   // Callable: retorna valor
}

for (Future<ResultatAvis> f : futurs) {
    ResultatAvis r = f.get();   // espera, i RELLANCA l'excepcio si n'hi va haver
}

executor.shutdown();

// La interficie completa. Un sol metode.
public interface Executor {
    void execute(Runnable ordre);
}

// Tres implementacions valides de la MATEIXA interficie:
Executor alMateixFil    = tasca -> tasca.run();
Executor unFilNou       = tasca -> new Thread(tasca).start();
Executor unPool         = Executors.newFixedThreadPool(8);

// El codi client no canvia:
alMateixFil.execute(() -> System.out.println("hola"));
unPool.execute(() -> System.out.println("hola"));

public interface ExecutorService extends Executor {

    // Enviar tasques i obtenir un Future
    Future<?> submit(Runnable tasca);
    <T> Future<T> submit(Callable<T> tasca);
    <T> Future<T> submit(Runnable tasca, T resultat);

    // Enviar-ne diverses
    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasques);
    <T> T invokeAny(Collection<? extends Callable<T>> tasques);

    // Apagada
    void shutdown();
    List<Runnable> shutdownNow();
    boolean isShutdown();
    boolean isTerminated();
    boolean awaitTermination(long temps, TimeUnit unitat);
}

// execute(Runnable): no retorna res. Si la tasca llanca una excepcio,
// va al gestor d'excepcions no capturades del fil (08-02) i
// normalment s'imprimeix a la consola.
executor.execute(() -> { throw new RuntimeException("fallada visible"); });

// submit(...): retorna un Future. Si la tasca llanca una excepcio,
// aquesta es DESA al Future i NO s'imprimeix enlloc.
// Si ningu no crida get(), la fallada desapareix SENSE DEIXAR RASTRE.
executor.submit(() -> { throw new RuntimeException("fallada INVISIBLE"); });

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;

// 1. Pool FIX: N fils, sempre els mateixos, cua illimitada.
ExecutorService fix = Executors.newFixedThreadPool(8);

// 2. Pool ELASTIC: crea fils segons necessitat, els recicla als 60 s.
ExecutorService elastic = Executors.newCachedThreadPool();

// 3. UN SOL FIL: garanteix ordre d'execucio.
ExecutorService unic = Executors.newSingleThreadExecutor();

// 4. PROGRAMAT: tasques retardades i periodiques.
ScheduledExecutorService programat = Executors.newScheduledThreadPool(2);

// 5. ROBATORI DE FEINA: ForkJoinPool amb parallelisme = nuclis.
ExecutorService robatori = Executors.newWorkStealingPool();

// Enviament d'avisos: E/S, carrega acotada i coneguda -> pool fix.
ExecutorService avisos = Executors.newFixedThreadPool(8);

// Escriptura del log d'auditoria: HA de conservar l'ordre -> un sol fil.
// A mes, en ser un unic fil, no cal sincronitzar el fitxer.
ExecutorService auditoria = Executors.newSingleThreadExecutor();

// Avis de venciments cada hora i copia de seguretat cada nit.
ScheduledExecutorService manteniment = Executors.newScheduledThreadPool(2);

// BOMBA DE RELLOTGERIA
ExecutorService pool = Executors.newFixedThreadPool(4);

// Cada tasca triga 100 ms; n'arriben 1.000 per segon.
// El pool en processa 40/s. S'acumulen 960 tasques per segon en memoria.
// En 10 minuts: ~576.000 objectes en cua. OutOfMemoryError.
while (hiHaPeticions()) {
    pool.submit(new TascaLenta(seguentPeticio()));
}

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

public class ExecutorBiblioTech {

    /**
     * ThreadFactory que posa nom als fils. Sense ella, els fils del pool
     * s'anomenen "pool-1-thread-1", que en un bolcat (08-03) no diu res.
     */
    static class FabricaFilsAnomenats implements ThreadFactory {
        private final String prefix;
        private final boolean dimoni;
        private final AtomicInteger comptador = new AtomicInteger(1);

        FabricaFilsAnomenats(String prefix, boolean dimoni) {
            this.prefix = prefix;
            this.dimoni = dimoni;
        }

        @Override
        public Thread newThread(Runnable r) {
            Thread t = new Thread(r, prefix + "-" + comptador.getAndIncrement());
            t.setDaemon(dimoni);
            // Xarxa de seguretat: qualsevol excepcio que escapi d'una tasca
            // enviada amb execute() queda registrada (06-07, 08-02).
            t.setUncaughtExceptionHandler((fil, error) ->
                    System.err.println("[" + fil.getName() + "] fallada no capturada: " + error));
            return t;
        }
    }

    public static ThreadPoolExecutor crear() {
        return new ThreadPoolExecutor(
                4,                                    // 1. mida del nucli
                8,                                    // 2. mida maxima
                60L, TimeUnit.SECONDS,                // 3. vida dels fils extra
                new ArrayBlockingQueue<>(100),        // 4. cua ACOTADA
                new FabricaFilsAnomenats("bibliotech-avisos", false),     // 5.
                new ThreadPoolExecutor.CallerRunsPolicy()                 // 6.
        );
    }
}

public class DimensionamentPool {

    private static final int NUCLIS = Runtime.getRuntime().availableProcessors();

    /** Calcul pur: mes fils que nuclis nomes afegeix canvis de context. */
    public static int perCalcul() {
        return NUCLIS;
    }

    /**
     * E/S: la formula de Brian Goetz.
     *   fils = nuclis * utilitzacioObjectiu * (1 + espera / calcul)
     * Amb utilitzacio 1.0, 300 ms d'espera i 20 ms de calcul en 8 nuclis:
     *   8 * 1.0 * (1 + 15) = 128 fils.
     * A la practica s'acota a un maxim raonable: 128 fils son 128 MB
     * de piles, i el recurs remot probablement no aguanti 128 peticions.
     */
    public static int perEs(double msEspera, double msCalcul) {
        double ratio = msEspera / msCalcul;
        int suggerit = (int) Math.ceil(NUCLIS * (1 + ratio));
        return Math.min(suggerit, 64);       // sostre de seny
    }

    public static void main(String[] args) {
        System.out.println("Nuclis              : " + NUCLIS);
        System.out.println("Pool de calcul      : " + perCalcul());
        System.out.println("Pool d'avisos       : " + perEs(300, 20));
        System.out.println("Pool d'importacio   : " + perEs(50, 30));
    }
}

// BE: tres pools amb propositos i mides diferents, i aillats
// entre si: una saturacio del pool d'avisos no afecta el de calcul.
private final ExecutorService poolCalcul = Executors.newFixedThreadPool(NUCLIS);
private final ExecutorService poolEs     = Executors.newFixedThreadPool(32);
private final ScheduledExecutorService poolProgramat =
        Executors.newScheduledThreadPool(2);

import java.util.concurrent.ExecutorService;
import java.util.concurrent.TimeUnit;

public final class AturadaOrdenada {

    /**
     * Aturada en dues fases:
     *   1. shutdown() + espera cortes: deixar acabar el que esta en curs.
     *   2. Si no acaben, shutdownNow() (interrupcio) + espera curta.
     *   3. Si tot i aixi no acaben, registrar-ho: hi ha tasques que no
     *      responen a la interrupcio, i aixo es un BUG d'aquestes tasques
     *      (el catch buit d'InterruptedException de 08-02).
     */
    public static void aturar(ExecutorService executor, long segons) {
        executor.shutdown();                     // fase 1: no accepta mes
        try {
            if (!executor.awaitTermination(segons, TimeUnit.SECONDS)) {
                executor.shutdownNow();          // fase 2: interrompre
                if (!executor.awaitTermination(segons, TimeUnit.SECONDS)) {
                    System.err.println("L'executor no ha acabat: "
                            + "hi ha tasques que ignoren la interrupcio");
                }
            }
        } catch (InterruptedException e) {
            // Ens han interromput a NOSALTRES mentre esperavem.
            executor.shutdownNow();
            Thread.currentThread().interrupt();  // restaurar el marcador (08-02)
        }
    }
}

@FunctionalInterface
public interface Callable<V> {
    V call() throws Exception;      // retorna V i POT llancar
}

public interface Future<V> {
    V get() throws InterruptedException, ExecutionException;
    V get(long temps, TimeUnit unitat) throws ..., TimeoutException;
    boolean cancel(boolean interrompreSiEstaCorrent);
    boolean isCancelled();
    boolean isDone();
}

package com.nexussoftware.bibliotech.persistencia;

import java.nio.file.Path;
import java.util.concurrent.*;

public class ImportacioAmbFuture {

    public static void main(String[] args) {

        ExecutorService executor = Executors.newFixedThreadPool(2);
        try {
            // Callable<Informe>: retorna un Informe i pot llancar
            // excepcions comprovades. Totes dues coses impossibles amb Runnable.
            Callable<Informe> tasca = () -> {
                ImportadorCataleg imp = new ImportadorCataleg();
                return imp.importar(Path.of("dades/inventari.csv"));   // throws IOException
            };

            Future<Informe> futur = executor.submit(tasca);

            // El fil principal NO esta bloquejat: pot continuar treballant.
            System.out.println("[main] importacio llancada, atenc el menu");
            mostrarMenu();

            // isDone() no bloqueja: permet sondejar sense esperar.
            while (!futur.isDone()) {
                System.out.println("[main] important...");
                TimeUnit.MILLISECONDS.sleep(500);
            }

            // get() amb TERMINI: no facis servir mai get() sense termini en produccio.
            Informe informe = futur.get(30, TimeUnit.SECONDS);
            System.out.println("[main] importats: " + informe.importats());

        } catch (TimeoutException e) {
            System.err.println("[main] la importacio ha excedit el termini");

        } catch (ExecutionException e) {
            // La tasca ha llancat una excepcio. get() l'EMBOLCALLA en
            // ExecutionException; l'original es a getCause().
            // Es exactament l'encadenament de causes de 06-03.
            Throwable causa = e.getCause();
            System.err.println("[main] la importacio ha fallat: " + causa.getMessage());
            if (causa instanceof java.io.IOException) {
                System.err.println("[main] problema de fitxer; es conserva el cataleg anterior");
            }

        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();

        } finally {
            AturadaOrdenada.aturar(executor, 10);
        }
    }

    static void mostrarMenu() { /* ... */ }
}

try {
    Informe i = futur.get(30, TimeUnit.SECONDS);
} catch (ExecutionException e) {
    Throwable causa = e.getCause();
    // Recuperar el tipus original per aplicar la politica de 06-07
    if (causa instanceof FormatInvalidException fie) {
        registrarIDegradar(fie);
    } else if (causa instanceof java.io.IOException ioe) {
        avortarAmbCodi(ioe);
    } else {
        throw new BiblioTechException("Fallada inesperada a la importacio", causa);
    }
}

Future<Informe> futur = executor.submit(tasca);

// cancel(false): nomes evita que COMENCI si encara es a la cua.
// Si ja esta corrent, la deixa acabar.
futur.cancel(false);

// cancel(true): a mes, INTERROMP el fil que l'executa.
// Es literalment un fil.interrupt() sobre el fil del pool.
futur.cancel(true);

/**
 * Tasca cancellable dins d'un pool. Identica al patro de 08-02:
 * cancel(true) del Future es tradueix en interrupt() sobre aquest fil.
 */
public class TascaAvisCancellable implements Callable<ResultatAvis> {

    private final Avis avis;

    public TascaAvisCancellable(Avis avis) { this.avis = avis; }

    @Override
    public ResultatAvis call() throws Exception {
        for (int intent = 1; intent <= 3; intent++) {

            // Punt de cancellacio a cada volta.
            if (Thread.currentThread().isInterrupted()) {
                throw new InterruptedException("avis cancellat abans de l'intent " + intent);
            }
            try {
                enviar(avis);                        // pot llancar InterruptedException
                return ResultatAvis.exit(avis);
            } catch (EnviamentFallitException e) {
                if (intent == 3) {
                    return ResultatAvis.fallada(avis, e.getMessage());
                }
                TimeUnit.MILLISECONDS.sleep(100L * intent);   // retroces
            }
        }
        return ResultatAvis.fallada(avis, "reintents exhaurits");
    }

    private void enviar(Avis a) throws Exception { /* ... */ }
}

Future<Informe> f = executor.submit(tasca);
TimeUnit.SECONDS.sleep(2);

boolean cancellada = f.cancel(true);
System.out.println("cancel() retorna  : " + cancellada);   // false si ja havia acabat
System.out.println("isCancelled()     : " + f.isCancelled());
System.out.println("isDone()          : " + f.isDone());   // true: cancellada tambe es "feta"

try {
    f.get();
} catch (CancellationException e) {
    // get() sobre un Future CANCELLAT llanca CancellationException,
    // que es NO comprovada. Es facil oblidar-se de capturar-la.
    System.out.println("confirmat: la tasca ha estat cancellada");
}

List<Callable<ResultatAvis>> tasques = new ArrayList<>();
for (Avis a : avisos) {
    tasques.add(new TascaAvisCancellable(a));
}

// Bloqueja fins que TOTES acabin. Els Future retornats
// ja estan complets: get() no bloqueja.
List<Future<ResultatAvis>> resultats = executor.invokeAll(tasques);

int exits = 0, fallades = 0;
for (Future<ResultatAvis> f : resultats) {
    try {
        if (f.get().correcte()) exits++; else fallades++;
    } catch (ExecutionException e) {
        fallades++;
        LOG.log(Level.WARNING, "avis fallit", e.getCause());
    }
}

// Termini GLOBAL per al conjunt. Les que no acabin a temps
// es CANCELLEN automaticament, i el seu get() llancara CancellationException.
List<Future<ResultatAvis>> resultats =
        executor.invokeAll(tasques, 30, TimeUnit.SECONDS);

// Tres fonts per al mateix cataleg; ens val la primera que respongui.
List<Callable<Cataleg>> fonts = List.of(
        () -> carregarDesDeCacheLocal(),
        () -> carregarDesDelFitxerPrincipal(),
        () -> carregarDesDeCopiaSeguretat()
);

// Retorna el primer resultat correcte; cancella els altres dos.
// Si TOTES fallen, llanca ExecutionException amb l'ultima causa.
Cataleg c = executor.invokeAny(fonts, 10, TimeUnit.SECONDS);

import java.util.concurrent.*;

public class MantenimentBiblioTech {

    private final ScheduledExecutorService programador =
            Executors.newScheduledThreadPool(2, r -> {
                Thread t = new Thread(r, "bibliotech-programador");
                t.setDaemon(true);      // manteniment: no ha d'impedir el tancament
                return t;
            });

    public void arrencar() {

        // 1. UNA vegada, d'aqui a 5 segons.
        programador.schedule(
                () -> System.out.println("[manteniment] arrencada completada"),
                5, TimeUnit.SECONDS);

        // 2. PERIODICA a ritme fix: cada hora des de l'instant d'inici.
        programador.scheduleAtFixedRate(
                this::avisarVenciments,
                0, 1, TimeUnit.HOURS);

        // 3. PERIODICA amb retard fix: 24 h des que ACABA l'anterior.
        programador.scheduleWithFixedDelay(
                this::copiaSeguretat,
                1, 24, TimeUnit.HOURS);
    }

    /**
     * REGLA D'OR: una tasca periodica ha de capturar TOTA excepcio.
     * Si en deixa escapar una, la JVM CANCELLA la planificacio i la tasca
     * NO ES TORNA A EXECUTAR MAI, en silenci, sense cap avis.
     * Es la fallada mes traidora d'aquesta API.
     */
    private void avisarVenciments() {
        try {
            int enviats = serveiAvisos.enviarVenciments();
            LOG.log(Level.INFO, "Avisos de venciment enviats: {0}", enviats);
        } catch (Exception e) {
            LOG.log(Level.SEVERE, "Fallada en avisar dels venciments", e);
            // NO rellancar: si surt, s'acaba la planificacio per sempre.
        }
    }

    private void copiaSeguretat() {
        try {
            gestorCopies.copiar();
        } catch (Exception e) {
            LOG.log(Level.SEVERE, "Fallada a la copia de seguretat", e);
        }
    }
}

Tasca que dura 3 s, periode 5 s:

scheduleAtFixedRate:   [---3s---]__2s__[---3s---]__2s__[---3s---]
                       0         3     5         8     10
                       inici cada 5 s exactes

scheduleWithFixedDelay:[---3s---]____5s____[---3s---]____5s____[--
                       0         3         8         11        16
                       5 s DESPRES d'acabar

CountDownLatch tancament = new CountDownLatch(5);   // 5 esdeveniments pendents

tancament.countDown();          // resta 1 (mai per sota de 0)
tancament.await();              // bloqueja fins a arribar a 0
tancament.await(10, TimeUnit.SECONDS);   // amb termini; retorna false si expira
tancament.getCount();           // compte actual (per mostrar el progres)

import java.util.concurrent.*;

public class EsperarNTasques {

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

        final int TASQUES = 200;
        ExecutorService pool = Executors.newFixedThreadPool(8);
        CountDownLatch acabades = new CountDownLatch(TASQUES);

        for (int i = 0; i < TASQUES; i++) {
            final int n = i;
            pool.execute(() -> {
                try {
                    enviarAvis(n);
                } catch (Exception e) {
                    LOG.log(Level.WARNING, "avis " + n + " fallit", e);
                } finally {
                    // OBLIGATORI al finally: si una tasca falla i no
                    // fa countDown, l'await() de main no torna MAI.
                    acabades.countDown();
                }
            });
        }

        // Progres mentre esperem, sense sondejar amb sleep a cegues.
        while (!acabades.await(500, TimeUnit.MILLISECONDS)) {
            long pendents = acabades.getCount();
            System.out.printf("\rProgres: %d/%d (%.0f%%)",
                    TASQUES - pendents, TASQUES,
                    100.0 * (TASQUES - pendents) / TASQUES);
        }
        System.out.println("\nTots els avisos processats");
        AturadaOrdenada.aturar(pool, 10);
    }
}

/**
 * Dos tancaments: un per donar la sortida a tots alhora, l'altre per
 * esperar que tots acabin. Es l'esquelet d'una prova d'estres
 * de concurrencia ben feta: sense la porta, els primers fils
 * acabarien abans que arrenquessin els ultims, i no hi hauria
 * solapament real (l'efecte que vas veure a l'exercici 2 de 08-01).
 */
public static long provaEstres(int fils, Runnable tasca) throws InterruptedException {

    CountDownLatch sortida = new CountDownLatch(1);       // la pistola
    CountDownLatch acabats = new CountDownLatch(fils);    // la meta

    for (int i = 0; i < fils; i++) {
        new Thread(() -> {
            try {
                sortida.await();     // tots esperen aqui
                tasca.run();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            } finally {
                acabats.countDown();
            }
        }, "estres-" + i).start();
    }

    long inici = System.nanoTime();
    sortida.countDown();             // ja! els N arrenquen alhora
    acabats.await();
    return System.nanoTime() - inici;
}

import java.util.concurrent.*;

public class ProcessamentPerFases {

    public static void main(String[] args) {

        final int TREBALLADORS = 4;

        // L'accio de barrera l'executa l'ULTIM fil a arribar,
        // abans d'alliberar els altres. Ideal per consolidar la fase.
        CyclicBarrier barrera = new CyclicBarrier(TREBALLADORS, () ->
                System.out.println("--- fase completada pels 4, consolidant ---"));

        for (int i = 0; i < TREBALLADORS; i++) {
            final int id = i;
            new Thread(() -> {
                try {
                    for (int fase = 1; fase <= 3; fase++) {
                        System.out.printf("  treballador %d processa la fase %d%n", id, fase);
                        TimeUnit.MILLISECONDS.sleep(100 + id * 50);
                        barrera.await();      // espera els altres tres
                    }
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                } catch (BrokenBarrierException e) {
                    // Si un fil s'interromp o expira, la barrera es TRENCA
                    // i TOTS els altres reben aquesta excepcio. Es correcte:
                    // sense tots els participants, la fase no te sentit.
                    System.err.println("barrera trencada: " + e);
                }
            }, "treballador-" + i).start();
        }
    }
}

package com.nexussoftware.bibliotech.servei;

import java.util.concurrent.*;

/**
 * Limita a 3 les exportacions simultanies.
 *
 * Motiu: cada exportacio obre el fitxer complet del cataleg, el
 * formata en memoria i l'escriu. Tres alhora saturen el disc i
 * multipliquen l'us de memoria; amb vint, el servidor s'arrossega.
 * El semafor posa un sostre dur sense limitar la resta del pool.
 */
public class ServeiExportacio {

    private static final int MAX_SIMULTANIES = 3;

    // 3 permisos. El 'true' activa l'equitat: els que porten mes temps
    // esperant passen abans, cosa que evita la inanicio (08-04).
    private final Semaphore permisos = new Semaphore(MAX_SIMULTANIES, true);

    private final ExecutorService pool = Executors.newFixedThreadPool(16);

    public Future<Path> exportar(String format) {
        return pool.submit(() -> {

            // Espera un permis. Si hi ha 3 exportacions en curs, aquest
            // fil es bloqueja aqui fins que una acabi.
            permisos.acquire();
            try {
                System.out.printf("[%s] exportant (%d permisos lliures)%n",
                        Thread.currentThread().getName(),
                        permisos.availablePermits());
                return generarFitxer(format);        // feina pesada
            } finally {
                // OBLIGATORI al finally: un permis no retornat es
                // perd PER SEMPRE. Despres de tres fallades, el semafor
                // queda a 0 i ningu no torna a exportar mai.
                permisos.release();
            }
        });
    }

    /** Variant que no espera: rebutja en lloc d'encuar. */
    public Future<Path> exportarSenseEsperar(String format) {
        return pool.submit(() -> {
            if (!permisos.tryAcquire(5, TimeUnit.SECONDS)) {
                throw new ServeiSaturatException(
                        "Hi ha " + MAX_SIMULTANIES + " exportacions en curs; reintenteu-ho");
            }
            try {
                return generarFitxer(format);
            } finally {
                permisos.release();
            }
        });
    }

    private Path generarFitxer(String format) throws Exception {
        TimeUnit.SECONDS.sleep(2);
        return Path.of("informes/cataleg." + format);
    }
}

Exchanger<List<Material>> intercanvi = new Exchanger<>();

// Fil lector: omple una memoria intermedia i la intercanvia per una buida.
List<Material> memoriaPropia = new ArrayList<>();
// ... omplir ...
memoriaPropia = intercanvi.exchange(memoriaPropia);   // rep la buida de l'altre

// Fil processador: processa una plena i en retorna una de buida.
List<Material> aProcessar = intercanvi.exchange(new ArrayList<>());

package com.nexussoftware.bibliotech.servei;

import java.util.List;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveTask;

/**
 * Calcula la suma de multes d'una llista de prestecs dividint
 * la feina recursivament.
 *
 * RecursiveTask<Double>: el <Double> es el tipus del resultat
 * que produeix aquesta tasca (10-01 per als generics).
 */
public class CalculMultesParallel extends RecursiveTask<Double> {

    /**
     * LLINDAR: per sota d'aquesta mida es calcula directament.
     * Triar-lo be es el mes important de tot el patro:
     *  - massa baix: el cost de crear i coordinar subtasques
     *    supera el del calcul, i va MES LENT que en sequencial;
     *  - massa alt: no hi ha prou trossos per a tots els nuclis.
     * Regla practica: entre 100 i 10.000 elements, i MESURAR.
     */
    private static final int LLINDAR = 1_000;

    private final List<Prestec> prestecs;
    private final int des;
    private final int fins;
    private final CalculadoraMultes calculadora;

    public CalculMultesParallel(List<Prestec> prestecs, int des, int fins,
                                CalculadoraMultes calculadora) {
        this.prestecs = prestecs;
        this.des = des;
        this.fins = fins;
        this.calculadora = calculadora;
    }

    @Override
    protected Double compute() {
        int mida = fins - des;

        // CAS BASE: tros petit, calcul sequencial directe.
        if (mida <= LLINDAR) {
            double suma = 0;
            for (int i = des; i < fins; i++) {
                suma += calculadora.calcular(prestecs.get(i));
            }
            return suma;
        }

        // CAS RECURSIU: partir per la meitat.
        int mig = des + mida / 2;
        CalculMultesParallel esq =
                new CalculMultesParallel(prestecs, des, mig, calculadora);
        CalculMultesParallel dre =
                new CalculMultesParallel(prestecs, mig, fins, calculadora);

        // PATRO CORRECTE: bifurcar UNA i calcular l'altra en AQUEST fil.
        // Fer esq.fork() + dre.fork() + esq.join() + dre.join()
        // desaprofita el fil actual, que es quedaria esperant.
        esq.fork();                       // a la cua: un altre fil la pot robar
        double resultatDre = dre.compute();    // aquest fil treballa
        double resultatEsq = esq.join();       // recollir la bifurcada

        return resultatEsq + resultatDre;
    }

    // --- Us ---
    public static double calcularTotes(List<Prestec> prestecs,
                                       CalculadoraMultes calculadora) {
        // El pool COMU: compartit per tota la JVM, amb
        // (nuclis - 1) fils. El fan servir tambe els streams parallels (10-04).
        ForkJoinPool comu = ForkJoinPool.commonPool();
        return comu.invoke(new CalculMultesParallel(
                prestecs, 0, prestecs.size(), calculadora));
    }
}

// PROHIBIT al pool comu: operacions blocants.
ForkJoinPool.commonPool().submit(() -> {
    return Files.readAllLines(camiEnorme);   // bloqueja un fil compartit
});

// CORRECTE: pool propi per a la feina blocant.
ForkJoinPool poolPropi = new ForkJoinPool(4);
try {
    poolPropi.invoke(new CalculMultesParallel(...));
} finally {
    poolPropi.shutdown();
}

package com.nexussoftware.bibliotech.servei;

import com.nexussoftware.bibliotech.domini.Prestec;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * Enviament massiu d'avisos de venciment.
 *
 * Propietats:
 *  - Pool ACOTAT amb fils anomenats i cua acotada.
 *  - SEMAFOR que limita a 5 els accessos simultanis al fitxer d'avisos.
 *  - COUNTDOWNLATCH per mostrar el progres i esperar el final.
 *  - Cancellacio neta mitjancant shutdownNow() -> interrupcio cooperativa.
 *  - Resultat agregat amb comptadors atomics (detall a 08-06).
 */
public class ServeiAvisos implements AutoCloseable {

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

    private static final int FILS = 8;
    private static final int MAX_ESCRIPTURES_SIMULTANIES = 5;

    private final ThreadPoolExecutor pool;
    private final Semaphore accesFitxer =
            new Semaphore(MAX_ESCRIPTURES_SIMULTANIES, true);

    public ServeiAvisos() {
        AtomicInteger n = new AtomicInteger(1);
        this.pool = new ThreadPoolExecutor(
                FILS, FILS,
                0L, TimeUnit.MILLISECONDS,
                new ArrayBlockingQueue<>(500),          // cua ACOTADA
                r -> {
                    Thread t = new Thread(r, "bibliotech-avisos-" + n.getAndIncrement());
                    t.setUncaughtExceptionHandler((f, e) ->
                            LOG.log(Level.SEVERE, "Fallada no capturada a " + f.getName(), e));
                    return t;
                },
                new ThreadPoolExecutor.CallerRunsPolicy());  // contrapressio
    }

    /** Resultat agregat de l'enviament. Immutable (08-04). */
    public record ResumEnviament(int total, int enviats, int fallits,
                                 int cancellats, long milisegons) {

        public double percentatgeExit() {
            return total == 0 ? 0 : 100.0 * enviats / total;
        }
    }

    /**
     * Envia tots els avisos en parallel.
     *
     * @param terminiSegons termini global; en exhaurir-se es cancella el pendent
     */
    public ResumEnviament enviarTots(List<Prestec> vencuts, long terminiSegons)
            throws InterruptedException {

        final int total = vencuts.size();
        final CountDownLatch acabats = new CountDownLatch(total);
        final AtomicInteger enviats = new AtomicInteger();
        final AtomicInteger fallits = new AtomicInteger();

        long inici = System.nanoTime();
        List<Future<?>> futurs = new ArrayList<>(total);

        // 1. Enviar totes les tasques al pool.
        for (Prestec p : vencuts) {
            futurs.add(pool.submit(() -> {
                try {
                    // Punt de cancellacio abans de comencar.
                    if (Thread.currentThread().isInterrupted()) {
                        return;
                    }
                    // El semafor limita l'acces concurrent al fitxer.
                    accesFitxer.acquire();
                    try {
                        escriureAvis(p);
                        enviats.incrementAndGet();
                    } finally {
                        accesFitxer.release();     // SEMPRE
                    }
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();     // restaurar (08-02)
                } catch (Exception e) {
                    fallits.incrementAndGet();
                    LOG.log(Level.WARNING, "Avis fallit per a " + p.id(), e);
                } finally {
                    // SEMPRE, o l'await() no torna mai.
                    acabats.countDown();
                }
            }));
        }

        // 2. Progres mentre s'espera, amb termini global.
        long limitNs = TimeUnit.SECONDS.toNanos(terminiSegons);
        boolean completat = false;

        while (!(completat = acabats.await(300, TimeUnit.MILLISECONDS))) {
            long fets = total - acabats.getCount();
            System.out.printf("\r  [%s] %d/%d avisos (%.0f%%)",
                    barra(fets, total), fets, total, 100.0 * fets / total);

            if (System.nanoTime() - inici > limitNs) {
                System.out.println("\n  Termini exhaurit: cancellant el pendent");
                for (Future<?> f : futurs) {
                    f.cancel(true);        // interromp o descarta de la cua
                }
                break;
            }
        }

        long ms = (System.nanoTime() - inici) / 1_000_000;
        int cancellats = total - enviats.get() - fallits.get();

        System.out.printf("\r  [%s] %d/%d avisos (100%%)%n",
                barra(total, total), total, total);

        return new ResumEnviament(total, enviats.get(), fallits.get(), cancellats, ms);
    }

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

    /** Simula l'escriptura de l'avis: 250 ms d'E/S. */
    private void escriureAvis(Prestec p) throws InterruptedException {
        TimeUnit.MILLISECONDS.sleep(250);
        if (p.id().hashCode() % 37 == 0) {
            throw new IllegalStateException("empleat sense adreca de contacte");
        }
    }

    /** AutoCloseable: aturada en dues fases (06-06 + apartat 7). */
    @Override
    public void close() {
        pool.shutdown();
        try {
            if (!pool.awaitTermination(30, TimeUnit.SECONDS)) {
                pool.shutdownNow();
                if (!pool.awaitTermination(10, TimeUnit.SECONDS)) {
                    LOG.severe("Hi ha tasques d'avis que ignoren la interrupcio");
                }
            }
        } catch (InterruptedException e) {
            pool.shutdownNow();
            Thread.currentThread().interrupt();
        }
    }
}

package com.nexussoftware.bibliotech.presentacio;

import java.util.List;

public class DemostracioAvisos {

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

        List<Prestec> vencuts = generarVencuts(200);

        System.out.println("=== ENVIAMENT D'AVISOS DE VENCIMENT ===");
        System.out.println("Avisos pendents: " + vencuts.size());
        System.out.println("Temps sequencial estimat: "
                + (vencuts.size() * 250 / 1000) + " s");
        System.out.println();

        // try-with-resources: close() atura el pool ordenadament.
        try (ServeiAvisos servei = new ServeiAvisos()) {

            ServeiAvisos.ResumEnviament r = servei.enviarTots(vencuts, 60);

            System.out.println();
            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("Cancellats : " + r.cancellats());
            System.out.println("Temps      : " + r.milisegons() + " ms");
            System.out.printf ("Exit       : %.1f%%%n", r.percentatgeExit());
            System.out.printf ("Acceleracio: %.1fx sobre l'enviament sequencial%n",
                    (vencuts.size() * 250.0) / r.milisegons());
        }
    }
}

=== ENVIAMENT D'AVISOS DE VENCIMENT ===
Avisos pendents: 200
Temps sequencial estimat: 50 s

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

=== RESUM ===
Total      : 200
Enviats    : 194
Fallits    : 6
Cancellats : 0
Temps      : 10247 ms
Exit       : 97.0%
Acceleracio: 4.9x sobre l'enviament sequencial

import java.util.Collections;
import java.util.HashSet;
import java.util.Set;
import java.util.concurrent.*;

public class ComparativaPools {

    static final int TASQUES = 300;
    static final long DURACIO_MS = 100;

    /** Tasca d'E/S simulada que registra quin fil l'ha executada. */
    static Runnable tasca(Set<String> filsUsats) {
        return () -> {
            filsUsats.add(Thread.currentThread().getName());
            try {
                TimeUnit.MILLISECONDS.sleep(DURACIO_MS);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        };
    }

    record Resultat(String estrategia, long ms, int fils) { }

    /** (a) Un fil per tasca, gestionat a ma. */
    static Resultat unFilPerTasca() throws InterruptedException {
        Set<String> fils = Collections.synchronizedSet(new HashSet<>());
        Thread[] ts = new Thread[TASQUES];
        long inici = System.nanoTime();
        for (int i = 0; i < TASQUES; i++) {
            ts[i] = new Thread(tasca(fils), "manual-" + i);
            ts[i].start();
        }
        for (Thread t : ts) t.join();
        return new Resultat("un fil per tasca",
                (System.nanoTime() - inici) / 1_000_000, fils.size());
    }

    /** (b)-(e) Qualsevol ExecutorService. */
    static Resultat ambExecutor(String nom, ExecutorService ex)
            throws InterruptedException {
        Set<String> fils = Collections.synchronizedSet(new HashSet<>());
        long inici = System.nanoTime();
        for (int i = 0; i < TASQUES; i++) {
            ex.execute(tasca(fils));
        }
        ex.shutdown();
        ex.awaitTermination(2, TimeUnit.MINUTES);
        return new Resultat(nom,
                (System.nanoTime() - inici) / 1_000_000, fils.size());
    }

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

        System.out.printf("%d tasques de %d ms d'E/S simulada%n", TASQUES, DURACIO_MS);
        System.out.printf("Sequencial seria: %d ms%n%n", TASQUES * DURACIO_MS);

        Resultat[] resultats = {
            unFilPerTasca(),
            ambExecutor("fixed(4)",  Executors.newFixedThreadPool(4)),
            ambExecutor("fixed(32)", Executors.newFixedThreadPool(32)),
            ambExecutor("cached",    Executors.newCachedThreadPool()),
            ambExecutor("a mida (16, cua 50, CallerRuns)",
                new ThreadPoolExecutor(16, 16, 0L, TimeUnit.MILLISECONDS,
                        new ArrayBlockingQueue<>(50),
                        new ThreadPoolExecutor.CallerRunsPolicy()))
        };

        System.out.printf("%-38s | %8s | %8s%n", "Estrategia", "ms", "fils");
        System.out.println("---------------------------------------|----------|---------");
        for (Resultat r : resultats) {
            System.out.printf("%-38s | %8d | %8d%n", r.estrategia(), r.ms(), r.fils());
        }
    }
}

300 tasques de 100 ms d'E/S simulada
Sequencial seria: 30000 ms

Estrategia                             |       ms |     fils
---------------------------------------|----------|---------
un fil per tasca                       |      147 |      300
fixed(4)                               |     7621 |        4
fixed(32)                              |     1024 |       32
cached                                 |      163 |      300
a mida (16, cua 50, CallerRuns)        |     1938 |       17

package com.nexussoftware.bibliotech.persistencia;

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

public class ImportacioAmbTermini {

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

    /** Informe immutable del resultat. */
    public record Informe(int importats, int descartats, long ms) { }

    /**
     * Importacio com a Callable<Informe>: retorna valor i pot
     * llancar excepcions comprovades. Es cancellable: comprova la
     * interrupcio a cada linia (08-02).
     */
    static class TascaImportacio implements Callable<Informe> {

        private final Path fitxer;
        private final AtomicInteger progres = new AtomicInteger();

        TascaImportacio(Path fitxer) { this.fitxer = fitxer; }

        int progres() { return progres.get(); }

        @Override
        public Informe call() throws Exception {
            long inici = System.nanoTime();
            int importats = 0, descartats = 0;

            for (int linia = 0; linia < 50_000; linia++) {

                // PUNT DE CANCELLACIO: cancel(true) del Future es
                // tradueix en interrupt() sobre aquest fil.
                if (Thread.currentThread().isInterrupted()) {
                    throw new InterruptedException(
                            "importacio cancellada a la linia " + linia);
                }

                if (linia % 97 == 0) descartats++; else importats++;
                progres.incrementAndGet();

                if (linia % 1000 == 0) {
                    TimeUnit.MILLISECONDS.sleep(30);   // simula validacio pesada
                }
            }
            return new Informe(importats, descartats,
                    (System.nanoTime() - inici) / 1_000_000);
        }
    }

    public static void main(String[] args) {

        ExecutorService executor = Executors.newSingleThreadExecutor(
                r -> new Thread(r, "bibliotech-importador"));

        TascaImportacio tasca = new TascaImportacio(Path.of("dades/inventari.csv"));
        Future<Informe> futur = executor.submit(tasca);

        try {
            // 1-2. El fil principal continua viu: aten el menu i pinta progres.
            System.out.println("[main] importacio llancada; el menu continua actiu");
            while (!futur.isDone()) {
                System.out.printf("\r[main] progres: %d linies", tasca.progres());
                TimeUnit.MILLISECONDS.sleep(300);
            }

            // 3. Termini de 5 segons.
            Informe informe = futur.get(5, TimeUnit.SECONDS);
            System.out.printf("%n[main] COMPLETADA: %d importats, %d descartats, %d ms%n",
                    informe.importats(), informe.descartats(), informe.ms());

        } catch (TimeoutException e) {
            // 4. El termini NO cancella per si sol: cal demanar-ho.
            System.out.printf("%n[main] termini exhaurit despres de %d linies; cancellant%n",
                    tasca.progres());
            boolean demanada = futur.cancel(true);
            System.out.println("[main] cancel() retorna   : " + demanada);
            System.out.println("[main] isCancelled()      : " + futur.isCancelled());
            System.out.println("[main] el cataleg conserva el seu contingut anterior");

        } catch (ExecutionException e) {
            // 5. La tasca ha fallat: la causa real es a getCause() (06-03).
            Throwable causa = e.getCause();
            if (causa instanceof InterruptedException) {
                System.out.println("\n[main] la importacio s'ha aturat per cancellacio");
            } else {
                LOG.log(Level.SEVERE, "La importacio ha fallat", causa);
                System.out.println("\n[main] fallada: " + causa.getMessage());
            }

        } catch (InterruptedException e) {
            // Ens han interromput a NOSALTRES; la tasca continua viva.
            System.out.println("\n[main] espera interrompuda");
            futur.cancel(true);
            Thread.currentThread().interrupt();

        } finally {
            // 6. Aturada en dues fases.
            executor.shutdown();
            try {
                if (!executor.awaitTermination(5, TimeUnit.SECONDS)) {
                    executor.shutdownNow();
                    if (!executor.awaitTermination(5, TimeUnit.SECONDS)) {
                        LOG.severe("L'importador ignora la interrupcio");
                    }
                }
            } catch (InterruptedException e) {
                executor.shutdownNow();
                Thread.currentThread().interrupt();
            }
            System.out.println("[main] executor aturat; la JVM pot acabar");
        }
    }
}

[main] importacio llancada; el menu continua actiu
[main] progres: 41893 linies
[main] termini exhaurit despres de 42017 linies; cancellant
[main] cancel() retorna   : true
[main] isCancelled()      : true
[main] el cataleg conserva el seu contingut anterior
[main] executor aturat; la JVM pot acabar

package com.nexussoftware.bibliotech.servei;

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

public class SalaDeLectura {

    private static final int AFORAMENT = 4;
    private static final int EMPLEATS = 20;

    // Semafor EQUITATIU: els que porten mes estona esperant entren abans,
    // cosa que evita la inanicio (08-04, apartat 12).
    private final Semaphore aforament = new Semaphore(AFORAMENT, true);

    // Aforament instantani, per comprovar l'invariant.
    private final AtomicInteger dins = new AtomicInteger();
    private final AtomicInteger maximObservat = new AtomicInteger();
    private volatile boolean invariantTrencat = false;

    /** Un empleat entra, hi roman una estona i surt. */
    public void visitar(String empleat) throws InterruptedException {

        aforament.acquire();      // bloqueja si ja n'hi ha 4 a dins
        try {
            int actual = dins.incrementAndGet();

            // Registre del maxim observat, amb bucle CAS (08-06).
            maximObservat.updateAndGet(m -> Math.max(m, actual));

            if (actual > AFORAMENT) {
                invariantTrencat = true;
                System.err.println("!!! INVARIANT TRENCAT: " + actual + " a dins !!!");
            }

            System.out.printf("  [+] %-12s entra  (dins=%d, esperant=%d)%n",
                    empleat, actual, aforament.getQueueLength());

            TimeUnit.MILLISECONDS.sleep(
                    ThreadLocalRandom.current().nextInt(200, 601));

            System.out.printf("  [-] %-12s surt   (dins=%d)%n",
                    empleat, dins.get() - 1);

        } finally {
            dins.decrementAndGet();
            // OBLIGATORI al finally: un permis perdut no torna mai,
            // i despres de quatre perdues la sala quedaria tancada per sempre.
            aforament.release();
        }
    }

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

        SalaDeLectura sala = new SalaDeLectura();

        // Dos tancaments: la "pistola de sortida" i la "meta".
        CountDownLatch sortida = new CountDownLatch(1);
        CountDownLatch meta    = new CountDownLatch(EMPLEATS);

        // Monitor periodic de l'aforament.
        ScheduledExecutorService monitor = Executors.newSingleThreadScheduledExecutor(
                r -> {
                    Thread t = new Thread(r, "bibliotech-monitor-aforament");
                    t.setDaemon(true);
                    return t;
                });

        monitor.scheduleAtFixedRate(() -> {
            try {
                System.out.printf("      [monitor] aforament=%d/%d  cua=%d%n",
                        sala.dins.get(), AFORAMENT, sala.aforament.getQueueLength());
            } catch (Exception e) {
                // Una excepcio no capturada CANCELLARIA la planificacio
                // per sempre i en silenci.
                e.printStackTrace();
            }
        }, 200, 200, TimeUnit.MILLISECONDS);

        // 20 fils que esperen la sortida i arrenquen alhora.
        for (int i = 1; i <= EMPLEATS; i++) {
            final String nom = "empleat-" + String.format("%02d", i);
            new Thread(() -> {
                try {
                    sortida.await();           // tots esperen aqui
                    sala.visitar(nom);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                } finally {
                    meta.countDown();          // SEMPRE
                }
            }, nom).start();
        }

        System.out.println("=== SALA DE LECTURA (aforament " + AFORAMENT + ") ===");
        TimeUnit.MILLISECONDS.sleep(200);      // que tots arribin a await()

        long inici = System.nanoTime();
        sortida.countDown();                   // alhora!
        meta.await();
        long ms = (System.nanoTime() - inici) / 1_000_000;

        monitor.shutdown();
        monitor.awaitTermination(2, TimeUnit.SECONDS);

        System.out.println();
        System.out.println("=== RESUM ===");
        System.out.println("Empleats atesos     : " + EMPLEATS);
        System.out.println("Aforament maxim      : " + sala.maximObservat.get()
                + " (limit " + AFORAMENT + ")");
        System.out.println("Invariant respectat  : " + !sala.invariantTrencat);
        System.out.println("Temps total          : " + ms + " ms");
        System.out.println("Dins al final        : " + sala.dins.get());
        System.out.println("Permisos disponibles : " + sala.aforament.availablePermits()
                + " (ha de ser " + AFORAMENT + ")");
    }
}

=== SALA DE LECTURA (aforament 4) ===
  [+] empleat-03   entra  (dins=1, esperant=16)
  [+] empleat-07   entra  (dins=2, esperant=15)
  [+] empleat-01   entra  (dins=3, esperant=14)
  [+] empleat-12   entra  (dins=4, esperant=13)
      [monitor] aforament=4/4  cua=16
  [-] empleat-03   surt   (dins=3)
  [+] empleat-05   entra  (dins=4, esperant=15)
  ...

=== RESUM ===
Empleats atesos     : 20
Aforament maxim      : 4 (limit 4)
Invariant respectat  : true
Temps total          : 2143 ms
Dins al final        : 0
Permisos disponibles : 4 (ha de ser 4)