import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;

public class HashMapCorromput {

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

        for (int intent = 1; intent <= 5; intent++) {

            Map<Integer, String> mapa = new HashMap<>();
            final int PER_FIL = 100_000;

            Thread f1 = new Thread(() -> {
                for (int i = 0; i < PER_FIL; i++) mapa.put(i, "A" + i);
            }, "escriptor-1");

            Thread f2 = new Thread(() -> {
                for (int i = PER_FIL; i < PER_FIL * 2; i++) mapa.put(i, "B" + i);
            }, "escriptor-2");

            f1.start();
            f2.start();

            // Termini: si el HashMap es corromp, un fil es pot quedar
            // en un bucle infinit dins de put() o de get().
            f1.join(5000);
            f2.join(5000);

            int esperat = PER_FIL * 2;
            if (f1.isAlive() || f2.isAlive()) {
                System.out.printf("Intent %d: BUCLE INFINIT. "
                        + "f1=%s f2=%s  <-- estructura corrompuda%n",
                        intent, f1.getState(), f2.getState());
                System.out.println("  (mira l'us de CPU: un nucli al 100%)");
                System.exit(1);
            }
            System.out.printf("Intent %d: esperat %d, real %d, perdues %d%n",
                    intent, esperat, mapa.size(), esperat - mapa.size());
        }
    }
}

