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

javac Contador.java
javap -c Contador

public void incrementar();
  Code:
     0: aload_0            // apilar la referencia 'this'
     1: dup                // duplicarla (hace falta dos veces)
     2: getfield #7        // LEER  el campo 'valor'  <-- operacion 1
     5: iconst_1           // apilar la constante 1
     6: iadd               // SUMAR                    <-- operacion 2
     7: putfield #7        // ESCRIBIR el campo 'valor'<-- operacion 3
    10: return

valor++;                     // leer, sumar, escribir
valor--;                     // idem
valor += 5;                  // idem
saldo = saldo - importe;     // idem
if (!mapa.containsKey(k)) {  // COMPROBAR...
    mapa.put(k, v);          // ...LUEGO ACTUAR: otro hilo puede colarse en medio
}
if (instancia == null) {     // el singleton perezoso clasico
    instancia = new Servicio();
}
lista.add(lista.size(), x);  // leer tamano, luego usarlo

public class LongPartido {
    // Sin volatile, en una JVM de 32 bits, un lector podia ver
    // 0x00000000FFFFFFFF: mitad de un valor y mitad de otro.
    private long contadorPrestamos = 0;

    // Con volatile, la escritura de 64 bits es atomica por especificacion.
    private volatile long contadorSeguro = 0;
}

// Lo que escribes:
datos = cargarCatalogo();     // (1)
listo = true;                 // (2)

// Lo que el compilador puede generar, porque para ESTE hilo
// el resultado es indistinguible:
listo = true;                 // (2)
datos = cargarCatalogo();     // (1)

public class BanderaSinVolatile {

    // SIN volatile. Ahi esta el problema.
    private static boolean detener = false;

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

        Thread trabajador = new Thread(() -> {
            long vueltas = 0;
            // El JIT puede transformar esto en 'while (true)' porque
            // dentro de ESTE hilo 'detener' nunca cambia: es una
            // optimizacion legal llamada elevacion (hoisting).
            while (!detener) {
                vueltas++;
            }
            System.out.println("[trabajador] parado tras " + vueltas + " vueltas");
        }, "bibliotech-trabajador");

        trabajador.start();

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

        trabajador.join(3000);
        if (trabajador.isAlive()) {
            System.out.println("[main] EL TRABAJADOR NO SE HA ENTERADO. Sigue vivo.");
            System.exit(1);
        }
    }
}

[main] escribiendo detener = true
[main] EL TRABAJADOR NO SE HA ENTERADO. Sigue vivo.

boolean copia = detener;      // se lee UNA vez
while (!copia) { vueltas++; } // bucle infinito

[main] escribiendo detener = true
[trabajador] parado tras 1847239104 vueltas

// REGLA start(): main escribe, el hilo nuevo lo ve garantizado.
catalogo.cargar();                  // A
Thread h = new Thread(tarea);
h.start();                          // A happens-before todo lo del hilo nuevo
// dentro de 'tarea': ve el catalogo cargado, seguro.

// REGLA join(): el hilo escribe, main lo ve garantizado.
h.start();
h.join();                           // todo lo del hilo hb el retorno de join
System.out.println(tarea.resultado());   // valor correcto garantizado

// REGLA monitor: transferencia de visibilidad entre secciones criticas.
synchronized (candado) { x = 42; }       // soltar hb...
// ... otro hilo:
synchronized (candado) { leer(x); }      // ...adquirir: ve x == 42

// REGLA volatile + transitividad: el idioma de la "publicacion segura".
datos = cargarCatalogo();          // (1) escritura normal
listo = true;                      // (2) escritura VOLATILE
// ... otro hilo:
if (listo) {                       // (3) lectura VOLATILE
    usar(datos);                   // (4) ve datos correctamente. ¿Por que?
}
// (1) hb (2) por orden del programa;
// (2) hb (3) por la regla volatile;
// (3) hb (4) por orden del programa;
// por transitividad: (1) hb (4). El acceso a 'datos' es seguro
// AUNQUE 'datos' no sea volatile.

package com.nexussoftware.bibliotech.persistencia;

/**
 * Servicio de importacion con parada limpia mediante bandera volatile.
 * Es el complemento de la interrupcion de 08-02: la bandera propia
 * permite una parada ordenada sin depender del estado de interrupcion.
 */
public class ServicioImportacion implements Runnable {

    // volatile: escrito por el hilo del menu, leido por el hilo trabajador.
    // SIN volatile, el trabajador podria no enterarse NUNCA (apartado 3.2).
    private volatile boolean detener = false;

    // Progreso publicado hacia el hilo del menu. Solo lo escribe ESTE hilo,
    // asi que no hay leer-modificar-escribir concurrente: volatile basta.
    private volatile int lineasProcesadas = 0;

    public void detener() {
        detener = true;
    }

    @Override
    public void run() {
        while (!detener && !Thread.currentThread().isInterrupted()) {
            procesarLote();
            lineasProcesadas += 1000;     // seguro: UN solo escritor
        }
    }

    public int lineasProcesadas() { return lineasProcesadas; }

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

public class ContadorVolatileSigueRoto {

    // volatile SI garantiza que los dos hilos vean el valor mas reciente.
    // volatile NO garantiza que 'valor++' sea indivisible.
    private volatile int valor = 0;

    public void incrementar() {
        valor++;      // sigue siendo LEER, SUMAR, ESCRIBIR
    }

    public int valor() { return valor; }

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

        for (int intento = 1; intento <= 3; intento++) {
            ContadorVolatileSigueRoto c = new ContadorVolatileSigueRoto();

            Thread h1 = new Thread(() -> { for (int i = 0; i < VUELTAS; i++) c.incrementar(); });
            Thread h2 = new Thread(() -> { for (int i = 0; i < VUELTAS; i++) c.incrementar(); });

            h1.start(); h2.start();
            h1.join();  h2.join();

            System.out.printf("Intento %d: esperado %d, real %d, perdidos %d%n",
                    intento, VUELTAS * 2, c.valor(), VUELTAS * 2 - c.valor());
        }
    }
}

