public class Comptador {
    private int valor = 0;
    public void incrementar() {
        valor++;
    }
}

javac Comptador.java
javap -c Comptador

public void incrementar();
  Code:
     0: aload_0            // apilar la referencia 'this'
     1: dup                // duplicar-la (cal dues vegades)
     2: getfield #7        // LLEGIR el camp 'valor'      <-- operacio 1
     5: iconst_1           // apilar la constant 1
     6: iadd               // SUMAR                        <-- operacio 2
     7: putfield #7        // ESCRIURE el camp 'valor'     <-- operacio 3
    10: return

valor++;                     // llegir, sumar, escriure
valor--;                     // idem
valor += 5;                  // idem
saldo = saldo - quantitat;   // idem
if (!mapa.containsKey(k)) {  // COMPROVAR...
    mapa.put(k, v);          // ...DESPRES ACTUAR: un altre fil pot colar-se enmig
}
if (instancia == null) {     // el singleton mandros classic
    instancia = new Servei();
}
llista.add(llista.size(), x);  // llegir mida, despres fer-la servir

public class LongPartit {
    // Sense volatile, en una JVM de 32 bits, un lector podia veure
    // 0x00000000FFFFFFFF: meitat d'un valor i meitat d'un altre.
    private long comptadorPrestecs = 0;

    // Amb volatile, l'escriptura de 64 bits es atomica per especificacio.
    private volatile long comptadorSegur = 0;
}

// El que escrius:
dades = carregarCataleg();    // (1)
llest = true;                 // (2)

// El que el compilador pot generar, perque per a AQUEST fil
// el resultat es indistingible:
llest = true;                 // (2)
dades = carregarCataleg();    // (1)

public class MarcadorSenseVolatile {

    // SENSE volatile. Aqui hi ha el problema.
    private static boolean aturat = false;

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

        Thread treballador = new Thread(() -> {
            long voltes = 0;
            // El JIT pot transformar aixo en 'while (true)' perque
            // dins d'AQUEST fil 'aturat' no canvia mai: es una
            // optimitzacio legal anomenada elevacio (hoisting).
            while (!aturat) {
                voltes++;
            }
            System.out.println("[treballador] aturat despres de " + voltes + " voltes");
        }, "bibliotech-treballador");

        treballador.start();

        Thread.sleep(1000);
        System.out.println("[main] escrivint aturat = true");
        aturat = true;

        treballador.join(3000);
        if (treballador.isAlive()) {
            System.out.println("[main] EL TREBALLADOR NO SE N'HA ASSABENTAT. Continua viu.");
            System.exit(1);
        }
    }
}

[main] escrivint aturat = true
[main] EL TREBALLADOR NO SE N'HA ASSABENTAT. Continua viu.

boolean copia = aturat;       // es llegeix UNA vegada
while (!copia) { voltes++; }  // bucle infinit

[main] escrivint aturat = true
[treballador] aturat despres de 1847239104 voltes

// REGLA start(): main escriu, el fil nou ho veu garantit.
cataleg.carregar();                 // A
Thread f = new Thread(tasca);
f.start();                          // A happens-before tot el del fil nou
// dins de 'tasca': veu el cataleg carregat, segur.

// REGLA join(): el fil escriu, main ho veu garantit.
f.start();
f.join();                           // tot el del fil hb el retorn de join
System.out.println(tasca.resultat());    // valor correcte garantit

// REGLA monitor: transferencia de visibilitat entre seccions critiques.
synchronized (pany) { x = 42; }          // deixar anar hb...
// ... un altre fil:
synchronized (pany) { llegir(x); }       // ...adquirir: veu x == 42

// REGLA volatile + transitivitat: l'idioma de la "publicacio segura".
dades = carregarCataleg();         // (1) escriptura normal
llest = true;                      // (2) escriptura VOLATILE
// ... un altre fil:
if (llest) {                       // (3) lectura VOLATILE
    usar(dades);                   // (4) veu dades correctament. Per que?
}
// (1) hb (2) per ordre del programa;
// (2) hb (3) per la regla volatile;
// (3) hb (4) per ordre del programa;
// per transitivitat: (1) hb (4). L'acces a 'dades' es segur
// ENCARA QUE 'dades' no sigui volatile.

package com.nexussoftware.bibliotech.persistencia;

/**
 * Servei d'importacio amb aturada neta mitjancant marcador volatile.
 * Es el complement de la interrupcio de 08-02: el marcador propi
 * permet una aturada ordenada sense dependre de l'estat d'interrupcio.
 */
public class ServeiImportacio implements Runnable {

    // volatile: escrit pel fil del menu, llegit pel fil treballador.
    // SENSE volatile, el treballador podria no assabentar-se'n MAI (apartat 3.2).
    private volatile boolean aturat = false;

    // Progres publicat cap al fil del menu. Nomes l'escriu AQUEST fil,
    // aixi que no hi ha llegir-modificar-escriure concurrent: volatile n'hi ha prou.
    private volatile int liniesProcessades = 0;

    public void aturar() {
        aturat = true;
    }

    @Override
    public void run() {
        while (!aturat && !Thread.currentThread().isInterrupted()) {
            processarLot();
            liniesProcessades += 1000;    // segur: UN sol escriptor
        }
    }

    public int liniesProcessades() { return liniesProcessades; }

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

public class ComptadorVolatileEncaraTrencat {

    // volatile SI que garanteix que els dos fils vegin el valor mes recent.
    // volatile NO garanteix que 'valor++' sigui indivisible.
    private volatile int valor = 0;

    public void incrementar() {
        valor++;      // continua sent LLEGIR, SUMAR, ESCRIURE
    }

    public int valor() { return valor; }

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

        for (int intent = 1; intent <= 3; intent++) {
            ComptadorVolatileEncaraTrencat c = new ComptadorVolatileEncaraTrencat();

            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.printf("Intent %d: esperat %d, real %d, perduts %d%n",
                    intent, VOLTES * 2, c.valor(), VOLTES * 2 - c.valor());
        }
    }
}

Intent 1: esperat 2000000, real 1223981, perduts 776019
Intent 2: esperat 2000000, real 1341102, perduts 658898
Intent 3: esperat 2000000, real 1189447, perduts 810553

// 'cataleg' volatile garanteix que veus la referencia mes recent...
private volatile List<Material> cataleg = new ArrayList<>();

// ...pero NO protegeix el CONTINGUT de la llista.
cataleg.add(nouLlibre);     // continua sent una cursa de dades