Intent 1: esperat 200000, real 187341, perdues 12659
Intent 2: esperat 200000, real 193028, perdues 6972
Intent 3: BUCLE INFINIT. f1=RUNNABLE f2=RUNNABLE  <-- estructura corrompuda
  (mira l'us de CPU: un nucli al 100%)

List<String> llista = new ArrayList<>(List.of("a", "b", "c"));
for (String s : llista) {
    llista.remove(s);     // ConcurrentModificationException
}

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

public class FailFastConcurrent {

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

        List<String> cataleg = new ArrayList<>();
        for (int i = 0; i < 10_000; i++) cataleg.add("978-" + i);

        Thread lector = new Thread(() -> {
            try {
                while (!Thread.currentThread().isInterrupted()) {
                    int n = 0;
                    for (String isbn : cataleg) {     // iteracio
                        n += isbn.length();
                    }
                }
            } catch (java.util.ConcurrentModificationException e) {
                System.out.println("[lector] ConcurrentModificationException: "
                        + "un altre fil ha modificat el cataleg mentre iterava");
            }
        }, "bibliotech-lector");

        Thread escriptor = new Thread(() -> {
            try {
                while (!Thread.currentThread().isInterrupted()) {
                    cataleg.add("978-nou");
                    TimeUnit.MILLISECONDS.sleep(1);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }, "bibliotech-escriptor");

        lector.start();
        escriptor.start();

        TimeUnit.SECONDS.sleep(2);
        lector.interrupt();
        escriptor.interrupt();
    }
}

[lector] ConcurrentModificationException: un altre fil ha modificat el cataleg mentre iterava

import java.util.*;

Map<String, Material> mapa = Collections.synchronizedMap(new HashMap<>());
List<Material> llista      = Collections.synchronizedList(new ArrayList<>());
Set<String> conjunt        = Collections.synchronizedSet(new HashSet<>());

// Aproximadament, el que fa Collections.synchronizedMap:
public V get(Object clau) {
    synchronized (mutex) { return m.get(clau); }
}
public V put(K clau, V valor) {
    synchronized (mutex) { return m.put(clau, valor); }
}

List<Material> llista = Collections.synchronizedList(new ArrayList<>());

// MALAMENT: cada crida de l'iterador esta sincronitzada, pero la
// ITERACIO COMPLETA no. ConcurrentModificationException garantida.
for (Material m : llista) {
    processar(m);
}

// BE: sincronitzar la iteracio sencera sobre el mateix embolcall.
// Es el que exigeix explicitament el javadoc de Collections.synchronizedList,
// i gairebe ningu no llegeix aquesta part.
synchronized (llista) {
    for (Material m : llista) {
        processar(m);     // COMPTE: 'processar' s'executa AMB EL PANY PRES
    }                     // (regla 3 de 08-04: res de codi alie aqui)
}

Map<String, Integer> prestecsPerIsbn = Collections.synchronizedMap(new HashMap<>());

// MALAMENT: comprovar-despres-actuar. Cada crida esta sincronitzada,
// pero el FORAT entre elles no ho esta.
if (!prestecsPerIsbn.containsKey(isbn)) {      // (1) fil A: no existeix
    prestecsPerIsbn.put(isbn, 1);              // (3) fil A escriu 1
}                                              // (2) fil B tambe va veure "no existeix"
                                               // (4) fil B escriu 1 -> se'n perd un

// MALAMENT: llegir-modificar-escriure, el mateix problema que 'comptador++' (08-04)
Integer n = prestecsPerIsbn.get(isbn);         // (1) llegeix 5
prestecsPerIsbn.put(isbn, n + 1);              // (3) escriu 6
                                               // un altre fil tambe va llegir 5 i
                                               // tambe escriu 6: un prestec perdut

// Correcte pero maldestre: pany extern sobre la colleccio.
synchronized (prestecsPerIsbn) {
    Integer n = prestecsPerIsbn.get(isbn);
    prestecsPerIsbn.put(isbn, n == null ? 1 : n + 1);
}

import java.util.*;
import java.util.concurrent.*;

public class ComparativaMapes {

    static long mesurar(Map<Integer, String> mapa, int fils, int opsPerFil,
                        double proporcioLectura) throws InterruptedException {

        // Precarregar perque les lectures encertin.
        for (int i = 0; i < 10_000; i++) mapa.put(i, "valor-" + i);

        CountDownLatch sortida = new CountDownLatch(1);
        CountDownLatch meta    = new CountDownLatch(fils);

        for (int f = 0; f < fils; f++) {
            new Thread(() -> {
                try {
                    sortida.await();
                    ThreadLocalRandom atzar = ThreadLocalRandom.current();
                    for (int i = 0; i < opsPerFil; i++) {
                        int clau = atzar.nextInt(10_000);
                        if (atzar.nextDouble() < proporcioLectura) {
                            mapa.get(clau);
                        } else {
                            mapa.put(clau, "nou-" + i);
                        }
                    }
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                } finally {
                    meta.countDown();
                }
            }, "acces-" + f).start();
        }

        long inici = System.nanoTime();
        sortida.countDown();         // arrenquen tots alhora (08-05)
        meta.await();
        return (System.nanoTime() - inici) / 1_000_000;
    }

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

        final int FILS = 16;
        final int OPS = 200_000;

        System.out.printf("%d fils x %d operacions%n%n", FILS, OPS);
        System.out.printf("%-28s | %10s | %10s%n", "Implementacio", "90% lectura", "50% lectura");
        System.out.println("-----------------------------|------------|------------");

        long s90 = mesurar(Collections.synchronizedMap(new HashMap<>()), FILS, OPS, 0.9);
        long s50 = mesurar(Collections.synchronizedMap(new HashMap<>()), FILS, OPS, 0.5);
        System.out.printf("%-28s | %8d ms | %8d ms%n", "synchronizedMap", s90, s50);

        long c90 = mesurar(new ConcurrentHashMap<>(), FILS, OPS, 0.9);
        long c50 = mesurar(new ConcurrentHashMap<>(), FILS, OPS, 0.5);
        System.out.printf("%-28s | %8d ms | %8d ms%n", "ConcurrentHashMap", c90, c50);

        System.out.printf("%nMillora: %.1fx (90%% lectura), %.1fx (50%% lectura)%n",
                (double) s90 / c90, (double) s50 / c50);
    }
}

16 fils x 200000 operacions

Implementacio                | 90% lectura | 50% lectura
-----------------------------|------------|------------
synchronizedMap              |     3187 ms |     3402 ms
ConcurrentHashMap            |      184 ms |      271 ms

Millora: 17.3x (90% lectura), 12.6x (50% lectura)

import java.util.concurrent.ConcurrentHashMap;
import java.util.Map;

public class OperacionsAtomiquesMapa {

    private final Map<String, Integer> prestecsPerIsbn = new ConcurrentHashMap<>();
    private final Map<String, Fitxa> cacheFitxes = new ConcurrentHashMap<>();

    /** Comprovar-despres-actuar, resolt: una sola operacio atomica. */
    public boolean registrarPrimerPrestec(String isbn) {
        // Retorna null si NO existia (i l'insereix), o el valor previ.
        return prestecsPerIsbn.putIfAbsent(isbn, 1) == null;
    }

    /** Llegir-modificar-escriure, resolt amb merge. */
    public void comptarPrestec(String isbn) {
        // Si no existeix -> posa 1. Si existeix -> aplica Integer::sum
        // entre el valor actual i l'1 que passem. Tot atomic.
        prestecsPerIsbn.merge(isbn, 1, Integer::sum);
    }

    /** El mateix amb compute, mes explicit. */
    public void comptarPrestecAlternatiu(String isbn) {
        prestecsPerIsbn.compute(isbn, (clau, actual) ->
                actual == null ? 1 : actual + 1);
    }

    /**
     * Cache mandrosa, resolta amb computeIfAbsent.
     * Substitueix les tres fases de l'exercici 3 de 08-04:
     * la funcio s'executa COM A MOLT UNA VEGADA per clau, encara que
     * deu fils la demanin alhora. Els altres nou esperen i
     * reben el mateix objecte: no hi ha calcul duplicat.
     */
    public Fitxa obtenirFitxa(String isbn) {
        return cacheFitxes.computeIfAbsent(isbn, this::construirFitxa);
    }

    /** Eliminar nomes si el valor es l'esperat: comparar-i-eliminar. */
    public boolean retornarSiEsUltim(String isbn) {
        return prestecsPerIsbn.remove(isbn, 1);
    }

    /** Comptador de descarregues sense NullPointerException. */
    public int descarreguesDe(String isbn) {
        return prestecsPerIsbn.getOrDefault(isbn, 0);
    }

    private Fitxa construirFitxa(String isbn) { /* consulta cara */ return null; }
}

// PROHIBIT 1: modificar el MATEIX mapa dins de la funcio.
// Pot provocar un interbloqueig o corrompre l'estructura.
mapa.computeIfAbsent(k, clau -> {
    mapa.put("altra", "cosa");    // MAI
    return calcular(clau);
});

// PROHIBIT 2: operacions llargues o blocants.
// Bloqueja la cubeta sencera, i tota l'aplicacio se'n ressent
// (regla 2 de 08-04: res d'E/S dins del bloqueig).
mapa.computeIfAbsent(k, clau -> llegirDelDisc(clau));   // MALAMENT si triga

// PROHIBIT 3: cridar codi alie (oients, callbacks).
// Regla 3 de 08-04, aplicada aqui.

// CORRECTE quan el calcul es car: calcular fora i publicar amb putIfAbsent.
Fitxa calculada = llegirDelDisc(isbn);       // sense cap pany
Fitxa establerta = mapa.putIfAbsent(isbn, calculada);
Fitxa resultat = (establerta != null) ? establerta : calculada;
// Hi pot haver calcul duplicat si dos fils coincideixen, pero
// el resultat es correcte i no es bloqueja la cubeta.

Map<String, Material> cataleg = new ConcurrentHashMap<>();

// SEGUR: no llanca excepcio, no bloqueja ningu, i cap escriptor
// no es queda esperant que acabis de recorrer 100.000 entrades.
for (Map.Entry<String, Material> e : cataleg.entrySet()) {
    processar(e.getValue());
}
// Si un altre fil afegeix una entrada mentre iteres, potser la veuras
// i potser no. El que NO passara es que el bucle falli.

// MALAMENT: comprovar-despres-actuar sobre una mida aproximada.
if (cataleg.size() < LIMIT) {
    cataleg.put(isbn, material);     // la mida ha pogut canviar entremig
}

// La mida d'una estructura concurrent es una dada ESTADISTICA,
// util per a logs i metriques, no per a decisions de control.
LOG.log(Level.INFO, "Cataleg amb ~{0} materials", cataleg.size());

package com.nexussoftware.bibliotech.servei;

import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;

/**
 * Registre d'oients d'esdeveniments del cataleg.
 *
 * Cas d'us PERFECTE per a CopyOnWriteArrayList:
 *  - Es registren ~10 oients en arrencar i gairebe mai no canvien.
 *  - Es recorren a CADA operacio del cataleg: milers de vegades per minut.
 *  - Proporcio lectura/escriptura: 100.000 a 1.
 */
public class RegistreOients {

    private final List<OientCataleg> oients = new CopyOnWriteArrayList<>();

    public void registrar(OientCataleg o)    { oients.add(o); }
    public void desregistrar(OientCataleg o) { oients.remove(o); }

    /**
     * Notifica tots els oients.
     *
     * DOS avantatges decisius davant d'una llista sincronitzada:
     *  1. NO hi ha pany durant el recorregut: els oients poden
     *     registrar o desregistrar oients sense interbloquejar-se.
     *  2. Es la regla 3 de 08-04 —no cridar codi alie amb un
     *     pany— complerta automaticament per la colleccio.
     */
    public void notificarAlta(Material m) {
        for (OientCataleg o : oients) {
            try {
                o.materialAfegit(m);
            } catch (RuntimeException e) {
                // Un oient defectuos no ha d'impedir que els altres
                // se n'assabentin (politica de degradacio de 06-07).
                LOG.log(Level.WARNING, "Oient fallit: " + o, e);
            }
        }
    }
}

// DESASTRE: 10.000 escriptures sobre una llista que creix.
// Cada add() copia tot l'array: 1 + 2 + ... + 10.000 ≈ 50 milions
// de copies de referencies. Segons on haurien de ser milisegons.
List<Material> llista = new CopyOnWriteArrayList<>();
for (int i = 0; i < 10_000; i++) {
    llista.add(materials.get(i));      // O(n) cadascuna -> O(n²) total
}

import java.util.Queue;
import java.util.concurrent.ConcurrentLinkedQueue;

Queue<Reserva> pendents = new ConcurrentLinkedQueue<>();

pendents.offer(reserva);          // afegir: no bloqueja mai, no falla mai
Reserva r = pendents.poll();      // treure: retorna NULL si esta buida

// ANTIPATRO amb ConcurrentLinkedQueue: sondeig (08-03, apartat 6).
while (!Thread.currentThread().isInterrupted()) {
    Reserva r = pendents.poll();
    if (r == null) {
        Thread.sleep(100);     // es desperta 10 vegades per segon per no res
        continue;
    }
    atendre(r);
}

import java.util.concurrent.*;

// 1. ARRAYBLOCKINGQUEUE: acotada. Si s'omple, el productor ESPERA.
//    Aixo es CONTRAPRESSIO: el productor es frena al ritme del consumidor.
//    Es el que evita l'OutOfMemoryError de les cues illimitades (08-05).
BlockingQueue<Reserva> reserves = new ArrayBlockingQueue<>(100);

// 2. LINKEDBLOCKINGQUEUE acotada: dos panys interns (un per al
//    cap i un altre per a la cua), aixi que un productor i un consumidor
//    poden treballar alhora. Millor amb molta concurrencia.
BlockingQueue<Avis> avisos = new LinkedBlockingQueue<>(500);

// 3. SYNCHRONOUSQUEUE: capacitat ZERO. Cada put() espera un take().
//    Es el traspas ma a ma, sense magatzem. Es la cua que fa servir
//    newCachedThreadPool (08-05) i per aixo crea fils sense limit.
BlockingQueue<Tasca> traspas = new SynchronousQueue<>();

// 4. PRIORITYBLOCKINGQUEUE: surt primer el mes "petit" segons el
//    Comparator (05-09). Els avisos mes vencuts, primer.
BlockingQueue<Prestec> perUrgencia = new PriorityBlockingQueue<>(
        100, Comparator.comparingLong(Prestec::diesDeRetard).reversed());

// 5. DELAYQUEUE: els elements implementen Delayed i no es poden
//    treure fins que expiri el seu retard. Reintents amb espera.
DelayQueue<ReintentAvis> reintents = new DelayQueue<>();

package com.nexussoftware.bibliotech.servei;

import com.nexussoftware.bibliotech.domini.Reserva;

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

/**
 * Processador de reserves amb el patro productor-consumidor.
 *
 * Els empleats produeixen reserves des del menu (diversos fils);
 * un grup de consumidors les aten (comprovar disponibilitat,
 * notificar, registrar).
 *
 * La cua ACOTADA dona contrapressio: si les reserves arriben mes rapid
 * del que s'atenen, el menu es frena en lloc d'acumular
 * reserves en memoria fins a exhaurir-la.
 */
public class ProcessadorReserves implements AutoCloseable {

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

    private static final int CAPACITAT = 50;
    private static final int CONSUMIDORS = 4;

    private final BlockingQueue<Reserva> cua = new ArrayBlockingQueue<>(CAPACITAT);
    private final ExecutorService consumidors;

    private final AtomicInteger ateses = new AtomicInteger();
    private final AtomicInteger rebutjades = new AtomicInteger();
    private volatile boolean acceptantNoves = true;

    public ProcessadorReserves() {
        AtomicInteger n = new AtomicInteger(1);
        this.consumidors = Executors.newFixedThreadPool(CONSUMIDORS,
                r -> new Thread(r, "bibliotech-reserves-" + n.getAndIncrement()));

        for (int i = 0; i < CONSUMIDORS; i++) {
            consumidors.execute(this::bucleConsumidor);
        }
    }

    // ---------- PRODUCTOR ----------

    /**
     * Encua una reserva. BLOQUEJA si la cua esta plena: es la
     * contrapressio, i es una caracteristica, no un defecte.
     */
    public void encuar(Reserva r) throws InterruptedException {
        if (!acceptantNoves) {
            throw new IllegalStateException("El processador s'esta apagant");
        }
        cua.put(r);       // espera si esta plena
    }

    /**
     * Variant que no espera indefinidament: si en 2 segons no hi ha
     * forat, rebutja. Es l'apropiat per a una interficie d'usuari:
     * millor dir "el sistema esta saturat" que deixar el menu penjat.
     */
    public boolean encuarAmbTermini(Reserva r) throws InterruptedException {
        boolean acceptada = cua.offer(r, 2, TimeUnit.SECONDS);
        if (!acceptada) {
            rebutjades.incrementAndGet();
            LOG.log(Level.WARNING, "Reserva rebutjada per saturacio: {0}", r.id());
        }
        return acceptada;
    }

    // ---------- CONSUMIDOR ----------

    private void bucleConsumidor() {
        String jo = Thread.currentThread().getName();
        LOG.log(Level.INFO, "[{0}] consumidor llest", jo);
        try {
            while (true) {
                // take() BLOQUEJA sense consumir CPU si la cua esta buida.
                // Es l'alternativa correcta al sondeig amb sleep (08-03).
                Reserva r = cua.take();

                // PINDOLA VERINOSA: senyal d'apagada (apartat 12).
                if (r == Reserva.FI) {
                    LOG.log(Level.INFO, "[{0}] pindola rebuda, acabo", jo);
                    return;
                }

                try {
                    atendre(r);
                    ateses.incrementAndGet();
                } catch (Exception e) {
                    // Una fallada individual NO ha de matar el consumidor:
                    // si mor, el pool perd capacitat silenciosament.
                    LOG.log(Level.WARNING, "[" + jo + "] reserva fallida: " + r.id(), e);
                }
            }
        } catch (InterruptedException e) {
            LOG.log(Level.INFO, "[{0}] consumidor interromput", jo);
            Thread.currentThread().interrupt();      // restaurar (08-02)
        }
    }

    private void atendre(Reserva r) throws InterruptedException {
        TimeUnit.MILLISECONDS.sleep(120);            // E/S simulada
        if (r.id().hashCode() % 23 == 0) {
            throw new IllegalStateException("material ja prestat");
        }
    }

    // ---------- APAGADA ----------

    /**
     * Apagada ORDENADA: deixa d'acceptar, insereix una pindola per
     * consumidor i espera. Tot el que ja era a la cua es processa.
     */
    @Override
    public void close() {
        acceptantNoves = false;
        try {
            for (int i = 0; i < CONSUMIDORS; i++) {
                cua.put(Reserva.FI);         // una per consumidor
            }
            consumidors.shutdown();
            if (!consumidors.awaitTermination(30, TimeUnit.SECONDS)) {
                consumidors.shutdownNow();
            }
        } catch (InterruptedException e) {
            consumidors.shutdownNow();
            Thread.currentThread().interrupt();
        }
        LOG.log(Level.INFO, "Processador tancat: {0} ateses, {1} rebutjades",
                new Object[] { ateses.get(), rebutjades.get() });
    }

    public int ateses()     { return ateses.get(); }
    public int rebutjades() { return rebutjades.get(); }
    public int pendents()   { return cua.size(); }
}

public class DemostracioReserves {

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

        try (ProcessadorReserves processador = new ProcessadorReserves()) {

            // Tres productors: tres empleats fent servir el menu alhora.
            Thread[] productors = new Thread[3];
            for (int p = 0; p < 3; p++) {
                final String empleat = switch (p) {
                    case 0 -> "Marta Ruiz";
                    case 1 -> "Diego Alonso";
                    default -> "Nuria Vidal";
                };
                productors[p] = new Thread(() -> {
                    try {
                        for (int i = 1; i <= 40; i++) {
                            processador.encuar(new Reserva(
                                    empleat + "-R" + i, "978-000000000" + (i % 3 + 1)));
                            TimeUnit.MILLISECONDS.sleep(20);
                        }
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                    }
                }, "menu-" + empleat.split(" ")[0]);
                productors[p].start();
            }

            // Progres mentre treballen.
            for (int t = 0; t < 10; t++) {
                System.out.printf("  ateses=%d  pendents=%d%n",
                        processador.ateses(), processador.pendents());
                TimeUnit.MILLISECONDS.sleep(400);
            }

            for (Thread p : productors) p.join();
            System.out.println("Tots els productors han acabat");

        }   // close(): pindoles verinoses i espera al buidatge
    }
}

  ateses=0  pendents=3
  ateses=12  pendents=14
  ateses=25  pendents=26
  ateses=38  pendents=39
  ateses=51  pendents=50   <-- cua PLENA: els productors es frenen
  ateses=64  pendents=50
  ateses=77  pendents=43
  ateses=90  pendents=30
  ateses=103  pendents=17
  ateses=113  pendents=7