Intento 1: esperado 2000000, real 1223981, perdidos 776019
Intento 2: esperado 2000000, real 1341102, perdidos 658898
Intento 3: esperado 2000000, real 1189447, perdidos 810553

// 'catalogo' volatile garantiza que ves la referencia mas reciente...
private volatile List<Material> catalogo = new ArrayList<>();

// ...pero NO protege el CONTENIDO de la lista.
catalogo.add(nuevoLibro);   // sigue siendo una carrera de datos

synchronized (objeto) {
    // solo un hilo a la vez puede estar aqui
}

public class ContadorSincronizado {

    private int valor = 0;

    // Metodo sincronizado de instancia: adquiere el monitor de 'this'.
    public synchronized void incrementar() {
        valor++;      // ahora las tres operaciones son indivisibles
                      // respecto a otros hilos que usen ESTE monitor
    }

    // TAMBIEN sincronizado. Si no lo estuviera, un lector podria ver
    // un valor obsoleto: la exclusion mutua sin visibilidad no basta.
    public synchronized int valor() {
        return valor;
    }

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

        for (int intento = 1; intento <= 3; intento++) {
            ContadorSincronizado c = new ContadorSincronizado();
            Thread h1 = new Thread(() -> { for (int i = 0; i < VUELTAS; i++) c.incrementar(); });
            Thread h2 = new Thread(() -> { for (int i = 0; i < VUELTAS; i++) c.incrementar(); });
            h1.start(); h2.start();
            h1.join();  h2.join();
            System.out.printf("Intento %d: esperado %d, real %d%n",
                    intento, VUELTAS * 2, c.valor());
        }
    }
}

Intento 1: esperado 2000000, real 2000000
Intento 2: esperado 2000000, real 2000000
Intento 3: esperado 2000000, real 2000000

public class Reentrada {

    public synchronized void registrarPrestamo(String isbn) {
        validar(isbn);
        // Llamada a OTRO metodo sincronizado del MISMO objeto.
        // Sin reentrada, el hilo se bloquearia a si mismo: interbloqueo
        // instantaneo consigo mismo.
        actualizarIndice(isbn);
    }

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

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

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

// Es EXACTAMENTE equivalente a:
public void anadir(Material m) {
    synchronized (this) { /* ... */ }
}

public static synchronized void registrarEnGlobal(String evento) { /* ... */ }

// Equivalente a:
public static void registrarEnGlobal(String evento) {
    synchronized (Catalogo.class) { /* ... */ }
}

public class DosMonitoresDistintos {
    private static int contadorGlobal = 0;

    // Bloquea 'this'
    public synchronized void incrementarMal() { contadorGlobal++; }

    // Bloquea 'DosMonitoresDistintos.class'
    public static synchronized void incrementarEstatico() { contadorGlobal++; }

    // Estos dos metodos NO se excluyen: usan candados diferentes.
    // El estado estatico que comparten NO esta protegido. BUG.
}

private final Object candado = new Object();

public void anadir(Material m) {
    // Trabajo que NO necesita proteccion, fuera del bloqueo:
    validar(m);
    String clave = normalizar(m.isbn());

    synchronized (candado) {
        // Seccion critica: lo minimo imprescindible
        materiales.add(m);
        indice.put(clave, m);
    }

    // Mas trabajo no critico
    registrarEnAuditoria(m);
}

public class Catalogo {
    // Candado PRIVADO y FINAL: nadie fuera puede adquirirlo,
    // y nadie puede reasignarlo (un candado reasignado deja de
    // proteger: dos hilos podrian bloquear objetos distintos).
    private final Object candado = new Object();

    // Y NUNCA uses como candado algo asi:
    //   private final Integer candado = 42;      // <- puede estar internado
    //   private final String candado = "cat";    // <- literal internado: COMPARTIDO
    //   private final Boolean candado = false;   // <- Boolean.FALSE, compartido
    // Un literal String o un Integer pequeno es un objeto UNICO en toda la JVM:
    // otra clase que use el mismo literal comparte tu candado sin saberlo.
}

// MAL: 300 ms de E/S dentro del bloqueo. Todos los demas hilos esperan.
public void registrarPrestamo(Prestamo p) {
    synchronized (candado) {
        prestamos.put(p.id(), p);
        escribirEnDisco(p);              // 300 ms de E/S
        enviarNotificacion(p.empleado()); // 200 ms mas
    }
}

// BIEN: solo el cambio de estado en memoria esta protegido.
public void registrarPrestamo(Prestamo p) {
    synchronized (candado) {
        prestamos.put(p.id(), p);        // microsegundos
    }
    escribirEnDisco(p);                  // fuera del bloqueo
    enviarNotificacion(p.empleado());    // fuera del bloqueo
}

// PELIGROSO: 'oyentes' contiene codigo que no controlas.
synchronized (candado) {
    for (OyenteCatalogo o : oyentes) {
        o.materialAnadido(m);    // ¿que hace? ¿bloquea? ¿llama de vuelta?
    }
}

// SEGURO: copiar bajo el candado, notificar fuera.
List<OyenteCatalogo> copia;
synchronized (candado) {
    copia = new ArrayList<>(oyentes);
}
for (OyenteCatalogo o : copia) {
    o.materialAnadido(m);        // sin candado: no puede bloquearnos
}

public class RegistroPrestamos {
    private final Object candado = new Object();

    /** Protegido por 'candado'. */
    private final Map<String, Prestamo> porId = new HashMap<>();

    /** Protegido por 'candado'. Invariante: contiene los mismos prestamos que 'porId'. */
    private final Map<Empleado, List<Prestamo>> porEmpleado = new HashMap<>();
}

package com.nexussoftware.bibliotech.servicio;

import java.util.concurrent.TimeUnit;

public class TransferenciaPrestamos {

    /** Cada empleado tiene su propio candado y su lista de prestamos. */
    static class CuentaEmpleado {
        final String nombre;
        final Object candado = new Object();
        int prestamos;

        CuentaEmpleado(String nombre, int prestamos) {
            this.nombre = nombre;
            this.prestamos = prestamos;
        }
    }