synchronized (objecte) {
    // nomes un fil alhora pot ser aqui
}

public class ComptadorSincronitzat {

    private int valor = 0;

    // Metode sincronitzat d'instancia: adquireix el monitor de 'this'.
    public synchronized void incrementar() {
        valor++;      // ara les tres operacions son indivisibles
                      // respecte a altres fils que facin servir AQUEST monitor
    }

    // TAMBE sincronitzat. Si no ho estigues, un lector podria veure
    // un valor obsolet: l'exclusio mutua sense visibilitat no n'hi ha prou.
    public synchronized int valor() {
        return valor;
    }

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

        for (int intent = 1; intent <= 3; intent++) {
            ComptadorSincronitzat c = new ComptadorSincronitzat();
            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.printf("Intent %d: esperat %d, real %d%n",
                    intent, VOLTES * 2, c.valor());
        }
    }
}

Intent 1: esperat 2000000, real 2000000
Intent 2: esperat 2000000, real 2000000
Intent 3: esperat 2000000, real 2000000

public class Reentrada {

    public synchronized void registrarPrestec(String isbn) {
        validar(isbn);
        // Crida a UN ALTRE metode sincronitzat del MATEIX objecte.
        // Sense reentrada, el fil es bloquejaria a si mateix: interbloqueig
        // instantani amb si mateix.
        actualitzarIndex(isbn);
    }

    public synchronized void actualitzarIndex(String isbn) { /* ... */ }

    private void validar(String isbn) { /* ... */ }
}

public synchronized void afegir(Material m) { /* ... */ }

// Es EXACTAMENT equivalent a:
public void afegir(Material m) {
    synchronized (this) { /* ... */ }
}

public static synchronized void registrarAGlobal(String esdeveniment) { /* ... */ }

// Equivalent a:
public static void registrarAGlobal(String esdeveniment) {
    synchronized (Cataleg.class) { /* ... */ }
}

public class DosMonitorsDiferents {
    private static int comptadorGlobal = 0;

    // Bloqueja 'this'
    public synchronized void incrementarMalament() { comptadorGlobal++; }

    // Bloqueja 'DosMonitorsDiferents.class'
    public static synchronized void incrementarEstatic() { comptadorGlobal++; }

    // Aquests dos metodes NO s'exclouen: fan servir panys diferents.
    // L'estat estatic que comparteixen NO esta protegit. BUG.
}

private final Object pany = new Object();

public void afegir(Material m) {
    // Feina que NO necessita proteccio, fora del bloqueig:
    validar(m);
    String clau = normalitzar(m.isbn());

    synchronized (pany) {
        // Seccio critica: el minim imprescindible
        materials.add(m);
        index.put(clau, m);
    }

    // Mes feina no critica
    registrarAAuditoria(m);
}

public class Cataleg {
    // Pany PRIVAT i FINAL: ningu de fora no el pot adquirir,
    // i ningu no el pot reassignar (un pany reassignat deixa de
    // protegir: dos fils podrien bloquejar objectes diferents).
    private final Object pany = new Object();

    // I no facis servir MAI com a pany una cosa aixi:
    //   private final Integer pany = 42;         // <- pot estar internat
    //   private final String pany = "cat";       // <- literal internat: COMPARTIT
    //   private final Boolean pany = false;      // <- Boolean.FALSE, compartit
    // Un literal String o un Integer petit es un objecte UNIC a tota la JVM:
    // una altra classe que faci servir el mateix literal comparteix el teu pany sense saber-ho.
}

// MALAMENT: 300 ms d'E/S dins del bloqueig. Tots els altres fils esperen.
public void registrarPrestec(Prestec p) {
    synchronized (pany) {
        prestecs.put(p.id(), p);
        escriureAlDisc(p);                // 300 ms d'E/S
        enviarNotificacio(p.empleat());   // 200 ms mes
    }
}

// BE: nomes el canvi d'estat en memoria esta protegit.
public void registrarPrestec(Prestec p) {
    synchronized (pany) {
        prestecs.put(p.id(), p);          // microsegons
    }
    escriureAlDisc(p);                    // fora del bloqueig
    enviarNotificacio(p.empleat());       // fora del bloqueig
}

// PERILLOS: 'oients' conte codi que no controles.
synchronized (pany) {
    for (OientCataleg o : oients) {
        o.materialAfegit(m);     // que fa? bloqueja? crida de tornada?
    }
}

// SEGUR: copiar sota el pany, notificar fora.
List<OientCataleg> copia;
synchronized (pany) {
    copia = new ArrayList<>(oients);
}
for (OientCataleg o : copia) {
    o.materialAfegit(m);         // sense pany: no ens pot bloquejar
}

public class RegistrePrestecs {
    private final Object pany = new Object();

    /** Protegit per 'pany'. */
    private final Map<String, Prestec> perId = new HashMap<>();

    /** Protegit per 'pany'. Invariant: conte els mateixos prestecs que 'perId'. */
    private final Map<Empleat, List<Prestec>> perEmpleat = new HashMap<>();
}

package com.nexussoftware.bibliotech.servei;

import java.util.concurrent.TimeUnit;

public class TransferenciaPrestecs {

    /** Cada empleat te el seu propi pany i la seva llista de prestecs. */
    static class CompteEmpleat {
        final String nom;
        final Object pany = new Object();
        int prestecs;

        CompteEmpleat(String nom, int prestecs) {
            this.nom = nom;
            this.prestecs = prestecs;
        }
    }