Tots els productors han acabat
INFO: Processador tancat: 120 ateses, 0 rebutjades

package com.nexussoftware.bibliotech.domini;

public record Reserva(String id, String isbn) {

    /**
     * PINDOLA VERINOSA: instancia sentinella que significa
     * "no hi haura mes feina, acaba".
     *
     * Es compara amb == (identitat), no amb equals: es un objecte
     * unic i irrepetible, i cap dada real no pot coincidir amb ell.
     */
    public static final Reserva FI = new Reserva("__FI__", "__FI__");
}

for (int i = 0; i < CONSUMIDORS; i++) {
    cua.put(Reserva.FI);
}

// Alternativa: una sola pindola que cada consumidor reinjecta.
if (r == Reserva.FI) {
    cua.put(Reserva.FI);     // passar-la al seguent
    return;
}

import java.util.concurrent.ConcurrentSkipListMap;
import java.util.NavigableMap;

// Prestecs ordenats per data de venciment (en milisegons).
NavigableMap<Long, Prestec> perVenciment = new ConcurrentSkipListMap<>();

perVenciment.put(vencimentMs, prestec);

// Tots els vencuts abans d'ara, en ordre, sense bloquejar ningu.
NavigableMap<Long, Prestec> vencuts =
        perVenciment.headMap(System.currentTimeMillis(), true);