    /**
     * VERSION CON INTERBLOQUEO.
     * Bloquea 'origen' y luego 'destino'. Si dos hilos transfieren
     * en sentidos opuestos, se forma el ciclo.
     */
    static void transferirMal(CuentaEmpleado origen, CuentaEmpleado destino, int n) {
        synchronized (origen.candado) {
            dormir(100);                       // amplia la ventana del fallo
            synchronized (destino.candado) {
                origen.prestamos -= n;
                destino.prestamos += n;
                System.out.printf("  %s -> %s : %d prestamos%n",
                        origen.nombre, destino.nombre, n);
            }
        }
    }

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

        // Hilo 1: marta -> diego  (bloquea marta, luego diego)
        Thread t1 = new Thread(() -> transferirMal(marta, diego, 1), "hilo-marta-diego");
        // Hilo 2: diego -> marta  (bloquea diego, luego marta)  <-- ORDEN INVERSO
        Thread t2 = new Thread(() -> transferirMal(diego, marta, 1), "hilo-diego-marta");

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

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

        if (t1.isAlive() || t2.isAlive()) {
            System.out.println("INTERBLOQUEO: los dos hilos siguen vivos y bloqueados.");
            System.out.println("Estado t1: " + t1.getState());
            System.out.println("Estado t2: " + t2.getState());
            System.exit(1);
        }
    }
}

INTERBLOQUEO: los dos hilos siguen vivos y bloqueados.
Estado t1: BLOCKED
Estado t2: BLOCKED

/**
 * VERSION CORRECTA: orden global de adquisicion.
 * Los candados se toman SIEMPRE en orden creciente de identityHashCode,
 * independientemente de la direccion de la transferencia.
 */
static void transferirBien(CuentaEmpleado origen, CuentaEmpleado destino, int n) {

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

    if (ho < hd) {
        synchronized (origen.candado) {
            synchronized (destino.candado) {
                mover(origen, destino, n);
            }
        }
    } else if (ho > hd) {
        synchronized (destino.candado) {      // orden INVERTIDO respecto al negocio,
            synchronized (origen.candado) {   // pero CONSISTENTE entre hilos
                mover(origen, destino, n);
            }
        }
    } else {
        // Caso rarisimo: colision de identityHashCode entre dos objetos
        // distintos. Un tercer candado global desempata y garantiza
        // que solo un hilo entre en este camino a la vez.
        synchronized (CANDADO_DESEMPATE) {
            synchronized (origen.candado) {
                synchronized (destino.candado) {
                    mover(origen, destino, n);
                }
            }
        }
    }
}

private static final Object CANDADO_DESEMPATE = new Object();

private static void mover(CuentaEmpleado origen, CuentaEmpleado destino, int n) {
    origen.prestamos -= n;
    destino.prestamos += n;
}

// Con identificador natural, mucho mas claro:
CuentaEmpleado primero = origen.id().compareTo(destino.id()) < 0 ? origen : destino;
CuentaEmpleado segundo = (primero == origen) ? destino : origen;

synchronized (primero.candado) {
    synchronized (segundo.candado) {
        mover(origen, destino, n);
    }
}

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

public class TransferenciaConTryLock {

    static class CuentaEmpleado {
        final String nombre;
        final ReentrantLock candado = new ReentrantLock();
        int prestamos;
        CuentaEmpleado(String nombre, int prestamos) {
            this.nombre = nombre; this.prestamos = prestamos;
        }
    }

    /**
     * Adquiere los dos candados con plazo. Si no consigue ambos,
     * suelta lo que tenga, espera un tiempo ALEATORIO y reintenta.
     * El azar es esencial: sin el, dos hilos podrian reintentar
     * sincronizados eternamente (livelock, apartado 12).
     */
    static boolean transferir(CuentaEmpleado origen, CuentaEmpleado destino,
                              int n, int maxIntentos) throws InterruptedException {

        for (int intento = 0; intento < maxIntentos; intento++) {
            boolean tengoOrigen = false;
            boolean tengoDestino = false;
            try {
                tengoOrigen = origen.candado.tryLock(50, TimeUnit.MILLISECONDS);
                if (tengoOrigen) {
                    tengoDestino = destino.candado.tryLock(50, TimeUnit.MILLISECONDS);
                }
                if (tengoOrigen && tengoDestino) {
                    origen.prestamos -= n;
                    destino.prestamos += n;
                    return true;                     // exito
                }
            } finally {
                // SIEMPRE soltar lo adquirido, en orden inverso.
                if (tengoDestino) destino.candado.unlock();
                if (tengoOrigen)  origen.candado.unlock();
            }
            // Retroceso aleatorio antes de reintentar.
            TimeUnit.MILLISECONDS.sleep(
                    ThreadLocalRandom.current().nextInt(10, 60));
        }
        return false;                                // agotados los intentos
    }
}

// Si las transferencias no son el 90% de la carga, esto es
// mas simple, mas seguro y probablemente igual de rapido.
private static final Object CANDADO_TRANSFERENCIAS = new Object();

static void transferir(CuentaEmpleado origen, CuentaEmpleado destino, int n) {
    synchronized (CANDADO_TRANSFERENCIAS) {
        origen.prestamos -= n;
        destino.prestamos += n;
    }
}

// El parametro true activa la politica FIFO: el candado se concede
// al hilo que lleva mas tiempo esperando.
// COSTE: mucho menor rendimiento (a menudo 10x o mas), porque impide
// la reentrada oportunista y fuerza cambios de contexto.
// Usalo solo si has medido inanicion real.
ReentrantLock equitativo = new ReentrantLock(true);

// LIVELOCK: si los dos hilos entran en fase, pueden reintentar
// eternamente, cediendo siempre a la vez.
while (true) {
    if (a.tryLock()) {
        if (b.tryLock()) { hacerTrabajo(); return; }
        a.unlock();          // cede
    }
    // sin espera aleatoria: los dos hilos vuelven a intentarlo
    // exactamente a la vez, otra vez, y otra
}

import java.util.concurrent.locks.ReentrantLock;

public class ContadorConLock {

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