    /**
     * VERSIO AMB INTERBLOQUEIG.
     * Bloqueja 'origen' i despres 'desti'. Si dos fils transfereixen
     * en sentits oposats, es forma el cicle.
     */
    static void transferirMalament(CompteEmpleat origen, CompteEmpleat desti, int n) {
        synchronized (origen.pany) {
            dormir(100);                       // amplia la finestra de la fallada
            synchronized (desti.pany) {
                origen.prestecs -= n;
                desti.prestecs += n;
                System.out.printf("  %s -> %s : %d prestecs%n",
                        origen.nom, desti.nom, n);
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        CompteEmpleat marta = new CompteEmpleat("Marta Ruiz", 5);
        CompteEmpleat diego = new CompteEmpleat("Diego Alonso", 5);

        // Fil 1: marta -> diego  (bloqueja marta, despres diego)
        Thread t1 = new Thread(() -> transferirMalament(marta, diego, 1), "fil-marta-diego");
        // Fil 2: diego -> marta  (bloqueja diego, despres marta)  <-- ORDRE INVERS
        Thread t2 = new Thread(() -> transferirMalament(diego, marta, 1), "fil-diego-marta");

        t1.start(); t2.start();

        t1.join(3000);
        t2.join(3000);

        if (t1.isAlive() || t2.isAlive()) {
            System.out.println("INTERBLOQUEIG: els dos fils continuen vius i bloquejats.");
            System.out.println("Estat t1: " + t1.getState());
            System.out.println("Estat t2: " + t2.getState());
            System.exit(1);
        }
    }
}

INTERBLOQUEIG: els dos fils continuen vius i bloquejats.
Estat t1: BLOCKED
Estat t2: BLOCKED

/**
 * VERSIO CORRECTA: ordre global d'adquisicio.
 * Els panys es prenen SEMPRE en ordre creixent d'identityHashCode,
 * independentment de la direccio de la transferencia.
 */
static void transferirBe(CompteEmpleat origen, CompteEmpleat desti, int n) {

    int ho = System.identityHashCode(origen);
    int hd = System.identityHashCode(desti);

    if (ho < hd) {
        synchronized (origen.pany) {
            synchronized (desti.pany) {
                moure(origen, desti, n);
            }
        }
    } else if (ho > hd) {
        synchronized (desti.pany) {       // ordre INVERTIT respecte al negoci,
            synchronized (origen.pany) {  // pero CONSISTENT entre fils
                moure(origen, desti, n);
            }
        }
    } else {
        // Cas rarissim: collisio d'identityHashCode entre dos objectes
        // diferents. Un tercer pany global desempata i garanteix
        // que nomes un fil entri en aquest cami alhora.
        synchronized (PANY_DESEMPAT) {
            synchronized (origen.pany) {
                synchronized (desti.pany) {
                    moure(origen, desti, n);
                }
            }
        }
    }
}

private static final Object PANY_DESEMPAT = new Object();

private static void moure(CompteEmpleat origen, CompteEmpleat desti, int n) {
    origen.prestecs -= n;
    desti.prestecs += n;
}

// Amb identificador natural, molt mes clar:
CompteEmpleat primer = origen.id().compareTo(desti.id()) < 0 ? origen : desti;
CompteEmpleat segon = (primer == origen) ? desti : origen;

synchronized (primer.pany) {
    synchronized (segon.pany) {
        moure(origen, desti, n);
    }
}

import java.util.concurrent.ThreadLocalRandom;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;

public class TransferenciaAmbTryLock {

    static class CompteEmpleat {
        final String nom;
        final ReentrantLock pany = new ReentrantLock();
        int prestecs;
        CompteEmpleat(String nom, int prestecs) {
            this.nom = nom; this.prestecs = prestecs;
        }
    }

    /**
     * Adquireix els dos panys amb termini. Si no aconsegueix tots dos,
     * deixa anar el que tingui, espera un temps ALEATORI i reintenta.
     * L'atzar es essencial: sense ell, dos fils podrien reintentar
     * sincronitzats eternament (livelock, apartat 12).
     */
    static boolean transferir(CompteEmpleat origen, CompteEmpleat desti,
                              int n, int maxIntents) throws InterruptedException {

        for (int intent = 0; intent < maxIntents; intent++) {
            boolean tincOrigen = false;
            boolean tincDesti = false;
            try {
                tincOrigen = origen.pany.tryLock(50, TimeUnit.MILLISECONDS);
                if (tincOrigen) {
                    tincDesti = desti.pany.tryLock(50, TimeUnit.MILLISECONDS);
                }
                if (tincOrigen && tincDesti) {
                    origen.prestecs -= n;
                    desti.prestecs += n;
                    return true;                     // exit
                }
            } finally {
                // SEMPRE deixar anar el que s'ha adquirit, en ordre invers.
                if (tincDesti)  desti.pany.unlock();
                if (tincOrigen) origen.pany.unlock();
            }
            // Retroces aleatori abans de reintentar.
            TimeUnit.MILLISECONDS.sleep(
                    ThreadLocalRandom.current().nextInt(10, 60));
        }
        return false;                                // intents exhaurits
    }
}

// Si les transferencies no son el 90% de la carrega, aixo es
// mes simple, mes segur i probablement igual de rapid.
private static final Object PANY_TRANSFERENCIES = new Object();

static void transferir(CompteEmpleat origen, CompteEmpleat desti, int n) {
    synchronized (PANY_TRANSFERENCIES) {
        origen.prestecs -= n;
        desti.prestecs += n;
    }
}

// El parametre true activa la politica FIFO: el pany es concedeix
// al fil que porta mes temps esperant.
// COST: molt menys rendiment (sovint 10x o mes), perque impedeix
// la reentrada oportunista i forca canvis de context.
// Fes-lo servir nomes si has mesurat inanicio real.
ReentrantLock equitatiu = new ReentrantLock(true);

// LIVELOCK: si els dos fils entren en fase, poden reintentar
// eternament, cedint sempre alhora.
while (true) {
    if (a.tryLock()) {
        if (b.tryLock()) { ferFeina(); return; }
        a.unlock();          // cedeix
    }
    // sense espera aleatoria: els dos fils ho tornen a intentar
    // exactament alhora, una altra vegada, i una altra
}

import java.util.concurrent.locks.ReentrantLock;

public class ComptadorAmbLock {

    private final ReentrantLock pany = new ReentrantLock();
    private int valor = 0;

    public void incrementar() {
        pany.lock();
        try {
            valor++;
        } finally {
            // OBLIGATORI al finally: si el cos llanca una excepcio
            // i l'unlock es fora, el pany NO s'allibera MAI
            // i tota l'aplicacio es bloqueja. Es l'error numero u
            // de ReentrantLock, i el motiu pel qual synchronized
            // continua sent preferible quan no necessites res mes.
            pany.unlock();
        }
    }
}

if (pany.tryLock()) {              // no bloqueja mai
    try { operacio(); } finally { pany.unlock(); }
} else {
    // pla B: encuar, avisar l'usuari, reintentar mes tard
}

try {
    pany.lockInterruptibly();      // respon a interrupt() mentre espera
    try { operacio(); } finally { pany.unlock(); }
} catch (InterruptedException e) {
    Thread.currentThread().interrupt();
}

package com.nexussoftware.bibliotech.servei;

import java.util.ArrayDeque;
import java.util.Deque;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

/**
 * Cua acotada de reserves amb dues condicions separades.
 *
 * Avantatge sobre wait/notifyAll (08-03): en alliberar un forat nomes es
 * desperta un PRODUCTOR, i en afegir un element nomes un CONSUMIDOR.
 * Amb notifyAll es despertaven tots i la majoria es tornava a adormir.
 *
 * NOTA: en produccio faries servir ArrayBlockingQueue (08-06), que es
 * exactament aixo ja implementat i provat.
 */
public class CuaReservesAmbCondition {

    private final ReentrantLock pany = new ReentrantLock();

    // DUES condicions sobre el MATEIX pany.
    private final Condition hiHaForat   = pany.newCondition();
    private final Condition hiHaElement = pany.newCondition();

    private final Deque<String> cua = new ArrayDeque<>();
    private final int capacitat;

    public CuaReservesAmbCondition(int capacitat) {
        this.capacitat = capacitat;
    }

    public void posar(String reserva) throws InterruptedException {
        pany.lock();
        try {
            // WHILE, igual que amb wait(): les mateixes tres raons de 08-03.
            while (cua.size() == capacitat) {
                hiHaForat.await();         // deixa anar el pany i espera
            }
            cua.addLast(reserva);
            hiHaElement.signal();          // desperta UN consumidor.
                                           // Segur: en aquesta cua nomes esperen
                                           // consumidors, i tots son
                                           // intercanviables.
        } finally {
            pany.unlock();
        }
    }

    public String prendre() throws InterruptedException {
        pany.lock();
        try {
            while (cua.isEmpty()) {
                hiHaElement.await();
            }
            String r = cua.pollFirst();
            hiHaForat.signal();            // desperta UN productor
            return r;
        } finally {
            pany.unlock();
        }
    }

    public int mida() {
        pany.lock();
        try {
            return cua.size();
        } finally {
            pany.unlock();
        }
    }
}

package com.nexussoftware.bibliotech.servei;

import com.nexussoftware.bibliotech.domini.Material;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * Cataleg segur per a diversos fils, optimitzat per a lectura.
 *
 * Justificacio del ReadWriteLock: a BiblioTech es consulta el cataleg
 * desenes de vegades per cada alta (cercar per ISBN, llistar, filtrar per tipus),
 * i les altes arriben en lots durant la importacio.
 */
public class CatalegSegur {

    private final ReentrantReadWriteLock pany = new ReentrantReadWriteLock();
    private final ReentrantReadWriteLock.ReadLock  lectura    = pany.readLock();
    private final ReentrantReadWriteLock.WriteLock escriptura = pany.writeLock();

    /** Protegit per 'pany'. */
    private final List<Material> materials = new ArrayList<>();
    /** Protegit per 'pany'. Invariant: una entrada per material. */
    private final Map<String, Material> index = new HashMap<>();
    /** Protegit per 'pany'. Invariant: mateixos ISBN que 'index'. */
    private final Set<String> isbnRegistrats = new HashSet<>();

    // ---------- ESCRIPTURES: pany exclusiu ----------

    public boolean afegir(Material m) {
        escriptura.lock();
        try {
            if (!isbnRegistrats.add(m.isbn())) {
                return false;                // ja existia
            }
            materials.add(m);
            index.put(m.isbn(), m);
            return true;
        } finally {
            escriptura.unlock();
        }
    }

    public boolean eliminar(String isbn) {
        escriptura.lock();
        try {
            Material m = index.remove(isbn);
            if (m == null) return false;
            materials.remove(m);
            isbnRegistrats.remove(isbn);
            return true;
        } finally {
            escriptura.unlock();
        }
    }

    /** Substitucio atomica completa: el que fa servir la importacio de 08-02. */
    public void substituirTot(List<Material> nous) {
        escriptura.lock();
        try {
            materials.clear();
            index.clear();
            isbnRegistrats.clear();
            for (Material m : nous) {
                if (isbnRegistrats.add(m.isbn())) {
                    materials.add(m);
                    index.put(m.isbn(), m);
                }
            }
        } finally {
            escriptura.unlock();
        }
    }

    // ---------- LECTURES: pany compartit ----------

    public Material cercarPerIsbn(String isbn) {
        lectura.lock();
        try {
            return index.get(isbn);
        } finally {
            lectura.unlock();
        }
    }

    public int mida() {
        lectura.lock();
        try {
            return materials.size();
        } finally {
            lectura.unlock();
        }
    }

    /**
     * Retorna una COPIA. Retornar la llista interna seria una fallada de
     * seguretat de fils: qui la rebi podria iterar-la sense pany
     * mentre un altre fil la modifica -> ConcurrentModificationException
     * (05-02) o alguna cosa pitjor.
     */
    public List<Material> llistar() {
        lectura.lock();
        try {
            return new ArrayList<>(materials);    // copia sota el pany
        } finally {
            lectura.unlock();
        }
    }
}

// PROHIBIT: promocio. Es penja per sempre.
lectura.lock();
escriptura.lock();    // espera que es deixin anar TOTES les lectures,
                      // inclosa la NOSTRA. Interbloqueig.

// PERMES: degradacio (escriptura -> lectura).
escriptura.lock();
try {
    modificar();
    lectura.lock();        // adquirir lectura ABANS de deixar anar escriptura
} finally {
    escriptura.unlock();   // ara nomes tenim lectura
}
try {
    llegirElQueAcabemDEscriure();
} finally {
    lectura.unlock();
}

// PUBLICACIO INSEGURA
public class Registre {
    public static Cataleg instancia;     // sense volatile, sense final

    public static void inicialitzar() {
        instancia = new Cataleg();       // (1) reservar (2) construir (3) assignar
        // Les fases (2) i (3) es poden REORDENAR: un altre fil pot veure
        // 'instancia' no nulla apuntant a un objecte sense construir.
    }
}

package com.nexussoftware.bibliotech.domini;

/**
 * Fitxa immutable: tots els seus camps son final pel fet de ser un record.
 * Compartible entre qualsevol nombre de fils sense sincronitzacio.
 */
public record Fitxa(String isbn, String titol, String autor, int exemplars) { }

/**
 * ResumSessio immutable. Compte: si un record conte una colleccio,
 * la colleccio ha de ser tambe immutable, o el record nomes es
 * "superficialment" immutable.
 */
public record ResumSessio(long iniciMs, long fiMs,
                          int prestecs, int devolucions,
                          List<String> incidencies) {

    /** Constructor compacte amb copia defensiva: fa la llista immutable. */
    public ResumSessio {
        incidencies = List.copyOf(incidencies);   // copia IMMUTABLE
    }
}

public class EstadistiquesBiblioTech {

    /** Instantania immutable de les estadistiques. */
    public record Instantania(long prestecs, long devolucions, long multes) {
        Instantania ambPrestec()   { return new Instantania(prestecs + 1, devolucions, multes); }
        Instantania ambDevolucio() { return new Instantania(prestecs, devolucions + 1, multes); }
    }

    // La REFERENCIA es volatile: els lectors sempre veuen una
    // instantania completa i coherent, mai una a mitges.
    private volatile Instantania actual = new Instantania(0, 0, 0);

    /** Lectura sense cap bloqueig: coherent per immutabilitat. */
    public Instantania instantania() {
        return actual;
    }

    /**
     * L'escriptura SI que necessita sincronitzacio: 'actual = actual.ambPrestec()'
     * es llegir-modificar-escriure, i volatile no ho fa atomic (apartat 6).
     * A 08-06 aixo es resoldra amb AtomicReference.updateAndGet, sense pany.
     */
    public synchronized void registrarPrestec() {
        actual = actual.ambPrestec();
    }
}

public Informe processarLot(List<String> linies) {
    // TOT local: cada fil te la seva propia llista i el seu propi comptador.
    // Cap pany, cap cursa possible.
    List<Material> acceptats = new ArrayList<>();
    int descartats = 0;

    for (String l : linies) {
        try {
            acceptats.add(lector.aMaterial(l));
        } catch (FormatInvalidException e) {
            descartats++;
        }
    }
    // L'unic punt de contacte amb estat compartit, i esta protegit:
    cataleg.afegirTots(acceptats);
    return new Informe(acceptats.size(), descartats);
}

import java.text.NumberFormat;
import java.util.Locale;

public class FormatMultes {

    // NumberFormat NO es segur per a diversos fils: compartir una instancia
    // produeix resultats corruptes sota carrega (un classic molt dificil de
    // diagnosticar perque falla poc i de forma silenciosa).
    // ThreadLocal dona una instancia per fil: segur i sense panys.
    private static final ThreadLocal<NumberFormat> FORMAT =
            ThreadLocal.withInitial(() -> NumberFormat.getCurrencyInstance(
                    Locale.forLanguageTag("ca-ES")));

    public static String formatar(double quantitat) {
        return FORMAT.get().format(quantitat);
    }

    /**
     * IMPORTANT: en un pool de fils (08-05) els fils es reutilitzen
     * indefinidament, aixi que un ThreadLocal no s'allibera mai sol.
     * Si desa alguna cosa gran o sensible, cal netejar-lo:
     */
    public static void netejar() {
        FORMAT.remove();
    }
}

// Cada fil processa EL SEU tros i produeix EL SEU resultat parcial.
// No hi ha estat compartit durant el calcul, nomes en combinar.
// Es el model de ForkJoinPool (08-05) i dels streams parallels (10-04).
List<Informe> parcials = new ArrayList<>();
// ... cada fil retorna el seu Informe, i al final:
Informe total = combinar(parcials);   // un sol fil, sense panys

package com.nexussoftware.bibliotech.servei;

import com.nexussoftware.bibliotech.domini.Empleat;
import com.nexussoftware.bibliotech.domini.Prestec;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * Registre de prestecs segur per a diversos fils.
 *
 * POLITICA DE SINCRONITZACIO
 * --------------------------
 * Tot l'estat mutable esta protegit per 'pany'.
 * Les consultes fan servir el pany de lectura (compartit);
 * les modificacions, el d'escriptura (exclusiu).
 *
 * INVARIANT: 'perId' i 'perEmpleat' contenen exactament el mateix
 * conjunt de prestecs. Aquest invariant abasta DUES estructures, i per
 * aixo no n'hi ha prou amb fer servir dos ConcurrentHashMap (08-06): caldria que
 * les dues actualitzacions fossin una sola operacio atomica, i aixo nomes
 * ho dona un pany.
 */
public class RegistrePrestecsSegur {

    private final ReentrantReadWriteLock pany = new ReentrantReadWriteLock();
    private final ReentrantReadWriteLock.ReadLock  lectura    = pany.readLock();
    private final ReentrantReadWriteLock.WriteLock escriptura = pany.writeLock();

    /** Protegit per 'pany'. */
    private final Map<String, Prestec> perId = new HashMap<>();
    /** Protegit per 'pany'. Invariant: coherent amb 'perId'. */
    private final Map<Empleat, List<Prestec>> perEmpleat = new HashMap<>();

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

    /**
     * Registra un prestec. Les dues actualitzacions ocorren sota el mateix
     * pany, aixi que cap lector no pot veure l'estat intermedi en el
     * qual el prestec es a 'perId' pero encara no a 'perEmpleat'.
     */
    public void registrar(Prestec p) {
        escriptura.lock();
        try {
            if (perId.putIfAbsent(p.id(), p) != null) {
                throw new IllegalStateException("Prestec duplicat: " + p.id());
            }
            perEmpleat.computeIfAbsent(p.empleat(), e -> new ArrayList<>()).add(p);
        } finally {
            escriptura.unlock();
        }
    }

    public Prestec retornar(String idPrestec) {
        escriptura.lock();
        try {
            Prestec p = perId.remove(idPrestec);
            if (p == null) {
                throw new PrestecNoTrobatException(idPrestec);
            }
            List<Prestec> dEmpleat = perEmpleat.get(p.empleat());
            if (dEmpleat != null) {
                dEmpleat.remove(p);
                if (dEmpleat.isEmpty()) {
                    perEmpleat.remove(p.empleat());     // no deixar llistes buides
                }
            }
            return p;
        } finally {
            escriptura.unlock();
        }
    }

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

    public Prestec cercar(String idPrestec) {
        lectura.lock();
        try {
            return perId.get(idPrestec);
        } finally {
            lectura.unlock();
        }
    }

    /** Retorna una COPIA: la llista interna no surt mai del pany. */
    public List<Prestec> prestecsDe(Empleat e) {
        lectura.lock();
        try {
            List<Prestec> l = perEmpleat.get(e);
            return l == null ? List.of() : new ArrayList<>(l);
        } finally {
            lectura.unlock();
        }
    }

    public int actius() {
        lectura.lock();
        try {
            return perId.size();
        } finally {
            lectura.unlock();
        }
    }

    /**
     * OPERACIO COMPOSTA ATOMICA.
     *
     * Aquest metode existeix precisament perque fer-ho des de fora seria
     * un comprovar-despres-actuar insegur:
     *
     *     if (registre.actius() < MAX) registre.registrar(p);   // BUG
     *
     * Entre la comprovacio i l'accio, un altre fil pot registrar i
     * superar el limit. Encapsular l'operacio completa dins del
     * pany es l'unica forma correcta.
     */
    public boolean registrarSiHiHaLloc(Prestec p, int maximPerEmpleat) {
        escriptura.lock();
        try {
            List<Prestec> actuals = perEmpleat.get(p.empleat());
            if (actuals != null && actuals.size() >= maximPerEmpleat) {
                return false;
            }
            perId.put(p.id(), p);
            perEmpleat.computeIfAbsent(p.empleat(), e -> new ArrayList<>()).add(p);
            return true;
        } finally {
            escriptura.unlock();
        }
    }
}

package com.nexussoftware.bibliotech.servei;

import java.util.concurrent.TimeUnit;

public class ProvaConcurrenciaRegistre {

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

        final int FILS = 8;
        final int PER_FIL = 5_000;

        RegistrePrestecsSegur registre = new RegistrePrestecsSegur();
        Empleat marta = new Empleat("E-001", "Marta Ruiz");

        Thread[] fils = new Thread[FILS];
        long inici = System.nanoTime();

        for (int f = 0; f < FILS; f++) {
            final int idFil = f;
            fils[f] = new Thread(() -> {
                for (int i = 0; i < PER_FIL; i++) {
                    registre.registrar(new Prestec(
                            "P-" + idFil + "-" + i, marta, "978-0000000001"));
                }
            }, "bibliotech-registrador-" + f);
            fils[f].start();
        }

        for (Thread f : fils) f.join();

        long ms = (System.nanoTime() - inici) / 1_000_000;
        int esperat = FILS * PER_FIL;
        int real = registre.actius();
        int aLlista = registre.prestecsDe(marta).size();

        System.out.println("Esperats            : " + esperat);
        System.out.println("A perId             : " + real);
        System.out.println("A perEmpleat        : " + aLlista);
        System.out.println("Invariant coherent  : " + (real == aLlista));
        System.out.println("Temps               : " + ms + " ms");
        System.out.println(real == esperat && real == aLlista
                ? "CORRECTE"
                : "FALLADA: hi ha una cursa de dades");
    }
}

Esperats            : 40000
A perId             : 40000
A perEmpleat        : 40000
Invariant coherent  : true
Temps               : 187 ms
CORRECTE

import java.util.concurrent.locks.ReentrantLock;

public class ComparativaComptadors {