import java.util.concurrent.atomic.AtomicInteger;

public class ComptadorAtomic {

    private final AtomicInteger valor = new AtomicInteger(0);

    public void incrementar() {
        valor.incrementAndGet();     // ATOMIC, sense pany
    }

    public int valor() { return valor.get(); }

    public static void main(String[] args) throws InterruptedException {
        final int VOLTES = 1_000_000;
        ComptadorAtomic c = new ComptadorAtomic();

        Thread f1 = new Thread(() -> { for (int i = 0; i < VOLTES; i++) c.incrementar(); });
        Thread f2 = new Thread(() -> { for (int i = 0; i < VOLTES; i++) c.incrementar(); });
        f1.start(); f2.start(); f1.join(); f2.join();

        System.out.println("Esperat: " + VOLTES * 2 + ", real: " + c.valor());
    }
}

Esperat: 2000000, real: 2000000

AtomicInteger a = new AtomicInteger(10);

// "Si val 10, posa'l a 11". Retorna true si ho ha fet.
boolean exit = a.compareAndSet(10, 11);

/**
 * El que fa incrementAndGet() per dins, simplificat.
 * Es el patro BUCLE CAS, la base de tota la programacio sense panys.
 */
public int incrementAndGet() {
    while (true) {
        int actual = get();                      // 1. llegir
        int seguent = actual + 1;                // 2. calcular
        if (compareAndSet(actual, seguent)) {    // 3. intentar escriure
            return seguent;                      //    exit: sortir
        }
        // Fallada: un altre fil ha canviat el valor entre 1 i 3.
        // No s'ha perdut res: es torna a llegir i es reintenta.
    }
}

package com.nexussoftware.bibliotech.servei;

import java.util.concurrent.atomic.*;

/**
 * Estadistiques de BiblioTech amb comptadors atomics.
 * Sense un sol pany, i amb lectures que no bloquegen res.
 */
public class EstadistiquesBiblioTech {

    private final AtomicLong prestecsTotals    = new AtomicLong();
    private final AtomicLong devolucionsTotals = new AtomicLong();
    private final AtomicLong multesRecaptadesCentims = new AtomicLong();
    private final AtomicInteger prestecsActius = new AtomicInteger();
    private final AtomicBoolean modeManteniment = new AtomicBoolean(false);
    private final AtomicLong maximSimultanis = new AtomicLong();

    public void registrarPrestec() {
        prestecsTotals.incrementAndGet();
        int actius = prestecsActius.incrementAndGet();

        // MAXIM HISTORIC amb accumulateAndGet: combina el valor
        // actual amb 'actius' fent servir Math::max, atomicament.
        // Escriure-ho amb get()+set() seria una cursa classica.
        maximSimultanis.accumulateAndGet(actius, Math::max);
    }