    public void incrementar() {
        candado.lock();
        try {
            valor++;
        } finally {
            // OBLIGATORIO en finally: si el cuerpo lanza una excepcion
            // y el unlock esta fuera, el candado NO se libera JAMAS
            // y toda la aplicacion se bloquea. Es el error numero uno
            // de ReentrantLock, y el motivo por el que synchronized
            // sigue siendo preferible cuando no necesitas nada mas.
            candado.unlock();
        }
    }
}

if (candado.tryLock()) {           // no bloquea nunca
    try { operacion(); } finally { candado.unlock(); }
} else {
    // plan B: encolar, avisar al usuario, reintentar mas tarde
}

try {
    candado.lockInterruptibly();   // responde a interrupt() mientras espera
    try { operacion(); } finally { candado.unlock(); }
} catch (InterruptedException e) {
    Thread.currentThread().interrupt();
}

package com.nexussoftware.bibliotech.servicio;

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

/**
 * Cola acotada de reservas con dos condiciones separadas.
 *
 * Ventaja sobre wait/notifyAll (08-03): al liberar un hueco solo se
 * despierta a un PRODUCTOR, y al anadir un elemento solo a un CONSUMIDOR.
 * Con notifyAll se despertaba a todos y la mayoria volvia a dormirse.
 *
 * NOTA: en produccion usarias ArrayBlockingQueue (08-06), que es
 * exactamente esto ya implementado y probado.
 */
public class ColaReservasConCondition {

    private final ReentrantLock candado = new ReentrantLock();

    // DOS condiciones sobre el MISMO candado.
    private final Condition hayHueco    = candado.newCondition();
    private final Condition hayElemento = candado.newCondition();

    private final Deque<String> cola = new ArrayDeque<>();
    private final int capacidad;

    public ColaReservasConCondition(int capacidad) {
        this.capacidad = capacidad;
    }

    public void poner(String reserva) throws InterruptedException {
        candado.lock();
        try {
            // WHILE, igual que con wait(): las mismas tres razones de 08-03.
            while (cola.size() == capacidad) {
                hayHueco.await();          // suelta el candado y espera
            }
            cola.addLast(reserva);
            hayElemento.signal();          // despierta a UN consumidor.
                                           // Seguro: en esta cola solo esperan
                                           // consumidores, y todos son
                                           // intercambiables.
        } finally {
            candado.unlock();
        }
    }

    public String tomar() throws InterruptedException {
        candado.lock();
        try {
            while (cola.isEmpty()) {
                hayElemento.await();
            }
            String r = cola.pollFirst();
            hayHueco.signal();             // despierta a UN productor
            return r;
        } finally {
            candado.unlock();
        }
    }

    public int tamano() {
        candado.lock();
        try {
            return cola.size();
        } finally {
            candado.unlock();
        }
    }
}

package com.nexussoftware.bibliotech.servicio;

import com.nexussoftware.bibliotech.dominio.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;

/**
 * Catalogo seguro para varios hilos, optimizado para lectura.
 *
 * Justificacion del ReadWriteLock: en BiblioTech se consulta el catalogo
 * decenas de veces por cada alta (buscar por ISBN, listar, filtrar por tipo),
 * y las altas llegan en lotes durante la importacion.
 */
public class CatalogoSeguro {

    private final ReentrantReadWriteLock candado = new ReentrantReadWriteLock();
    private final ReentrantReadWriteLock.ReadLock  lectura  = candado.readLock();
    private final ReentrantReadWriteLock.WriteLock escritura = candado.writeLock();

    /** Protegido por 'candado'. */
    private final List<Material> materiales = new ArrayList<>();
    /** Protegido por 'candado'. Invariante: una entrada por material. */
    private final Map<String, Material> indice = new HashMap<>();
    /** Protegido por 'candado'. Invariante: mismos ISBN que 'indice'. */
    private final Set<String> isbnRegistrados = new HashSet<>();

    // ---------- ESCRITURAS: candado exclusivo ----------

    public boolean anadir(Material m) {
        escritura.lock();
        try {
            if (!isbnRegistrados.add(m.isbn())) {
                return false;                // ya existia
            }
            materiales.add(m);
            indice.put(m.isbn(), m);
            return true;
        } finally {
            escritura.unlock();
        }
    }

    public boolean eliminar(String isbn) {
        escritura.lock();
        try {
            Material m = indice.remove(isbn);
            if (m == null) return false;
            materiales.remove(m);
            isbnRegistrados.remove(isbn);
            return true;
        } finally {
            escritura.unlock();
        }
    }

    /** Reemplazo atomico completo: lo que usa la importacion de 08-02. */
    public void reemplazarTodo(List<Material> nuevos) {
        escritura.lock();
        try {
            materiales.clear();
            indice.clear();
            isbnRegistrados.clear();
            for (Material m : nuevos) {
                if (isbnRegistrados.add(m.isbn())) {
                    materiales.add(m);
                    indice.put(m.isbn(), m);
                }
            }
        } finally {
            escritura.unlock();
        }
    }

    // ---------- LECTURAS: candado compartido ----------

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

    public int tamano() {
        lectura.lock();
        try {
            return materiales.size();
        } finally {
            lectura.unlock();
        }
    }

    /**
     * Devuelve una COPIA. Devolver la lista interna seria un fallo de
     * seguridad de hilos: quien la reciba podria iterarla sin candado
     * mientras otro hilo la modifica -> ConcurrentModificationException
     * (05-02) o algo peor.
     */
    public List<Material> listar() {
        lectura.lock();
        try {
            return new ArrayList<>(materiales);   // copia bajo el candado
        } finally {
            lectura.unlock();
        }
    }
}

// PROHIBIDO: promocion. Se cuelga para siempre.
lectura.lock();
escritura.lock();     // espera a que se suelten TODAS las lecturas,
                      // incluida la NUESTRA. Interbloqueo.

// PERMITIDO: degradacion (escritura -> lectura).
escritura.lock();
try {
    modificar();
    lectura.lock();       // adquirir lectura ANTES de soltar escritura
} finally {
    escritura.unlock();   // ahora tenemos solo lectura
}
try {
    leerLoQueAcabamosDeEscribir();
} finally {
    lectura.unlock();
}