    interface Comptador {
        void incrementar();
        long valor();
        String nom();
    }

    /** 1. INSEGUR: valor++ es llegir-modificar-escriure sense proteccio. */
    static class ComptadorInsegur implements Comptador {
        private long valor = 0;
        public void incrementar() { valor++; }
        public long valor() { return valor; }
        public String nom() { return "int simple"; }
    }

    /** 2. VOLATILE: resol la visibilitat, NO l'atomicitat. */
    static class ComptadorVolatile implements Comptador {
        private volatile long valor = 0;
        public void incrementar() { valor++; }
        public long valor() { return valor; }
        public String nom() { return "volatile"; }
    }

    /** 3. SYNCHRONIZED: exclusio mutua + visibilitat. Correcte. */
    static class ComptadorSincronitzat implements Comptador {
        private long valor = 0;
        public synchronized void incrementar() { valor++; }
        // El getter TAMBE sincronitzat: sense ell, un lector podria
        // veure un valor obsolet de la seva memoria cau.
        public synchronized long valor() { return valor; }
        public String nom() { return "synchronized"; }
    }

    /** 4. REENTRANTLOCK: equivalent, amb unlock al finally. */
    static class ComptadorAmbLock implements Comptador {
        private final ReentrantLock pany = new ReentrantLock();
        private long valor = 0;