    public void registrarDevolucio(long multaCentims) {
        devolucionsTotals.incrementAndGet();
        prestecsActius.decrementAndGet();
        if (multaCentims > 0) {
            multesRecaptadesCentims.addAndGet(multaCentims);
        }
    }

    /**
     * Aplica un descompte del 10% al total recaptat.
     * updateAndGet aplica la funcio ATOMICAMENT, amb un bucle CAS
     * per sota: si un altre fil modifica el valor entre la lectura i
     * l'escriptura, la funcio es TORNA A EXECUTAR amb el valor nou.
     *
     * IMPORTANT: la funcio ha de ser PURA i rapida, perque es pot
     * executar diverses vegades. Res d'efectes secundaris.
     */
    public long aplicarDescompte() {
        return multesRecaptadesCentims.updateAndGet(v -> (long) (v * 0.9));
    }

    /**
     * Entrar en manteniment NOMES SI no hi erem ja.
     * compareAndSet garanteix que, encara que deu fils ho demanin alhora,
     * exactament UN rebi true i executi la preparacio.
     * Es l'idioma "nomes una vegada" sense panys.
     */
    public boolean entrarEnManteniment() {
        if (modeManteniment.compareAndSet(false, true)) {
            prepararManteniment();         // nomes un fil hi arriba
            return true;
        }
        return false;                      // un altre se'ns ha avancat
    }

    public String resum() {
        return String.format(
                "prestecs=%d devolucions=%d actius=%d maxim=%d multes=%.2f EUR",
                prestecsTotals.get(), devolucionsTotals.get(),
                prestecsActius.get(), maximSimultanis.get(),
                multesRecaptadesCentims.get() / 100.0);
    }

    private void prepararManteniment() { /* ... */ }
}

package com.nexussoftware.bibliotech.servei;

import java.util.concurrent.atomic.AtomicReference;

public class EstatBiblioTech {

    /** Estat complet, immutable (record de 04-07). */
    public record Estat(long prestecs, long devolucions,
                        long multesCentims, boolean manteniment) {

        Estat ambPrestec() {
            return new Estat(prestecs + 1, devolucions, multesCentims, manteniment);
        }
        Estat ambDevolucio(long multa) {
            return new Estat(prestecs, devolucions + 1,
                    multesCentims + multa, manteniment);
        }
    }

    private final AtomicReference<Estat> estat =
            new AtomicReference<>(new Estat(0, 0, 0, false));

    /**
     * Lectura sense cap bloqueig i SEMPRE COHERENT: els quatre
     * camps venen del mateix instant, perque son un sol objecte
     * immutable. Es l'avantatge sobre quatre comptadors separats.
     */
    public Estat instantania() {
        return estat.get();
    }

    /** Actualitzacio atomica dels quatre camps alhora. */
    public void registrarPrestec() {
        estat.updateAndGet(Estat::ambPrestec);
    }

    public void registrarDevolucio(long multaCentims) {
        estat.updateAndGet(e -> e.ambDevolucio(multaCentims));
    }
}

Fil 1: llegeix A ............................... CAS(A -> C): EXIT
Fil 2:      llegeix A, CAS(A->B), CAS(B->A)
                                                 ^
        El fil 1 no s'assabenta que hi va haver dos canvis.
        Si la seva decisio depenia que NO hagues passat res, es un bug.

import java.util.concurrent.atomic.AtomicStampedReference;

// Cada modificacio incrementa el SEGELL, encara que el valor torni a ser
// el mateix. El CAS comprova valor I segell, aixi que A-B-A es detecta.
AtomicStampedReference<Node> capcalera =
        new AtomicStampedReference<>(nodeInicial, 0);

int[] segellActual = new int[1];
Node actual = capcalera.get(segellActual);

capcalera.compareAndSet(actual, nouNode,
                        segellActual[0], segellActual[0] + 1);   // segell + 1

// Variant mes simple amb un sol bit boolea:
// AtomicMarkableReference<Node>

import java.util.concurrent.atomic.LongAdder;
import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.*;

public class ComparativaComptadors {

    static long mesurarAtomicLong(int fils, int ops) throws InterruptedException {
        AtomicLong c = new AtomicLong();
        return mesurar(fils, ops, c::incrementAndGet, c::get);
    }

    static long mesurarLongAdder(int fils, int ops) throws InterruptedException {
        LongAdder c = new LongAdder();
        return mesurar(fils, ops, c::increment, c::sum);
    }

    static long mesurar(int fils, int ops, Runnable increment,
                        java.util.function.LongSupplier lectura) throws InterruptedException {
        CountDownLatch sortida = new CountDownLatch(1);
        CountDownLatch meta = new CountDownLatch(fils);
        for (int f = 0; f < fils; f++) {
            new Thread(() -> {
                try {
                    sortida.await();
                    for (int i = 0; i < ops; i++) increment.run();
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                } finally { meta.countDown(); }
            }, "comptador-" + f).start();
        }
        long inici = System.nanoTime();
        sortida.countDown();
        meta.await();
        long ns = System.nanoTime() - inici;
        // Verificacio: tots dos han de donar el resultat exacte.
        if (lectura.getAsLong() != (long) fils * ops) {
            throw new AssertionError("resultat incorrecte");
        }
        return ns / 1_000_000;
    }

    public static void main(String[] args) throws InterruptedException {
        final int OPS = 2_000_000;
        System.out.printf("%-8s | %14s | %14s | %8s%n",
                "Fils", "AtomicLong ms", "LongAdder ms", "Millora");
        System.out.println("---------|----------------|----------------|---------");
        for (int fils : new int[] { 1, 2, 4, 8, 16 }) {
            long a = mesurarAtomicLong(fils, OPS / fils);
            long l = mesurarLongAdder(fils, OPS / fils);
            System.out.printf("%-8d | %14d | %14d | %7.1fx%n",
                    fils, a, l, (double) a / Math.max(l, 1));
        }
    }
}

Fils     |  AtomicLong ms |   LongAdder ms |  Millora
---------|----------------|----------------|---------
1        |             12 |             18 |     0.7x
2        |             41 |             21 |     2.0x
4        |             96 |             19 |     5.1x
8        |            213 |             22 |     9.7x
16       |            487 |             26 |    18.7x

package com.nexussoftware.bibliotech.servei;

import com.nexussoftware.bibliotech.domini.Material;

import java.util.*;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.atomic.LongAdder;

/**
 * Cataleg concurrent de BiblioTech.
 *
 * Davant de la versio amb ReadWriteLock de 08-04:
 *  - No hi ha cap pany explicit que deixar anar en un finally.
 *  - Les lectures no bloquegen RES, ni tan sols altres lectures.
 *  - Les escriptures en cubetes diferents ocorren en parallel.
 *  - Les operacions compostes es resolen amb els metodes atomics
 *    del mateix mapa, no encapsulant seccions critiques a ma.
 *
 * LIMIT HONEST: un invariant que abasti DIVERSES estructures
 * (com el de RegistrePrestecs entre perId i perEmpleat) continua
 * necessitant un pany. Les colleccions concurrents garanteixen
 * l'atomicitat d'UNA operacio sobre UNA colleccio, no de dues.
 */