// PUBLICACION INSEGURA
public class Registro {
    public static Catalogo instancia;    // sin volatile, sin final

    public static void inicializar() {
        instancia = new Catalogo();      // (1) reservar (2) construir (3) asignar
        // Las fases (2) y (3) pueden REORDENARSE: otro hilo puede ver
        // 'instancia' no nula apuntando a un objeto sin construir.
    }
}

package com.nexussoftware.bibliotech.dominio;

/**
 * Ficha inmutable: todos sus campos son final por ser un record.
 * Compartible entre cualquier numero de hilos sin sincronizacion.
 */
public record Ficha(String isbn, String titulo, String autor, int ejemplares) { }

/**
 * ResumenSesion inmutable. Ojo: si un record contiene una coleccion,
 * la coleccion debe ser tambien inmutable, o el record solo es
 * "superficialmente" inmutable.
 */
public record ResumenSesion(long inicioMs, long finMs,
                            int prestamos, int devoluciones,
                            List<String> incidencias) {

    /** Constructor compacto con copia defensiva: hace la lista inmutable. */
    public ResumenSesion {
        incidencias = List.copyOf(incidencias);   // copia INMUTABLE
    }
}

public class EstadisticasBiblioTech {

    /** Instantanea inmutable de las estadisticas. */
    public record Instantanea(long prestamos, long devoluciones, long multas) {
        Instantanea conPrestamo()   { return new Instantanea(prestamos + 1, devoluciones, multas); }
        Instantanea conDevolucion() { return new Instantanea(prestamos, devoluciones + 1, multas); }
    }

    // La REFERENCIA es volatile: los lectores siempre ven una
    // instantanea completa y coherente, nunca una a medias.
    private volatile Instantanea actual = new Instantanea(0, 0, 0);

    /** Lectura sin ningun bloqueo: coherente por inmutabilidad. */
    public Instantanea instantanea() {
        return actual;
    }

    /**
     * La escritura SI necesita sincronizacion: 'actual = actual.conPrestamo()'
     * es leer-modificar-escribir, y volatile no lo hace atomico (apartado 6).
     * En 08-06 esto se resolvera con AtomicReference.updateAndGet, sin candado.
     */
    public synchronized void registrarPrestamo() {
        actual = actual.conPrestamo();
    }
}

public Informe procesarLote(List<String> lineas) {
    // TODO local: cada hilo tiene su propia lista y su propio contador.
    // Ningun candado, ninguna carrera posible.
    List<Material> aceptados = new ArrayList<>();
    int descartados = 0;

    for (String l : lineas) {
        try {
            aceptados.add(lector.aMaterial(l));
        } catch (FormatoInvalidoException e) {
            descartados++;
        }
    }
    // El unico punto de contacto con estado compartido, y esta protegido:
    catalogo.anadirTodos(aceptados);
    return new Informe(aceptados.size(), descartados);
}

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

public class FormatoMultas {

    // NumberFormat NO es seguro para varios hilos: compartir una instancia
    // produce resultados corruptos bajo carga (un clasico muy dificil de
    // diagnosticar porque falla poco y de forma silenciosa).
    // ThreadLocal da una instancia por hilo: seguro y sin candados.
    private static final ThreadLocal<NumberFormat> FORMATO =
            ThreadLocal.withInitial(() -> NumberFormat.getCurrencyInstance(
                    Locale.forLanguageTag("es-ES")));

    public static String formatear(double importe) {
        return FORMATO.get().format(importe);
    }

    /**
     * IMPORTANTE: en un pool de hilos (08-05) los hilos se reutilizan
     * indefinidamente, asi que un ThreadLocal nunca se libera solo.
     * Si guarda algo grande o sensible, hay que limpiarlo:
     */
    public static void limpiar() {
        FORMATO.remove();
    }
}

// Cada hilo procesa SU trozo y produce SU resultado parcial.
// No hay estado compartido durante el calculo, solo al combinar.
// Es el modelo de ForkJoinPool (08-05) y de los streams paralelos (10-04).
List<Informe> parciales = new ArrayList<>();
// ... cada hilo devuelve su Informe, y al final:
Informe total = combinar(parciales);   // un solo hilo, sin candados

package com.nexussoftware.bibliotech.servicio;

import com.nexussoftware.bibliotech.dominio.Empleado;
import com.nexussoftware.bibliotech.dominio.Prestamo;

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

/**
 * Registro de prestamos seguro para varios hilos.
 *
 * POLITICA DE SINCRONIZACION
 * --------------------------
 * Todo el estado mutable esta protegido por 'candado'.
 * Las consultas usan el candado de lectura (compartido);
 * las modificaciones, el de escritura (exclusivo).
 *
 * INVARIANTE: 'porId' y 'porEmpleado' contienen exactamente el mismo
 * conjunto de prestamos. Este invariante abarca DOS estructuras, y por
 * eso no basta con usar dos ConcurrentHashMap (08-06): haria falta que
 * las dos actualizaciones fueran una sola operacion atomica, y eso solo
 * lo da un candado.
 */
public class RegistroPrestamosSeguro {

    private final ReentrantReadWriteLock candado = new ReentrantReadWriteLock();
    private final ReentrantReadWriteLock.ReadLock  lectura   = candado.readLock();
    private final ReentrantReadWriteLock.WriteLock escritura = candado.writeLock();

    /** Protegido por 'candado'. */
    private final Map<String, Prestamo> porId = new HashMap<>();
    /** Protegido por 'candado'. Invariante: coherente con 'porId'. */
    private final Map<Empleado, List<Prestamo>> porEmpleado = new HashMap<>();

    // ---------- ESCRITURA ----------

    /**
     * Registra un prestamo. Las dos actualizaciones ocurren bajo el mismo
     * candado, asi que ningun lector puede ver el estado intermedio en el
     * que el prestamo esta en 'porId' pero aun no en 'porEmpleado'.
     */
    public void registrar(Prestamo p) {
        escritura.lock();
        try {
            if (porId.putIfAbsent(p.id(), p) != null) {
                throw new IllegalStateException("Prestamo duplicado: " + p.id());
            }
            porEmpleado.computeIfAbsent(p.empleado(), e -> new ArrayList<>()).add(p);
        } finally {
            escritura.unlock();
        }
    }