        public void incrementar() {
            pany.lock();                  // FORA del try
            try { valor++; }
            finally { pany.unlock(); }    // SEMPRE al finally
        }

        public long valor() {
            pany.lock();
            try { return valor; }
            finally { pany.unlock(); }
        }
        public String nom() { return "ReentrantLock"; }
    }

    static long mesurar(Comptador c, int fils, int perFil) throws InterruptedException {
        Thread[] ts = new Thread[fils];
        long inici = System.nanoTime();
        for (int i = 0; i < fils; i++) {
            ts[i] = new Thread(() -> {
                for (int j = 0; j < perFil; j++) c.incrementar();
            }, "sumador-" + i);
            ts[i].start();
        }
        for (Thread t : ts) t.join();
        return System.nanoTime() - inici;
    }

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

        final int FILS = 8;
        final int PER_FIL = 500_000;
        final long ESPERAT = (long) FILS * PER_FIL;

        Comptador[] comptadors = {
                new ComptadorInsegur(), new ComptadorVolatile(),
                new ComptadorSincronitzat(), new ComptadorAmbLock()
        };

        // Escalfament: sense ell, les primeres implementacions paguen
        // la compilacio JIT i la comparacio no es justa.
        for (Comptador c : comptadors) mesurar(c, 2, 10_000);