public class CatalegConcurrent {

    /** Index principal per ISBN. Lectures sense bloqueig. */
    private final ConcurrentMap<String, Material> perIsbn = new ConcurrentHashMap<>();

    /** Materials agrupats per tipus. El valor es una llista concurrent. */
    private final ConcurrentMap<TipusMaterial, List<Material>> perTipus =
            new ConcurrentHashMap<>();

    /** Oients d'esdeveniments: moltes lectures, gairebe cap escriptura. */
    private final List<OientCataleg> oients = new CopyOnWriteArrayList<>();

    // --- Estadistiques: LongAdder per la seva alta frequencia d'escriptura ---
    private final LongAdder consultes = new LongAdder();
    private final LongAdder encerts   = new LongAdder();
    private final LongAdder altes     = new LongAdder();
    private final AtomicLong ultimaModificacioMs = new AtomicLong();

    // ---------- ESCRIPTURA ----------

    /**
     * Afegeix un material si el seu ISBN no hi era.
     * putIfAbsent es ATOMIC: encara que deu fils afegeixin el mateix ISBN
     * alhora, exactament un rep true. Es el comprovar-despres-actuar
     * resolt sense panys.
     */
    public boolean afegir(Material m) {
        if (perIsbn.putIfAbsent(m.isbn(), m) != null) {
            return false;                       // ja existia
        }
        // computeIfAbsent crea la llista nomes si no existeix, atomicament.
        // CopyOnWriteArrayList perque aquestes llistes es recorren molt
        // mes del que es modifiquen.
        perTipus.computeIfAbsent(m.tipus(), t -> new CopyOnWriteArrayList<>()).add(m);

        altes.increment();
        ultimaModificacioMs.set(System.currentTimeMillis());
        notificarAlta(m);
        return true;
    }

    public boolean eliminar(String isbn) {
        Material m = perIsbn.remove(isbn);
        if (m == null) return false;

        List<Material> llista = perTipus.get(m.tipus());
        if (llista != null) llista.remove(m);

        ultimaModificacioMs.set(System.currentTimeMillis());
        return true;
    }

    // ---------- LECTURA ----------

    /** Sense panys. Amb 100 fils consultant, cap no espera cap altre. */
    public Material cercarPerIsbn(String isbn) {
        consultes.increment();
        Material m = perIsbn.get(isbn);
        if (m != null) encerts.increment();
        return m;
    }

    /**
     * Retorna la llista d'un tipus. Com que es CopyOnWriteArrayList,
     * qui crida la pot iterar amb total seguretat encara que un altre fil
     * la modifiqui: el seu iterador treballa sobre una instantania immutable.
     * No cal copiar defensivament, a diferencia de 08-04.
     */
    public List<Material> perTipus(TipusMaterial tipus) {
        return perTipus.getOrDefault(tipus, List.of());
    }

    /**
     * Recorregut complet del cataleg.
     * L'iterador es DEBILMENT CONSISTENT: no llanca
     * ConcurrentModificationException i no bloqueja els escriptors.
     */
    public void recorrer(java.util.function.Consumer<Material> accio) {
        for (Material m : perIsbn.values()) {
            accio.accept(m);
        }
    }

    /** COMPTE: aproximat (apartat 7). Val per a metriques, no per a control. */
    public int midaAproximada() {
        return perIsbn.size();
    }

    // ---------- OIENTS ----------

    public void registrarOient(OientCataleg o) { oients.add(o); }

    private void notificarAlta(Material m) {
        // Sense pany durant la notificacio: la regla 3 de 08-04
        // ("no cridis mai codi alie amb un pany") es compleix
        // automaticament gracies a CopyOnWriteArrayList.
        for (OientCataleg o : oients) {
            try {
                o.materialAfegit(m);
            } catch (RuntimeException e) {
                LOG.log(Level.WARNING, "Oient fallit", e);
            }
        }
    }

    // ---------- METRIQUES ----------

    public String metriques() {
        long c = consultes.sum();
        long a = encerts.sum();
        return String.format("consultes=%d encerts=%d taxa=%.1f%% altes=%d materials~%d",
                c, a, c == 0 ? 0.0 : 100.0 * a / c, altes.sum(), perIsbn.size());
    }
}

public class ProvaCatalegConcurrent {

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

        final int FILS = 16;
        final int OPS = 100_000;

        CatalegConcurrent cataleg = new CatalegConcurrent();
        CountDownLatch sortida = new CountDownLatch(1);
        CountDownLatch meta    = new CountDownLatch(FILS);

        for (int f = 0; f < FILS; f++) {
            final int id = f;
            new Thread(() -> {
                try {
                    sortida.await();
                    ThreadLocalRandom atzar = ThreadLocalRandom.current();
                    for (int i = 0; i < OPS; i++) {
                        if (atzar.nextInt(100) < 90) {
                            cataleg.cercarPerIsbn("978-" + atzar.nextInt(1000));
                        } else {
                            cataleg.afegir(new Llibre(
                                    "978-" + atzar.nextInt(1000), "Titol", "Autor"));
                        }
                    }
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                } finally { meta.countDown(); }
            }, "cataleg-" + id).start();
        }

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

        System.out.println("Operacions  : " + (FILS * OPS));
        System.out.println("Temps       : " + ms + " ms");
        System.out.println("Rendiment   : " + (FILS * OPS / Math.max(ms, 1)) + " ops/ms");
        System.out.println(cataleg.metriques());
    }
}

Operacions  : 1600000
Temps       : 312 ms
Rendiment   : 5128 ops/ms
Metriques   : consultes=1439871 encerts=1438204 taxa=99.9% altes=1000 materials~1000

import java.util.*;
import java.util.concurrent.*;

public class TresGeneracions {

    static final int FILS = 12;
    static final int OPS = 100_000;
    static final int CLAUS = 5_000;

    record Resultat(String nom, long ms, int entrades, String incidencia) { }