    public Prestamo devolver(String idPrestamo) {
        escritura.lock();
        try {
            Prestamo p = porId.remove(idPrestamo);
            if (p == null) {
                throw new PrestamoNoEncontradoException(idPrestamo);
            }
            List<Prestamo> deEmpleado = porEmpleado.get(p.empleado());
            if (deEmpleado != null) {
                deEmpleado.remove(p);
                if (deEmpleado.isEmpty()) {
                    porEmpleado.remove(p.empleado());   // no dejar listas vacias
                }
            }
            return p;
        } finally {
            escritura.unlock();
        }
    }

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

    public Prestamo buscar(String idPrestamo) {
        lectura.lock();
        try {
            return porId.get(idPrestamo);
        } finally {
            lectura.unlock();
        }
    }

    /** Devuelve una COPIA: la lista interna nunca sale del candado. */
    public List<Prestamo> prestamosDe(Empleado e) {
        lectura.lock();
        try {
            List<Prestamo> l = porEmpleado.get(e);
            return l == null ? List.of() : new ArrayList<>(l);
        } finally {
            lectura.unlock();
        }
    }

    public int activos() {
        lectura.lock();
        try {
            return porId.size();
        } finally {
            lectura.unlock();
        }
    }

    /**
     * OPERACION COMPUESTA ATOMICA.
     *
     * Este metodo existe precisamente porque hacerlo desde fuera seria
     * un comprobar-luego-actuar inseguro:
     *
     *     if (registro.activos() < MAX) registro.registrar(p);   // BUG
     *
     * Entre la comprobacion y la accion, otro hilo puede registrar y
     * superar el limite. Encapsular la operacion completa dentro del
     * candado es la unica forma correcta.
     */
    public boolean registrarSiHayCupo(Prestamo p, int maximoPorEmpleado) {
        escritura.lock();
        try {
            List<Prestamo> actuales = porEmpleado.get(p.empleado());
            if (actuales != null && actuales.size() >= maximoPorEmpleado) {
                return false;
            }
            porId.put(p.id(), p);
            porEmpleado.computeIfAbsent(p.empleado(), e -> new ArrayList<>()).add(p);
            return true;
        } finally {
            escritura.unlock();
        }
    }
}

package com.nexussoftware.bibliotech.servicio;

import java.util.concurrent.TimeUnit;

public class PruebaConcurrenciaRegistro {

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

        final int HILOS = 8;
        final int POR_HILO = 5_000;

        RegistroPrestamosSeguro registro = new RegistroPrestamosSeguro();
        Empleado marta = new Empleado("E-001", "Marta Ruiz");

        Thread[] hilos = new Thread[HILOS];
        long inicio = System.nanoTime();

        for (int h = 0; h < HILOS; h++) {
            final int idHilo = h;
            hilos[h] = new Thread(() -> {
                for (int i = 0; i < POR_HILO; i++) {
                    registro.registrar(new Prestamo(
                            "P-" + idHilo + "-" + i, marta, "978-0000000001"));
                }
            }, "bibliotech-registrador-" + h);
            hilos[h].start();
        }

        for (Thread h : hilos) h.join();

        long ms = (System.nanoTime() - inicio) / 1_000_000;
        int esperado = HILOS * POR_HILO;
        int real = registro.activos();
        int enLista = registro.prestamosDe(marta).size();

        System.out.println("Esperados           : " + esperado);
        System.out.println("En porId            : " + real);
        System.out.println("En porEmpleado      : " + enLista);
        System.out.println("Invariante coherente: " + (real == enLista));
        System.out.println("Tiempo              : " + ms + " ms");
        System.out.println(real == esperado && real == enLista
                ? "CORRECTO"
                : "FALLO: hay una carrera de datos");
    }
}

Esperados           : 40000
En porId            : 40000
En porEmpleado      : 40000
Invariante coherente: true
Tiempo              : 187 ms
CORRECTO

import java.util.concurrent.locks.ReentrantLock;

public class ComparativaContadores {

    interface Contador {
        void incrementar();
        long valor();
        String nombre();
    }

    /** 1. INSEGURO: valor++ es leer-modificar-escribir sin proteccion. */
    static class ContadorInseguro implements Contador {
        private long valor = 0;
        public void incrementar() { valor++; }
        public long valor() { return valor; }
        public String nombre() { return "int simple"; }
    }

    /** 2. VOLATILE: resuelve la visibilidad, NO la atomicidad. */
    static class ContadorVolatile implements Contador {
        private volatile long valor = 0;
        public void incrementar() { valor++; }
        public long valor() { return valor; }
        public String nombre() { return "volatile"; }
    }

    /** 3. SYNCHRONIZED: exclusion mutua + visibilidad. Correcto. */
    static class ContadorSincronizado implements Contador {
        private long valor = 0;
        public synchronized void incrementar() { valor++; }
        // El getter TAMBIEN sincronizado: sin el, un lector podria
        // ver un valor obsoleto de su cache.
        public synchronized long valor() { return valor; }
        public String nombre() { return "synchronized"; }
    }

    /** 4. REENTRANTLOCK: equivalente, con unlock en finally. */
    static class ContadorConLock implements Contador {
        private final ReentrantLock candado = new ReentrantLock();
        private long valor = 0;

        public void incrementar() {
            candado.lock();                 // FUERA del try
            try { valor++; }
            finally { candado.unlock(); }   // SIEMPRE en finally
        }

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

    static long medir(Contador c, int hilos, int porHilo) throws InterruptedException {
        Thread[] ts = new Thread[hilos];
        long inicio = System.nanoTime();
        for (int i = 0; i < hilos; i++) {
            ts[i] = new Thread(() -> {
                for (int j = 0; j < porHilo; j++) c.incrementar();
            }, "sumador-" + i);
            ts[i].start();
        }
        for (Thread t : ts) t.join();
        return System.nanoTime() - inicio;
    }

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