        System.out.printf("%-16s | %12s | %10s | %8s | %12s%n",
                "Implementacio", "Resultat", "Perduts", "ms", "inc/ms");
        System.out.println("-----------------|--------------|------------|----------|-------------");

        for (Comptador plantilla : comptadors) {
            // Instancia nova per no arrossegar l'escalfament.
            Comptador c = switch (plantilla.nom()) {
                case "int simple"    -> new ComptadorInsegur();
                case "volatile"      -> new ComptadorVolatile();
                case "synchronized"  -> new ComptadorSincronitzat();
                default              -> new ComptadorAmbLock();
            };

            long ns = mesurar(c, FILS, PER_FIL);
            long ms = ns / 1_000_000;
            long perduts = ESPERAT - c.valor();

            System.out.printf("%-16s | %12d | %10d | %8d | %12d%s%n",
                    c.nom(), c.valor(), perduts, ms,
                    ms == 0 ? 0 : c.valor() / ms,
                    perduts == 0 ? "" : "   <-- INCORRECTE");
        }
    }
}

Implementacio    |     Resultat |    Perduts |       ms |       inc/ms
-----------------|--------------|------------|----------|-------------
int simple       |      1284471 |    2715529 |       31 |        41434   <-- INCORRECTE
volatile         |      1893204 |    2106796 |      142 |        13332   <-- INCORRECTE
synchronized     |      4000000 |          0 |      213 |        18779
ReentrantLock    |      4000000 |          0 |      205 |        19512