    static Resultat mesurar(String nom, Map<Integer, String> mapa)
            throws InterruptedException {

        CountDownLatch sortida = new CountDownLatch(1);
        CountDownLatch meta    = new CountDownLatch(FILS);
        // volatile no n'hi ha prou per acumular text des de diversos fils:
        // fem servir una cua concurrent per recollir incidencies.
        Queue<String> incidencies = new ConcurrentLinkedQueue<>();

        for (int f = 0; f < FILS; f++) {
            Thread t = new Thread(() -> {
                try {
                    sortida.await();
                    ThreadLocalRandom atzar = ThreadLocalRandom.current();
                    for (int i = 0; i < OPS; i++) {
                        int clau = atzar.nextInt(CLAUS);
                        if (atzar.nextInt(100) < 80) {
                            mapa.get(clau);
                        } else {
                            mapa.put(clau, "v" + i);
                        }
                    }
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                } catch (RuntimeException e) {
                    incidencies.add(e.getClass().getSimpleName());
                } finally {
                    meta.countDown();
                }
            }, nom + "-" + f);
            t.setDaemon(true);      // dimoni: si entra en bucle infinit,
            t.start();              // no impedira que la JVM acabi
        }

        long inici = System.nanoTime();
        sortida.countDown();

        // Termini: el HashMap sense proteccio pot no acabar MAI.
        boolean completat = meta.await(20, TimeUnit.SECONDS);
        long ms = (System.nanoTime() - inici) / 1_000_000;

        String inc = completat
                ? (incidencies.isEmpty() ? "-" : incidencies.peek())
                : "NO HA ACABAT (bucle infinit o corrupcio)";

        int entrades;
        try {
            entrades = mapa.size();
        } catch (RuntimeException e) {
            entrades = -1;
        }
        return new Resultat(nom, ms, entrades, inc);
    }

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

        System.out.printf("%d fils x %d ops (80%% lectura) sobre %d claus%n%n",
                FILS, OPS, CLAUS);

        List<Resultat> resultats = new ArrayList<>();
        resultats.add(mesurar("HashMap", new HashMap<>()));
        resultats.add(mesurar("synchronizedMap", Collections.synchronizedMap(new HashMap<>())));
        resultats.add(mesurar("ConcurrentHashMap", new ConcurrentHashMap<>()));

        System.out.printf("%-20s | %8s | %10s | %-40s%n",
                "Implementacio", "ms", "entrades", "incidencia");
        System.out.println("---------------------|----------|------------|"
                + "------------------------------------------");
        for (Resultat r : resultats) {
            System.out.printf("%-20s | %8d | %10d | %-40s%n",
                    r.nom(), r.ms(), r.entrades(), r.incidencia());
        }

        System.out.println();
        System.out.println("Esperat: " + CLAUS + " entrades (totes les claus tocades)");
    }
}

12 fils x 100000 ops (80% lectura) sobre 5000 claus

Implementacio        |       ms |   entrades | incidencia
---------------------|----------|------------|------------------------------------------
HashMap              |    20003 |       4211 | NO HA ACABAT (bucle infinit o corrupcio)
synchronizedMap      |     1876 |       5000 | -
ConcurrentHashMap    |      147 |       5000 | -

Esperat: 5000 entrades (totes les claus tocades)

package com.nexussoftware.bibliotech.persistencia;

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

public class PipelineImportacio {

    private static final String PINDOLA = "__FI__";
    private static final int CAPACITAT = 20;
    private static final int PRODUCTORS = 2;
    private static final int CONSUMIDORS = 4;
    private static final int LINIES_PER_PRODUCTOR = 150;

    // Cua ACOTADA: si els consumidors no donen l'abast, els productors
    // es bloquegen a put(). Contrapressio.
    private final BlockingQueue<String> cua = new ArrayBlockingQueue<>(CAPACITAT);

    private final ConcurrentMap<String, String> materials = new ConcurrentHashMap<>();

    // LongAdder: escriptures molt frequents, lectures ocasionals.
    private final LongAdder llegides    = new LongAdder();
    private final LongAdder creats      = new LongAdder();
    private final LongAdder descartades = new LongAdder();

    private volatile boolean enMarxa = true;

    // ---------- ETAPA 1: PRODUCTORS ----------