        final int HILOS = 8;
        final int POR_HILO = 500_000;
        final long ESPERADO = (long) HILOS * POR_HILO;

        Contador[] contadores = {
                new ContadorInseguro(), new ContadorVolatile(),
                new ContadorSincronizado(), new ContadorConLock()
        };

        // Calentamiento: sin el, las primeras implementaciones pagan
        // la compilacion JIT y la comparacion no es justa.
        for (Contador c : contadores) medir(c, 2, 10_000);

        System.out.printf("%-16s | %12s | %10s | %8s | %12s%n",
                "Implementacion", "Resultado", "Perdidos", "ms", "inc/ms");
        System.out.println("-----------------|--------------|------------|----------|-------------");

        for (Contador plantilla : contadores) {
            // Instancia nueva para no arrastrar el calentamiento.
            Contador c = switch (plantilla.nombre()) {
                case "int simple"    -> new ContadorInseguro();
                case "volatile"      -> new ContadorVolatile();
                case "synchronized"  -> new ContadorSincronizado();
                default              -> new ContadorConLock();
            };

            long ns = medir(c, HILOS, POR_HILO);
            long ms = ns / 1_000_000;
            long perdidos = ESPERADO - c.valor();

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

Implementacion   |    Resultado |   Perdidos |       ms |       inc/ms
-----------------|--------------|------------|----------|-------------
int simple       |      1284471 |    2715529 |       31 |        41434   <-- INCORRECTO
volatile         |      1893204 |    2106796 |      142 |        13332   <-- INCORRECTO
synchronized     |      4000000 |          0 |      213 |        18779
ReentrantLock    |      4000000 |          0 |      205 |        19512

package com.nexussoftware.bibliotech.servicio;

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 con candado intrinseco y candado explicito, para las tres versiones. */
    static class SalaReuniones {
        final String id;
        final Object candado = new Object();
        final ReentrantLock lock = new ReentrantLock();
        int reservas = 0;

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

    // ---------- 1. VERSION CON INTERBLOQUEO ----------

    static void reservarMal(SalaReuniones a, SalaReuniones b) {
        synchronized (a.candado) {
            dormir(100);                    // amplia la ventana del fallo
            synchronized (b.candado) {
                a.reservas++;
                b.reservas++;
            }
        }
    }

    // ---------- 2. ORDEN GLOBAL DE ADQUISICION ----------

    /**
     * Los candados se toman SIEMPRE en orden creciente de 'id'.
     * Sin espera circular no puede haber interbloqueo: es una
     * garantia estructural, no una probabilidad.
     */
    static void reservarBien(SalaReuniones a, SalaReuniones b) {
        SalaReuniones primera = a.id.compareTo(b.id) <= 0 ? a : b;
        SalaReuniones segunda = (primera == a) ? b : a;

        synchronized (primera.candado) {
            dormir(1);
            synchronized (segunda.candado) {
                a.reservas++;
                b.reservas++;
            }
        }
    }

    // ---------- 3. TRYLOCK CON RETROCESO ALEATORIO ----------

    static int reservarConTryLock(SalaReuniones a, SalaReuniones b, int maxIntentos)
            throws InterruptedException {

        for (int intento = 1; intento <= maxIntentos; intento++) {
            boolean tengoA = false, tengoB = false;
            try {
                tengoA = a.lock.tryLock(50, TimeUnit.MILLISECONDS);
                if (tengoA) {
                    tengoB = b.lock.tryLock(50, TimeUnit.MILLISECONDS);
                }
                if (tengoA && tengoB) {
                    a.reservas++;
                    b.reservas++;
                    return intento;                  // exito: devolvemos el intento
                }
            } finally {
                if (tengoB) b.lock.unlock();
                if (tengoA) a.lock.unlock();
            }
            // Retroceso ALEATORIO: sin el, dos hilos en fase reintentarian
            // eternamente a la vez (livelock, apartado 12).
            TimeUnit.MILLISECONDS.sleep(ThreadLocalRandom.current().nextInt(5, 40));
        }
        return -1;                                    // no se consiguio
    }

    // ---------- DEMOSTRACION ----------

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

        // --- 1. Provocar el interbloqueo ---
        System.out.println("=== 1. VERSION CON INTERBLOQUEO ===");
        SalaReuniones s1 = new SalaReuniones("SALA-A");
        SalaReuniones s2 = new SalaReuniones("SALA-B");

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

        if (t1.isAlive() || t2.isAlive()) {
            System.out.println("  INTERBLOQUEADO. t1=" + t1.getState()
                    + "  t2=" + t2.getState());
            System.out.println("  (jstack diria: Found one Java-level deadlock)");
        } else {
            System.out.println("  Esta vez no ha ocurrido; reintenta. "
                    + "La intermitencia es exactamente el problema.");
        }

        // --- 2. Orden global: 1.000 intentos con 8 hilos ---
        System.out.println();
        System.out.println("=== 2. ORDEN GLOBAL DE ADQUISICION ===");
        SalaReuniones a = new SalaReuniones("SALA-A");
        SalaReuniones b = new SalaReuniones("SALA-B");

        Thread[] hilos = new Thread[8];
        for (int i = 0; i < 8; i++) {
            final boolean directo = (i % 2 == 0);
            hilos[i] = new Thread(() -> {
                for (int k = 0; k < 125; k++) {
                    if (directo) reservarBien(a, b);
                    else         reservarBien(b, a);   // sentido opuesto
                }
            }, "reservador-" + i);
            hilos[i].start();
        }
        for (Thread h : hilos) h.join(20_000);

        boolean alguienVivo = false;
        for (Thread h : hilos) alguienVivo |= h.isAlive();

        System.out.println("  Reservas SALA-A: " + a.reservas);
        System.out.println("  Reservas SALA-B: " + b.reservas);
        System.out.println("  Algun hilo bloqueado: " + alguienVivo);
        System.out.println(alguienVivo ? "  FALLO" : "  CORRECTO: 1.000 reservas sin interbloqueo");

        // --- 3. tryLock con retroceso ---
        System.out.println();
        System.out.println("=== 3. TRYLOCK CON RETROCESO ALEATORIO ===");
        SalaReuniones c = new SalaReuniones("SALA-C");
        SalaReuniones d = new SalaReuniones("SALA-D");

        AtomicInteger reintentosTotales = new AtomicInteger();
        AtomicInteger fracasos = new AtomicInteger();

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

        System.out.println("  Reservas SALA-C   : " + c.reservas);
        System.out.println("  Reservas SALA-D   : " + d.reservas);
        System.out.println("  Reintentos totales: " + reintentosTotales.get());
        System.out.println("  Fracasos          : " + fracasos.get());
        System.out.println("  (los reintentos son el precio de no imponer un orden)");
    }

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

=== 1. VERSION CON INTERBLOQUEO ===
  INTERBLOQUEADO. t1=BLOCKED  t2=BLOCKED
  (jstack diria: Found one Java-level deadlock)

=== 2. ORDEN GLOBAL DE ADQUISICION ===
  Reservas SALA-A: 1000
  Reservas SALA-B: 1000
  Algun hilo bloqueado: false
  CORRECTO: 1.000 reservas sin interbloqueo

=== 3. TRYLOCK CON RETROCESO ALEATORIO ===
  Reservas SALA-C   : 200
  Reservas SALA-D   : 200
  Reintentos totales: 37
  Fracasos          : 0

package com.nexussoftware.bibliotech.servicio;

import com.nexussoftware.bibliotech.dominio.Ficha;

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

/**
 * Cache de fichas segura para varios hilos, optimizada para lectura.
 *
 * POLITICA: todo el estado esta protegido por 'candado'.
 * Las consultas que aciertan usan el candado de LECTURA (compartido);
 * solo los fallos escalan al de ESCRITURA (exclusivo).
 */
public class CacheFichasSegura {

    private final ReentrantReadWriteLock candado = new ReentrantReadWriteLock();
    private final ReentrantReadWriteLock.ReadLock  lectura   = candado.readLock();
    private final ReentrantReadWriteLock.WriteLock escritura = candado.writeLock();

    /** Protegido por 'candado'. */
    private final Map<String, Ficha> cache = new HashMap<>();
    /** Protegidos por 'candado'. */
    private long aciertos = 0;
    private long fallos = 0;

    public Ficha obtener(String isbn) {

        // FASE 1: intento optimista con candado COMPARTIDO.
        // Varios hilos pueden estar aqui a la vez, que es el 96% del trafico.
        lectura.lock();
        try {
            Ficha f = cache.get(isbn);
            if (f != null) {
                // OJO: 'aciertos++' bajo el candado de LECTURA seria una
                // carrera: varios lectores simultaneos harian
                // leer-modificar-escribir a la vez. Lo contamos en la fase 2.
                return f;
            }
        } finally {
            lectura.unlock();
        }

        // FASE 2: fallo. Calculamos FUERA de todo candado (regla 2 del
        // apartado 9: nunca operaciones lentas dentro del bloqueo).
        Ficha calculada = calcular(isbn);

        // FASE 3: publicacion con candado EXCLUSIVO.
        escritura.lock();
        try {
            // Re-comprobamos: entre la fase 1 y la 3 otro hilo pudo
            // calcular la misma ficha. putIfAbsent conserva la primera
            // y mantiene la coherencia del recuento.
            Ficha yaPuesta = cache.putIfAbsent(isbn, calculada);
            if (yaPuesta != null) {
                aciertos++;                  // otro hilo nos gano la carrera
                return yaPuesta;
            }
            fallos++;
            return calculada;
        } finally {
            escritura.unlock();
        }
    }

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

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

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

    /** Simula el coste real de construir una ficha (consulta + formateo). */
    private Ficha calcular(String isbn) {
        try { TimeUnit.MILLISECONDS.sleep(20); }
        catch (InterruptedException e) { Thread.currentThread().interrupt(); }
        return new Ficha(isbn, "Titulo de " + isbn, "Autor", 3);
    }

    // ---------- VERSION DE CONTRASTE: un solo candado exclusivo ----------

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

        // TODO el metodo sincronizado, INCLUIDO el calculo de 20 ms.
        // Es el error de la regla 2 del apartado 9, a proposito.
        public synchronized Ficha obtener(String isbn) {
            Ficha f = cache.get(isbn);
            if (f == null) {
                try { TimeUnit.MILLISECONDS.sleep(20); }
                catch (InterruptedException e) { Thread.currentThread().interrupt(); }
                f = new Ficha(isbn, "Titulo de " + isbn, "Autor", 3);
                cache.put(isbn, f);
            }
            return f;
        }

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

    // ---------- PRUEBA ----------

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

        final int HILOS = 10;
        final int CONSULTAS = 2_000;
        final int ISBNS = 50;

        // --- Version con ReadWriteLock ---
        CacheFichasSegura rw = new CacheFichasSegura();
        long msRw = ejecutar(HILOS, CONSULTAS, ISBNS, isbn -> rw.obtener(isbn));

        System.out.println("=== ReadWriteLock ===");
        System.out.println("  Tiempo   : " + msRw + " ms");
        System.out.println("  Entradas : " + rw.tamano());
        System.out.println("  " + rw.estadisticas());

        // --- Version con synchronized total ---
        CacheFichasSincronizada sy = new CacheFichasSincronizada();
        long msSy = ejecutar(HILOS, CONSULTAS, ISBNS, isbn -> sy.obtener(isbn));

        System.out.println();
        System.out.println("=== synchronized total ===");
        System.out.println("  Tiempo   : " + msSy + " ms");
        System.out.println("  Entradas : " + sy.tamano());

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

    interface Consulta { Ficha obtener(String isbn); }

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

=== ReadWriteLock ===
  Tiempo   : 152 ms
  Entradas : 50
  aciertos=19 fallos=50 tasa=27.5%

=== synchronized total ===
  Tiempo   : 1043 ms
  Entradas : 50

Relacion: 6.9x a favor del ReadWriteLock