package com.nexussoftware.bibliotech.servei;

import java.util.concurrent.ThreadLocalRandom;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.ReentrantLock;

public class ReservaDobleSala {

    /** Sala amb pany intrinsec i pany explicit, per a les tres versions. */
    static class SalaReunions {
        final String id;
        final Object pany = new Object();
        final ReentrantLock lock = new ReentrantLock();
        int reserves = 0;

        SalaReunions(String id) { this.id = id; }
    }

    // ---------- 1. VERSIO AMB INTERBLOQUEIG ----------

    static void reservarMalament(SalaReunions a, SalaReunions b) {
        synchronized (a.pany) {
            dormir(100);                    // amplia la finestra de la fallada
            synchronized (b.pany) {
                a.reserves++;
                b.reserves++;
            }
        }
    }

    // ---------- 2. ORDRE GLOBAL D'ADQUISICIO ----------

    /**
     * Els panys es prenen SEMPRE en ordre creixent d''id'.
     * Sense espera circular no pot haver-hi interbloqueig: es una
     * garantia estructural, no una probabilitat.
     */
    static void reservarBe(SalaReunions a, SalaReunions b) {
        SalaReunions primera = a.id.compareTo(b.id) <= 0 ? a : b;
        SalaReunions segona = (primera == a) ? b : a;

        synchronized (primera.pany) {
            dormir(1);
            synchronized (segona.pany) {
                a.reserves++;
                b.reserves++;
            }
        }
    }

    // ---------- 3. TRYLOCK AMB RETROCES ALEATORI ----------

    static int reservarAmbTryLock(SalaReunions a, SalaReunions b, int maxIntents)
            throws InterruptedException {

        for (int intent = 1; intent <= maxIntents; intent++) {
            boolean tincA = false, tincB = false;
            try {
                tincA = a.lock.tryLock(50, TimeUnit.MILLISECONDS);
                if (tincA) {
                    tincB = b.lock.tryLock(50, TimeUnit.MILLISECONDS);
                }
                if (tincA && tincB) {
                    a.reserves++;
                    b.reserves++;
                    return intent;                   // exit: retornem l'intent
                }
            } finally {
                if (tincB) b.lock.unlock();
                if (tincA) a.lock.unlock();
            }
            // Retroces ALEATORI: sense ell, dos fils en fase reintentarien
            // eternament alhora (livelock, apartat 12).
            TimeUnit.MILLISECONDS.sleep(ThreadLocalRandom.current().nextInt(5, 40));
        }
        return -1;                                    // no s'ha aconseguit
    }

    // ---------- DEMOSTRACIO ----------

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

        // --- 1. Provocar l'interbloqueig ---
        System.out.println("=== 1. VERSIO AMB INTERBLOQUEIG ===");
        SalaReunions s1 = new SalaReunions("SALA-A");
        SalaReunions s2 = new SalaReunions("SALA-B");

        Thread t1 = new Thread(() -> reservarMalament(s1, s2), "fil-A-B");
        Thread t2 = new Thread(() -> reservarMalament(s2, s1), "fil-B-A");
        t1.start(); t2.start();
        t1.join(3000); t2.join(3000);

        if (t1.isAlive() || t2.isAlive()) {
            System.out.println("  INTERBLOQUEJAT. t1=" + t1.getState()
                    + "  t2=" + t2.getState());
            System.out.println("  (jstack diria: Found one Java-level deadlock)");
        } else {
            System.out.println("  Aquesta vegada no ha passat; reintenta-ho. "
                    + "La intermitencia es exactament el problema.");
        }

        // --- 2. Ordre global: 1.000 intents amb 8 fils ---
        System.out.println();
        System.out.println("=== 2. ORDRE GLOBAL D'ADQUISICIO ===");
        SalaReunions a = new SalaReunions("SALA-A");
        SalaReunions b = new SalaReunions("SALA-B");

        Thread[] fils = new Thread[8];
        for (int i = 0; i < 8; i++) {
            final boolean directe = (i % 2 == 0);
            fils[i] = new Thread(() -> {
                for (int k = 0; k < 125; k++) {
                    if (directe) reservarBe(a, b);
                    else         reservarBe(b, a);     // sentit oposat
                }
            }, "reservador-" + i);
            fils[i].start();
        }
        for (Thread f : fils) f.join(20_000);

        boolean alguViu = false;
        for (Thread f : fils) alguViu |= f.isAlive();

        System.out.println("  Reserves SALA-A: " + a.reserves);
        System.out.println("  Reserves SALA-B: " + b.reserves);
        System.out.println("  Algun fil bloquejat: " + alguViu);
        System.out.println(alguViu ? "  FALLADA" : "  CORRECTE: 1.000 reserves sense interbloqueig");

        // --- 3. tryLock amb retroces ---
        System.out.println();
        System.out.println("=== 3. TRYLOCK AMB RETROCES ALEATORI ===");
        SalaReunions c = new SalaReunions("SALA-C");
        SalaReunions d = new SalaReunions("SALA-D");

        AtomicInteger reintentsTotals = new AtomicInteger();
        AtomicInteger fracassos = new AtomicInteger();

        Thread[] ts = new Thread[4];
        for (int i = 0; i < 4; i++) {
            final boolean directe = (i % 2 == 0);
            ts[i] = new Thread(() -> {
                for (int k = 0; k < 50; k++) {
                    try {
                        int intents = directe
                                ? reservarAmbTryLock(c, d, 10)
                                : reservarAmbTryLock(d, c, 10);
                        if (intents < 0) fracassos.incrementAndGet();
                        else reintentsTotals.addAndGet(intents - 1);
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                        return;
                    }
                }
            }, "trylock-" + i);
            ts[i].start();
        }
        for (Thread t : ts) t.join();

        System.out.println("  Reserves SALA-C   : " + c.reserves);
        System.out.println("  Reserves SALA-D   : " + d.reserves);
        System.out.println("  Reintents totals  : " + reintentsTotals.get());
        System.out.println("  Fracassos         : " + fracassos.get());
        System.out.println("  (els reintents son el preu de no imposar un ordre)");
    }

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

=== 1. VERSIO AMB INTERBLOQUEIG ===
  INTERBLOQUEJAT. t1=BLOCKED  t2=BLOCKED
  (jstack diria: Found one Java-level deadlock)