    private void produir(int idProductor) {
        try {
            for (int i = 0; i < LINIES_PER_PRODUCTOR; i++) {
                String linia = "978-" + idProductor + String.format("%05d", i)
                        + ";Titol " + i + ";Autor";
                cua.put(linia);       // BLOQUEJA si la cua esta plena
                llegides.increment();
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }

    // ---------- ETAPA 2: CONSUMIDORS ----------

    private void consumir() {
        String jo = Thread.currentThread().getName();
        try {
            while (true) {
                String linia = cua.take();       // BLOQUEJA si esta buida

                // Pindola verinosa: comparacio per IDENTITAT.
                if (linia == PINDOLA) {
                    System.out.println("  [" + jo + "] pindola rebuda, acabo");
                    return;
                }
                try {
                    TimeUnit.MILLISECONDS.sleep(30);       // conversio "cara"
                    String[] camps = linia.split(";");
                    if (camps.length < 3) {
                        throw new IllegalArgumentException("linia incompleta");
                    }
                    materials.put(camps[0], camps[1]);
                    creats.increment();
                } catch (IllegalArgumentException e) {
                    descartades.increment();               // degradar (06-07)
                }
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }

    // ---------- ORQUESTRACIO ----------

    public void executar() throws InterruptedException {

        ExecutorService productors = Executors.newFixedThreadPool(PRODUCTORS,
                new AnomenadorFils("pipeline-productor"));
        ExecutorService consumidors = Executors.newFixedThreadPool(CONSUMIDORS,
                new AnomenadorFils("pipeline-consumidor"));

        for (int c = 0; c < CONSUMIDORS; c++) consumidors.execute(this::consumir);

        CountDownLatch produccioAcabada = new CountDownLatch(PRODUCTORS);
        for (int p = 0; p < PRODUCTORS; p++) {
            final int id = p;
            productors.execute(() -> {
                try { produir(id); }
                finally { produccioAcabada.countDown(); }   // SEMPRE
            });
        }

        // Monitor: demostra que la cua s'omple i frena els productors.
        Thread monitor = new Thread(() -> {
            try {
                while (enMarxa) {
                    System.out.printf("      [monitor] cua=%2d/%d  llegides=%d  creats=%d%n",
                            cua.size(), CAPACITAT, llegides.sum(), creats.sum());
                    TimeUnit.MILLISECONDS.sleep(300);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }, "pipeline-monitor");
        monitor.setDaemon(true);
        monitor.start();

        // 1. Esperar que els productors acabin.
        produccioAcabada.await();
        System.out.println("  Produccio acabada; injectant pindoles");

        // 2. UNA pindola PER CONSUMIDOR, al final de la cua:
        //    tot l'anterior es processa abans.
        for (int c = 0; c < CONSUMIDORS; c++) cua.put(PINDOLA);

        // 3. Apagada ordenada en dues fases.
        productors.shutdown();
        consumidors.shutdown();
        boolean ok = consumidors.awaitTermination(30, TimeUnit.SECONDS);
        if (!ok) consumidors.shutdownNow();

        enMarxa = false;
        monitor.interrupt();

        // 4. Verificacio.
        long total = LINIES_PER_PRODUCTOR * PRODUCTORS;
        System.out.println();
        System.out.println("=== RESULTAT ===");
        System.out.println("Linies produides  : " + llegides.sum() + " (esperat " + total + ")");
        System.out.println("Materials creats  : " + creats.sum());
        System.out.println("Descartades       : " + descartades.sum());
        System.out.println("Al mapa           : " + materials.size());
        System.out.println("Cua al final      : " + cua.size() + " (ha de ser 0)");
        System.out.println("Sense perdues     : "
                + (creats.sum() + descartades.sum() == total));
    }

    static class AnomenadorFils implements ThreadFactory {
        private final String prefix;
        private int n = 1;
        AnomenadorFils(String prefix) { this.prefix = prefix; }
        @Override public synchronized Thread newThread(Runnable r) {
            return new Thread(r, prefix + "-" + n++);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        new PipelineImportacio().executar();
    }
}

      [monitor] cua=20/20  llegides= 42  creats= 22
      [monitor] cua=20/20  llegides= 82  creats= 62
      [monitor] cua=20/20  llegides=122  creats=102
      [monitor] cua=20/20  llegides=162  creats=142
      ...
  Produccio acabada; injectant pindoles
  [pipeline-consumidor-2] pindola rebuda, acabo
  [pipeline-consumidor-1] pindola rebuda, acabo
  [pipeline-consumidor-4] pindola rebuda, acabo
  [pipeline-consumidor-3] pindola rebuda, acabo

=== RESULTAT ===
Linies produides  : 300 (esperat 300)
Materials creats  : 300
Descartades       : 0
Al mapa           : 300
Cua al final      : 0 (ha de ser 0)
Sense perdues     : true

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

public class ComparativaEstadistiques {

    interface Comptador {
        void registrarPrestec();
        long total();
        String nom();
    }

    /** (a) long protegit amb synchronized. */
    static class AmbSynchronized implements Comptador {
        private long prestecs = 0;
        public synchronized void registrarPrestec() { prestecs++; }
        public synchronized long total() { return prestecs; }
        public String nom() { return "synchronized"; }
    }

    /** (b) AtomicLong: bucle CAS per sota. */
    static class AmbAtomicLong implements Comptador {
        private final AtomicLong prestecs = new AtomicLong();
        public void registrarPrestec() { prestecs.incrementAndGet(); }
        public long total() { return prestecs.get(); }
        public String nom() { return "AtomicLong"; }
    }

    /** (c) LongAdder: celles separades, suma en llegir. */
    static class AmbLongAdder implements Comptador {
        private final LongAdder prestecs = new LongAdder();
        public void registrarPrestec() { prestecs.increment(); }
        public long total() { return prestecs.sum(); }
        public String nom() { return "LongAdder"; }
    }

    /** (d) AtomicReference sobre un record immutable de TRES camps. */
    static class AmbAtomicReference implements Comptador {

        record Estat(long prestecs, long devolucions, long multes) {
            Estat ambPrestec() {
                return new Estat(prestecs + 1, devolucions, multes);
            }
        }

        private final AtomicReference<Estat> estat =
                new AtomicReference<>(new Estat(0, 0, 0));

        public void registrarPrestec() {
            // updateAndGet reintenta si un altre fil s'ha avancat.
            // La funcio ha de ser PURA: es pot executar diverses vegades.
            estat.updateAndGet(Estat::ambPrestec);
        }

        public long total() { return estat.get().prestecs(); }

        /** AVANTATGE UNIC: instantania COHERENT dels tres camps. */
        public Estat instantania() { return estat.get(); }

        public String nom() { return "AtomicReference+record"; }
    }

    static long mesurar(Comptador c, int fils, int perFil) throws InterruptedException {
        CountDownLatch sortida = new CountDownLatch(1);
        CountDownLatch meta    = new CountDownLatch(fils);

        for (int f = 0; f < fils; f++) {
            new Thread(() -> {
                try {
                    sortida.await();
                    for (int i = 0; i < perFil; i++) c.registrarPrestec();
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                } finally { meta.countDown(); }
            }, "est-" + f).start();
        }

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

        long esperat = (long) fils * perFil;
        if (c.total() != esperat) {
            throw new AssertionError(c.nom() + " INCORRECTE: "
                    + c.total() + " != " + esperat);
        }
        return ms;
    }

    static Comptador nova(int tipus) {
        return switch (tipus) {
            case 0 -> new AmbSynchronized();
            case 1 -> new AmbAtomicLong();
            case 2 -> new AmbLongAdder();
            default -> new AmbAtomicReference();
        };
    }

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

        final int TOTAL = 8_000_000;

        // Escalfament (JIT).
        for (int t = 0; t < 4; t++) mesurar(nova(t), 4, 50_000);

        for (int fils : new int[] { 1, 16 }) {
            System.out.printf("%n=== %d fil(s), %d increments en total ===%n",
                    fils, TOTAL);
            System.out.printf("%-26s | %8s | %14s%n", "Implementacio", "ms", "inc/ms");
            System.out.println("---------------------------|----------|---------------");

            for (int t = 0; t < 4; t++) {
                Comptador c = nova(t);
                long ms = mesurar(c, fils, TOTAL / fils);
                System.out.printf("%-26s | %8d | %14d%n",
                        c.nom(), ms, TOTAL / Math.max(ms, 1));
            }
        }

        // Demostracio de l'avantatge unic d'AtomicReference.
        AmbAtomicReference ar = new AmbAtomicReference();
        mesurar(ar, 8, 100_000);
        AmbAtomicReference.Estat foto = ar.instantania();
        System.out.printf("%nInstantania COHERENT: prestecs=%d devolucions=%d multes=%d%n",
                foto.prestecs(), foto.devolucions(), foto.multes());
        System.out.println("Els tres camps venen del MATEIX instant, cosa que");
        System.out.println("tres comptadors independents no poden garantir.");
    }
}

=== 1 fil(s), 8000000 increments en total ===
Implementacio              |       ms |         inc/ms
---------------------------|----------|---------------
synchronized               |       61 |         131147
AtomicLong                 |       48 |         166666
LongAdder                  |       72 |         111111
AtomicReference+record     |      284 |          28169

=== 16 fil(s), 8000000 increments en total ===
Implementacio              |       ms |         inc/ms
---------------------------|----------|---------------
synchronized               |     1842 |           4343
AtomicLong                 |      918 |           8714
LongAdder                  |       94 |          85106
AtomicReference+record     |     1531 |           5225

Instantania COHERENT: prestecs=800000 devolucions=0 multes=0
Els tres camps venen del MATEIX instant, cosa que
tres comptadors independents no poden garantir.