=== 2. ORDRE GLOBAL D'ADQUISICIO ===
  Reserves SALA-A: 1000
  Reserves SALA-B: 1000
  Algun fil bloquejat: false
  CORRECTE: 1.000 reserves sense interbloqueig

=== 3. TRYLOCK AMB RETROCES ALEATORI ===
  Reserves SALA-C   : 200
  Reserves SALA-D   : 200
  Reintents totals  : 37
  Fracassos         : 0

package com.nexussoftware.bibliotech.servei;

import com.nexussoftware.bibliotech.domini.Fitxa;

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

/**
 * Cache de fitxes segura per a diversos fils, optimitzada per a lectura.
 *
 * POLITICA: tot l'estat esta protegit per 'pany'.
 * Les consultes que encerten fan servir el pany de LECTURA (compartit);
 * nomes les fallades escalen al d'ESCRIPTURA (exclusiu).
 */
public class CacheFitxesSegura {

    private final ReentrantReadWriteLock pany = new ReentrantReadWriteLock();
    private final ReentrantReadWriteLock.ReadLock  lectura    = pany.readLock();
    private final ReentrantReadWriteLock.WriteLock escriptura = pany.writeLock();

    /** Protegit per 'pany'. */
    private final Map<String, Fitxa> cache = new HashMap<>();
    /** Protegits per 'pany'. */
    private long encerts = 0;
    private long fallades = 0;

    public Fitxa obtenir(String isbn) {

        // FASE 1: intent optimista amb pany COMPARTIT.
        // Diversos fils poden ser aqui alhora, que es el 96% del transit.
        lectura.lock();
        try {
            Fitxa f = cache.get(isbn);
            if (f != null) {
                // COMPTE: 'encerts++' sota el pany de LECTURA seria una
                // cursa: diversos lectors simultanis farien
                // llegir-modificar-escriure alhora. Ho comptem a la fase 2.
                return f;
            }
        } finally {
            lectura.unlock();
        }

        // FASE 2: fallada. Calculem FORA de tot pany (regla 2 de
        // l'apartat 9: mai operacions lentes dins del bloqueig).
        Fitxa calculada = calcular(isbn);

        // FASE 3: publicacio amb pany EXCLUSIU.
        escriptura.lock();
        try {
            // Re-comprovem: entre la fase 1 i la 3 un altre fil ha pogut
            // calcular la mateixa fitxa. putIfAbsent conserva la primera
            // i mante la coherencia del recompte.
            Fitxa jaPosada = cache.putIfAbsent(isbn, calculada);
            if (jaPosada != null) {
                encerts++;                   // un altre fil ens ha guanyat la cursa
                return jaPosada;
            }
            fallades++;
            return calculada;
        } finally {
            escriptura.unlock();
        }
    }

    public void invalidar(String isbn) {
        escriptura.lock();
        try { cache.remove(isbn); }
        finally { escriptura.unlock(); }
    }

    public int mida() {
        lectura.lock();
        try { return cache.size(); }
        finally { lectura.unlock(); }
    }

    public String estadistiques() {
        lectura.lock();
        try {
            long total = encerts + fallades;
            return String.format("encerts=%d fallades=%d taxa=%.1f%%",
                    encerts, fallades, total == 0 ? 0.0 : 100.0 * encerts / total);
        } finally {
            lectura.unlock();
        }
    }

    /** Simula el cost real de construir una fitxa (consulta + formatatge). */
    private Fitxa calcular(String isbn) {
        try { TimeUnit.MILLISECONDS.sleep(20); }
        catch (InterruptedException e) { Thread.currentThread().interrupt(); }
        return new Fitxa(isbn, "Titol de " + isbn, "Autor", 3);
    }

    // ---------- VERSIO DE CONTRAST: un sol pany exclusiu ----------

    public static class CacheFitxesSincronitzada {
        private final Map<String, Fitxa> cache = new HashMap<>();

        // TOT el metode sincronitzat, INCLOS el calcul de 20 ms.
        // Es l'error de la regla 2 de l'apartat 9, a proposit.
        public synchronized Fitxa obtenir(String isbn) {
            Fitxa f = cache.get(isbn);
            if (f == null) {
                try { TimeUnit.MILLISECONDS.sleep(20); }
                catch (InterruptedException e) { Thread.currentThread().interrupt(); }
                f = new Fitxa(isbn, "Titol de " + isbn, "Autor", 3);
                cache.put(isbn, f);
            }
            return f;
        }

        public synchronized int mida() { return cache.size(); }
    }

    // ---------- PROVA ----------

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

        final int FILS = 10;
        final int CONSULTES = 2_000;
        final int ISBNS = 50;

        // --- Versio amb ReadWriteLock ---
        CacheFitxesSegura rw = new CacheFitxesSegura();
        long msRw = executar(FILS, CONSULTES, ISBNS, isbn -> rw.obtenir(isbn));

        System.out.println("=== ReadWriteLock ===");
        System.out.println("  Temps    : " + msRw + " ms");
        System.out.println("  Entrades : " + rw.mida());
        System.out.println("  " + rw.estadistiques());

        // --- Versio amb synchronized total ---
        CacheFitxesSincronitzada sy = new CacheFitxesSincronitzada();
        long msSy = executar(FILS, CONSULTES, ISBNS, isbn -> sy.obtenir(isbn));

        System.out.println();
        System.out.println("=== synchronized total ===");
        System.out.println("  Temps    : " + msSy + " ms");
        System.out.println("  Entrades : " + sy.mida());

        System.out.println();
        System.out.printf("Relacio: %.1fx a favor del ReadWriteLock%n",
                (double) msSy / msRw);
    }

    interface Consulta { Fitxa obtenir(String isbn); }

    static long executar(int fils, int consultes, int isbns, Consulta c)
            throws InterruptedException {
        Thread[] ts = new Thread[fils];
        long inici = System.nanoTime();
        for (int i = 0; i < fils; i++) {
            ts[i] = new Thread(() -> {
                for (int k = 0; k < consultes; k++) {
                    c.obtenir("978-" + String.format("%010d", k % isbns));
                }
            }, "consultor-" + i);
            ts[i].start();
        }
        for (Thread t : ts) t.join();
        return (System.nanoTime() - inici) / 1_000_000;
    }
}

=== ReadWriteLock ===
  Temps    : 152 ms
  Entrades : 50
  encerts=19 fallades=50 taxa=27.5%

=== synchronized total ===
  Temps    : 1043 ms
  Entrades : 50

Relacio: 6.9x a favor del ReadWriteLock