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

public class HashMapCorrompido {

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

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

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

            Thread h1 = new Thread(() -> {
                for (int i = 0; i < POR_HILO; i++) mapa.put(i, "A" + i);
            }, "escritor-1");

            Thread h2 = new Thread(() -> {
                for (int i = POR_HILO; i < POR_HILO * 2; i++) mapa.put(i, "B" + i);
            }, "escritor-2");

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

            // Plazo: si el HashMap se corrompe, un hilo puede quedarse
            // en un bucle infinito dentro de put() o de get().
            h1.join(5000);
            h2.join(5000);

            int esperado = POR_HILO * 2;
            if (h1.isAlive() || h2.isAlive()) {
                System.out.printf("Intento %d: BUCLE INFINITO. "
                        + "h1=%s h2=%s  <-- estructura corrompida%n",
                        intento, h1.getState(), h2.getState());
                System.out.println("  (mira el uso de CPU: un nucleo al 100%)");
                System.exit(1);
            }
            System.out.printf("Intento %d: esperado %d, real %d, perdidas %d%n",
                    intento, esperado, mapa.size(), esperado - mapa.size());
        }
    }
}

Intento 1: esperado 200000, real 187341, perdidas 12659
Intento 2: esperado 200000, real 193028, perdidas 6972
Intento 3: BUCLE INFINITO. h1=RUNNABLE h2=RUNNABLE  <-- estructura corrompida
  (mira el uso de CPU: un nucleo al 100%)

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

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

public class FailFastConcurrente {

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

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

        Thread lector = new Thread(() -> {
            try {
                while (!Thread.currentThread().isInterrupted()) {
                    int n = 0;
                    for (String isbn : catalogo) {    // iteracion
                        n += isbn.length();
                    }
                }
            } catch (java.util.ConcurrentModificationException e) {
                System.out.println("[lector] ConcurrentModificationException: "
                        + "otro hilo modifico el catalogo mientras iteraba");
            }
        }, "bibliotech-lector");

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

        lector.start();
        escritor.start();

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

[lector] ConcurrentModificationException: otro hilo modifico el catalogo mientras iteraba

import java.util.*;

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

// Aproximadamente, lo que hace Collections.synchronizedMap:
public V get(Object clave) {
    synchronized (mutex) { return m.get(clave); }
}
public V put(K clave, V valor) {
    synchronized (mutex) { return m.put(clave, valor); }
}

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

// MAL: cada llamada del iterador esta sincronizada, pero la
// ITERACION COMPLETA no. ConcurrentModificationException garantizada.
for (Material m : lista) {
    procesar(m);
}

// BIEN: sincronizar la iteracion entera sobre el propio envoltorio.
// Es lo que exige explicitamente el javadoc de Collections.synchronizedList,
// y casi nadie lee esa parte.
synchronized (lista) {
    for (Material m : lista) {
        procesar(m);      // OJO: 'procesar' se ejecuta CON EL CANDADO TOMADO
    }                     // (regla 3 de 08-04: nada de codigo ajeno aqui)
}

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

// MAL: comprobar-luego-actuar. Cada llamada esta sincronizada,
// pero el HUECO entre ellas no lo esta.
if (!prestamosPorIsbn.containsKey(isbn)) {     // (1) hilo A: no existe
    prestamosPorIsbn.put(isbn, 1);             // (3) hilo A escribe 1
}                                              // (2) hilo B tambien vio "no existe"
                                               // (4) hilo B escribe 1 -> se pierde uno

// MAL: leer-modificar-escribir, el mismo problema que 'contador++' (08-04)
Integer n = prestamosPorIsbn.get(isbn);        // (1) lee 5
prestamosPorIsbn.put(isbn, n + 1);             // (3) escribe 6
                                               // otro hilo tambien leyo 5 y
                                               // tambien escribe 6: un prestamo perdido

// Correcto pero torpe: candado externo sobre la coleccion.
synchronized (prestamosPorIsbn) {
    Integer n = prestamosPorIsbn.get(isbn);
    prestamosPorIsbn.put(isbn, n == null ? 1 : n + 1);
}

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

public class ComparativaMapas {

    static long medir(Map<Integer, String> mapa, int hilos, int opsPorHilo,
                      double proporcionLectura) throws InterruptedException {

        // Precargar para que las lecturas acierten.
        for (int i = 0; i < 10_000; i++) mapa.put(i, "valor-" + i);

        CountDownLatch salida = new CountDownLatch(1);
        CountDownLatch meta   = new CountDownLatch(hilos);

        for (int h = 0; h < hilos; h++) {
            new Thread(() -> {
                try {
                    salida.await();
                    ThreadLocalRandom azar = ThreadLocalRandom.current();
                    for (int i = 0; i < opsPorHilo; i++) {
                        int clave = azar.nextInt(10_000);
                        if (azar.nextDouble() < proporcionLectura) {
                            mapa.get(clave);
                        } else {
                            mapa.put(clave, "nuevo-" + i);
                        }
                    }
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                } finally {
                    meta.countDown();
                }
            }, "acceso-" + h).start();
        }

        long inicio = System.nanoTime();
        salida.countDown();          // arrancan todos a la vez (08-05)
        meta.await();
        return (System.nanoTime() - inicio) / 1_000_000;
    }

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

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

        System.out.printf("%d hilos x %d operaciones%n%n", HILOS, OPS);
        System.out.printf("%-28s | %10s | %10s%n", "Implementacion", "90% lectura", "50% lectura");
        System.out.println("-----------------------------|------------|------------");

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

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

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

16 hilos x 200000 operaciones

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

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

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

public class OperacionesAtomicasMapa {

    private final Map<String, Integer> prestamosPorIsbn = new ConcurrentHashMap<>();
    private final Map<String, Ficha> cacheFichas = new ConcurrentHashMap<>();

    /** Comprobar-luego-actuar, resuelto: una sola operacion atomica. */
    public boolean registrarPrimerPrestamo(String isbn) {
        // Devuelve null si NO existia (y lo inserta), o el valor previo.
        return prestamosPorIsbn.putIfAbsent(isbn, 1) == null;
    }

    /** Leer-modificar-escribir, resuelto con merge. */
    public void contarPrestamo(String isbn) {
        // Si no existe -> pone 1. Si existe -> aplica Integer::sum
        // entre el valor actual y el 1 que pasamos. Todo atomico.
        prestamosPorIsbn.merge(isbn, 1, Integer::sum);
    }

    /** Lo mismo con compute, mas explicito. */
    public void contarPrestamoAlternativo(String isbn) {
        prestamosPorIsbn.compute(isbn, (clave, actual) ->
                actual == null ? 1 : actual + 1);
    }

    /**
     * Cache perezosa, resuelta con computeIfAbsent.
     * Sustituye a las tres fases del ejercicio 3 de 08-04:
     * la funcion se ejecuta A LO SUMO UNA VEZ por clave, aunque
     * diez hilos la pidan a la vez. Los otros nueve esperan y
     * reciben el mismo objeto: no hay calculo duplicado.
     */
    public Ficha obtenerFicha(String isbn) {
        return cacheFichas.computeIfAbsent(isbn, this::construirFicha);
    }

    /** Eliminar solo si el valor es el esperado: comparar-y-eliminar. */
    public boolean devolverSiEsElUltimo(String isbn) {
        return prestamosPorIsbn.remove(isbn, 1);
    }

    /** Contador de descargas sin NullPointerException. */
    public int descargasDe(String isbn) {
        return prestamosPorIsbn.getOrDefault(isbn, 0);
    }

    private Ficha construirFicha(String isbn) { /* consulta cara */ return null; }
}

// PROHIBIDO 1: modificar el MISMO mapa dentro de la funcion.
// Puede provocar un interbloqueo o corromper la estructura.
mapa.computeIfAbsent(k, clave -> {
    mapa.put("otra", "cosa");     // NUNCA
    return calcular(clave);
});

// PROHIBIDO 2: operaciones largas o bloqueantes.
// Bloquea la cubeta entera, y toda la aplicacion se resiente
// (regla 2 de 08-04: nada de E/S dentro del bloqueo).
mapa.computeIfAbsent(k, clave -> leerDeDisco(clave));   // MAL si tarda

// PROHIBIDO 3: llamar a codigo ajeno (oyentes, callbacks).
// Regla 3 de 08-04, aplicada aqui.

// CORRECTO cuando el calculo es caro: calcular fuera y publicar con putIfAbsent.
Ficha calculada = leerDeDisco(isbn);         // sin ningun candado
Ficha establecida = mapa.putIfAbsent(isbn, calculada);
Ficha resultado = (establecida != null) ? establecida : calculada;
// Puede haber calculo duplicado si dos hilos coinciden, pero
// el resultado es correcto y no se bloquea la cubeta.

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

// SEGURO: no lanza excepcion, no bloquea a nadie, y ningun escritor
// se queda esperando a que termines de recorrer 100.000 entradas.
for (Map.Entry<String, Material> e : catalogo.entrySet()) {
    procesar(e.getValue());
}
// Si otro hilo anade una entrada mientras iteras, puede que la veas
// y puede que no. Lo que NO ocurrira es que el bucle falle.

// MAL: comprobar-luego-actuar sobre un tamano aproximado.
if (catalogo.size() < LIMITE) {
    catalogo.put(isbn, material);    // el tamano pudo cambiar entre medias
}

// El tamano de una estructura concurrente es un dato ESTADISTICO,
// util para logs y metricas, no para decisiones de control.
LOG.log(Level.INFO, "Catalogo con ~{0} materiales", catalogo.size());

package com.nexussoftware.bibliotech.servicio;

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

/**
 * Registro de oyentes de eventos del catalogo.
 *
 * Caso de uso PERFECTO para CopyOnWriteArrayList:
 *  - Se registran ~10 oyentes al arrancar y casi nunca cambian.
 *  - Se recorren en CADA operacion del catalogo: miles de veces por minuto.
 *  - Proporcion lectura/escritura: 100.000 a 1.
 */
public class RegistroOyentes {

    private final List<OyenteCatalogo> oyentes = new CopyOnWriteArrayList<>();

    public void registrar(OyenteCatalogo o)   { oyentes.add(o); }
    public void desregistrar(OyenteCatalogo o) { oyentes.remove(o); }

    /**
     * Notifica a todos los oyentes.
     *
     * DOS ventajas decisivas frente a una lista sincronizada:
     *  1. NO hay candado durante el recorrido: los oyentes pueden
     *     registrar o desregistrar oyentes sin interbloquearse.
     *  2. Es la regla 3 de 08-04 —no llamar a codigo ajeno con un
     *     candado— cumplida automaticamente por la coleccion.
     */
    public void notificarAlta(Material m) {
        for (OyenteCatalogo o : oyentes) {
            try {
                o.materialAnadido(m);
            } catch (RuntimeException e) {
                // Un oyente defectuoso no debe impedir que los demas
                // se enteren (politica de degradacion de 06-07).
                LOG.log(Level.WARNING, "Oyente fallido: " + o, e);
            }
        }
    }
}

// DESASTRE: 10.000 escrituras sobre una lista que crece.
// Cada add() copia todo el array: 1 + 2 + ... + 10.000 ≈ 50 millones
// de copias de referencias. Segundos donde deberian ser milisegundos.
List<Material> lista = new CopyOnWriteArrayList<>();
for (int i = 0; i < 10_000; i++) {
    lista.add(materiales.get(i));      // O(n) cada una -> O(n²) total
}

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

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

pendientes.offer(reserva);        // anadir: nunca bloquea, nunca falla
Reserva r = pendientes.poll();    // sacar: devuelve NULL si esta vacia

// ANTIPATRON con ConcurrentLinkedQueue: sondeo (08-03, apartado 6).
while (!Thread.currentThread().isInterrupted()) {
    Reserva r = pendientes.poll();
    if (r == null) {
        Thread.sleep(100);      // despierta 10 veces por segundo para nada
        continue;
    }
    atender(r);
}

import java.util.concurrent.*;

// 1. ARRAYBLOCKINGQUEUE: acotada. Si se llena, el productor ESPERA.
//    Eso es CONTRAPRESION: el productor se frena al ritmo del consumidor.
//    Es lo que evita el OutOfMemoryError de las colas ilimitadas (08-05).
BlockingQueue<Reserva> reservas = new ArrayBlockingQueue<>(100);

// 2. LINKEDBLOCKINGQUEUE acotada: dos candados internos (uno para la
//    cabeza y otro para la cola), asi que un productor y un consumidor
//    pueden trabajar a la vez. Mejor con mucha concurrencia.
BlockingQueue<Aviso> avisos = new LinkedBlockingQueue<>(500);

// 3. SYNCHRONOUSQUEUE: capacidad CERO. Cada put() espera a un take().
//    Es el traspaso mano a mano, sin almacen. Es la cola que usa
//    newCachedThreadPool (08-05) y por eso crea hilos sin limite.
BlockingQueue<Tarea> traspaso = new SynchronousQueue<>();

// 4. PRIORITYBLOCKINGQUEUE: sale primero el mas "pequeno" segun el
//    Comparator (05-09). Los avisos mas vencidos, primero.
BlockingQueue<Prestamo> porUrgencia = new PriorityBlockingQueue<>(
        100, Comparator.comparingLong(Prestamo::diasDeRetraso).reversed());

// 5. DELAYQUEUE: los elementos implementan Delayed y no se pueden
//    sacar hasta que expire su retardo. Reintentos con espera.
DelayQueue<ReintentoAviso> reintentos = new DelayQueue<>();

package com.nexussoftware.bibliotech.servicio;

import com.nexussoftware.bibliotech.dominio.Reserva;

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

/**
 * Procesador de reservas con el patron productor-consumidor.
 *
 * Los empleados producen reservas desde el menu (varios hilos);
 * un grupo de consumidores las atiende (comprobar disponibilidad,
 * notificar, registrar).
 *
 * La cola ACOTADA da contrapresion: si las reservas llegan mas rapido
 * de lo que se atienden, el menu se frena en lugar de acumular
 * reservas en memoria hasta agotarla.
 */
public class ProcesadorReservas implements AutoCloseable {

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

    private static final int CAPACIDAD = 50;
    private static final int CONSUMIDORES = 4;

    private final BlockingQueue<Reserva> cola = new ArrayBlockingQueue<>(CAPACIDAD);
    private final ExecutorService consumidores;

    private final AtomicInteger atendidas = new AtomicInteger();
    private final AtomicInteger rechazadas = new AtomicInteger();
    private volatile boolean aceptandoNuevas = true;

    public ProcesadorReservas() {
        AtomicInteger n = new AtomicInteger(1);
        this.consumidores = Executors.newFixedThreadPool(CONSUMIDORES,
                r -> new Thread(r, "bibliotech-reservas-" + n.getAndIncrement()));

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

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

    /**
     * Encola una reserva. BLOQUEA si la cola esta llena: es la
     * contrapresion, y es una caracteristica, no un defecto.
     */
    public void encolar(Reserva r) throws InterruptedException {
        if (!aceptandoNuevas) {
            throw new IllegalStateException("El procesador se esta apagando");
        }
        cola.put(r);      // espera si esta llena
    }

    /**
     * Variante que no espera indefinidamente: si en 2 segundos no hay
     * hueco, rechaza. Es lo apropiado para una interfaz de usuario:
     * mejor decir "el sistema esta saturado" que dejar el menu colgado.
     */
    public boolean encolarConPlazo(Reserva r) throws InterruptedException {
        boolean aceptada = cola.offer(r, 2, TimeUnit.SECONDS);
        if (!aceptada) {
            rechazadas.incrementAndGet();
            LOG.log(Level.WARNING, "Reserva rechazada por saturacion: {0}", r.id());
        }
        return aceptada;
    }

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

    private void bucleConsumidor() {
        String yo = Thread.currentThread().getName();
        LOG.log(Level.INFO, "[{0}] consumidor listo", yo);
        try {
            while (true) {
                // take() BLOQUEA sin consumir CPU si la cola esta vacia.
                // Es la alternativa correcta al sondeo con sleep (08-03).
                Reserva r = cola.take();

                // PILDORA VENENOSA: senal de apagado (apartado 12).
                if (r == Reserva.FIN) {
                    LOG.log(Level.INFO, "[{0}] pildora recibida, termino", yo);
                    return;
                }

                try {
                    atender(r);
                    atendidas.incrementAndGet();
                } catch (Exception e) {
                    // Un fallo individual NO debe matar al consumidor:
                    // si muere, el pool pierde capacidad silenciosamente.
                    LOG.log(Level.WARNING, "[" + yo + "] reserva fallida: " + r.id(), e);
                }
            }
        } catch (InterruptedException e) {
            LOG.log(Level.INFO, "[{0}] consumidor interrumpido", yo);
            Thread.currentThread().interrupt();     // restaurar (08-02)
        }
    }

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

    // ---------- APAGADO ----------

    /**
     * Apagado ORDENADO: deja de aceptar, inserta una pildora por
     * consumidor y espera. Todo lo que ya estaba en la cola se procesa.
     */
    @Override
    public void close() {
        aceptandoNuevas = false;
        try {
            for (int i = 0; i < CONSUMIDORES; i++) {
                cola.put(Reserva.FIN);       // una por consumidor
            }
            consumidores.shutdown();
            if (!consumidores.awaitTermination(30, TimeUnit.SECONDS)) {
                consumidores.shutdownNow();
            }
        } catch (InterruptedException e) {
            consumidores.shutdownNow();
            Thread.currentThread().interrupt();
        }
        LOG.log(Level.INFO, "Procesador cerrado: {0} atendidas, {1} rechazadas",
                new Object[] { atendidas.get(), rechazadas.get() });
    }

    public int atendidas()  { return atendidas.get(); }
    public int rechazadas() { return rechazadas.get(); }
    public int pendientes() { return cola.size(); }
}

public class DemostracionReservas {

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

        try (ProcesadorReservas procesador = new ProcesadorReservas()) {

            // Tres productores: tres empleados usando el menu a la vez.
            Thread[] productores = new Thread[3];
            for (int p = 0; p < 3; p++) {
                final String empleado = switch (p) {
                    case 0 -> "Marta Ruiz";
                    case 1 -> "Diego Alonso";
                    default -> "Nuria Vidal";
                };
                productores[p] = new Thread(() -> {
                    try {
                        for (int i = 1; i <= 40; i++) {
                            procesador.encolar(new Reserva(
                                    empleado + "-R" + i, "978-000000000" + (i % 3 + 1)));
                            TimeUnit.MILLISECONDS.sleep(20);
                        }
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                    }
                }, "menu-" + empleado.split(" ")[0]);
                productores[p].start();
            }

            // Progreso mientras trabajan.
            for (int t = 0; t < 10; t++) {
                System.out.printf("  atendidas=%d  pendientes=%d%n",
                        procesador.atendidas(), procesador.pendientes());
                TimeUnit.MILLISECONDS.sleep(400);
            }

            for (Thread p : productores) p.join();
            System.out.println("Todos los productores han terminado");

        }   // close(): pildoras venenosas y espera al vaciado
    }
}

  atendidas=0  pendientes=3
  atendidas=12  pendientes=14
  atendidas=25  pendientes=26
  atendidas=38  pendientes=39
  atendidas=51  pendientes=50   <-- cola LLENA: los productores se frenan
  atendidas=64  pendientes=50
  atendidas=77  pendientes=43
  atendidas=90  pendientes=30
  atendidas=103  pendientes=17
  atendidas=113  pendientes=7
Todos los productores han terminado
INFO: Procesador cerrado: 120 atendidas, 0 rechazadas

package com.nexussoftware.bibliotech.dominio;

public record Reserva(String id, String isbn) {

    /**
     * PILDORA VENENOSA: instancia centinela que significa
     * "no habra mas trabajo, termina".
     *
     * Se compara con == (identidad), no con equals: es un objeto
     * unico e irrepetible, y ningun dato real puede coincidir con el.
     */
    public static final Reserva FIN = new Reserva("__FIN__", "__FIN__");
}

for (int i = 0; i < CONSUMIDORES; i++) {
    cola.put(Reserva.FIN);
}

// Alternativa: una sola pildora que cada consumidor reinyecta.
if (r == Reserva.FIN) {
    cola.put(Reserva.FIN);   // pasarla al siguiente
    return;
}

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

// Prestamos ordenados por fecha de vencimiento (en milisegundos).
NavigableMap<Long, Prestamo> porVencimiento = new ConcurrentSkipListMap<>();

porVencimiento.put(vencimientoMs, prestamo);

// Todos los vencidos antes de ahora, en orden, sin bloquear a nadie.
NavigableMap<Long, Prestamo> vencidos =
        porVencimiento.headMap(System.currentTimeMillis(), true);

import java.util.concurrent.atomic.AtomicInteger;

public class ContadorAtomico {

    private final AtomicInteger valor = new AtomicInteger(0);

    public void incrementar() {
        valor.incrementAndGet();     // ATOMICO, sin candado
    }

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

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

        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.println("Esperado: " + VUELTAS * 2 + ", real: " + c.valor());
    }
}

Esperado: 2000000, real: 2000000

AtomicInteger a = new AtomicInteger(10);

// "Si vale 10, ponlo a 11". Devuelve true si lo hizo.
boolean exito = a.compareAndSet(10, 11);

/**
 * Lo que hace incrementAndGet() por dentro, simplificado.
 * Es el patron BUCLE CAS, la base de toda la programacion sin candados.
 */
public int incrementAndGet() {
    while (true) {
        int actual = get();                      // 1. leer
        int siguiente = actual + 1;              // 2. calcular
        if (compareAndSet(actual, siguiente)) {  // 3. intentar escribir
            return siguiente;                    //    exito: salir
        }
        // Fallo: otro hilo cambio el valor entre 1 y 3.
        // No se ha perdido nada: se vuelve a leer y se reintenta.
    }
}

package com.nexussoftware.bibliotech.servicio;

import java.util.concurrent.atomic.*;

/**
 * Estadisticas de BiblioTech con contadores atomicos.
 * Sin un solo candado, y con lecturas que no bloquean nada.
 */
public class EstadisticasBiblioTech {

    private final AtomicLong prestamosTotales   = new AtomicLong();
    private final AtomicLong devolucionesTotales = new AtomicLong();
    private final AtomicLong multasRecaudadasCentimos = new AtomicLong();
    private final AtomicInteger prestamosActivos = new AtomicInteger();
    private final AtomicBoolean modoMantenimiento = new AtomicBoolean(false);
    private final AtomicLong maximoSimultaneos = new AtomicLong();

    public void registrarPrestamo() {
        prestamosTotales.incrementAndGet();
        int activos = prestamosActivos.incrementAndGet();

        // MAXIMO HISTORICO con accumulateAndGet: combina el valor
        // actual con 'activos' usando Math::max, atomicamente.
        // Escribirlo con get()+set() seria una carrera clasica.
        maximoSimultaneos.accumulateAndGet(activos, Math::max);
    }

    public void registrarDevolucion(long multaCentimos) {
        devolucionesTotales.incrementAndGet();
        prestamosActivos.decrementAndGet();
        if (multaCentimos > 0) {
            multasRecaudadasCentimos.addAndGet(multaCentimos);
        }
    }

    /**
     * Aplica un descuento del 10% al total recaudado.
     * updateAndGet aplica la funcion ATOMICAMENTE, con un bucle CAS
     * por debajo: si otro hilo modifica el valor entre la lectura y la
     * escritura, la funcion se REEJECUTA con el valor nuevo.
     *
     * IMPORTANTE: la funcion debe ser PURA y rapida, porque puede
     * ejecutarse varias veces. Nada de efectos secundarios.
     */
    public long aplicarDescuento() {
        return multasRecaudadasCentimos.updateAndGet(v -> (long) (v * 0.9));
    }

    /**
     * Entrar en mantenimiento SOLO SI no estabamos ya en el.
     * compareAndSet garantiza que, aunque diez hilos lo pidan a la vez,
     * exactamente UNO reciba true y ejecute la preparacion.
     * Es el idioma "solo una vez" sin candados.
     */
    public boolean entrarEnMantenimiento() {
        if (modoMantenimiento.compareAndSet(false, true)) {
            prepararMantenimiento();       // solo un hilo llega aqui
            return true;
        }
        return false;                      // otro se nos adelanto
    }

    public String resumen() {
        return String.format(
                "prestamos=%d devoluciones=%d activos=%d maximo=%d multas=%.2f EUR",
                prestamosTotales.get(), devolucionesTotales.get(),
                prestamosActivos.get(), maximoSimultaneos.get(),
                multasRecaudadasCentimos.get() / 100.0);
    }

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

package com.nexussoftware.bibliotech.servicio;

import java.util.concurrent.atomic.AtomicReference;

public class EstadoBiblioTech {

    /** Estado completo, inmutable (record de 04-07). */
    public record Estado(long prestamos, long devoluciones,
                         long multasCentimos, boolean mantenimiento) {

        Estado conPrestamo() {
            return new Estado(prestamos + 1, devoluciones, multasCentimos, mantenimiento);
        }
        Estado conDevolucion(long multa) {
            return new Estado(prestamos, devoluciones + 1,
                    multasCentimos + multa, mantenimiento);
        }
    }

    private final AtomicReference<Estado> estado =
            new AtomicReference<>(new Estado(0, 0, 0, false));

    /**
     * Lectura sin ningun bloqueo y SIEMPRE COHERENTE: los cuatro
     * campos vienen del mismo instante, porque son un solo objeto
     * inmutable. Es la ventaja sobre cuatro contadores separados.
     */
    public Estado instantanea() {
        return estado.get();
    }

    /** Actualizacion atomica de los cuatro campos a la vez. */
    public void registrarPrestamo() {
        estado.updateAndGet(Estado::conPrestamo);
    }

    public void registrarDevolucion(long multaCentimos) {
        estado.updateAndGet(e -> e.conDevolucion(multaCentimos));
    }
}

Hilo 1: lee A ................................. CAS(A -> C): EXITO
Hilo 2:      lee A, CAS(A->B), CAS(B->A)
                                                 ^
        El hilo 1 no se entera de que hubo dos cambios.
        Si su decision dependia de que NADA hubiera pasado, es un bug.

import java.util.concurrent.atomic.AtomicStampedReference;

// Cada modificacion incrementa el SELLO, aunque el valor vuelva a ser
// el mismo. El CAS comprueba valor Y sello, asi que A-B-A se detecta.
AtomicStampedReference<Nodo> cabeza =
        new AtomicStampedReference<>(nodoInicial, 0);

int[] selloActual = new int[1];
Nodo actual = cabeza.get(selloActual);

cabeza.compareAndSet(actual, nuevoNodo,
                     selloActual[0], selloActual[0] + 1);   // sello + 1

// Variante mas simple con un solo bit booleano:
// AtomicMarkableReference<Nodo>

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

public class ComparativaContadores {

    static long medirAtomicLong(int hilos, int ops) throws InterruptedException {
        AtomicLong c = new AtomicLong();
        return medir(hilos, ops, c::incrementAndGet, c::get);
    }

    static long medirLongAdder(int hilos, int ops) throws InterruptedException {
        LongAdder c = new LongAdder();
        return medir(hilos, ops, c::increment, c::sum);
    }

    static long medir(int hilos, int ops, Runnable incremento,
                      java.util.function.LongSupplier lectura) throws InterruptedException {
        CountDownLatch salida = new CountDownLatch(1);
        CountDownLatch meta = new CountDownLatch(hilos);
        for (int h = 0; h < hilos; h++) {
            new Thread(() -> {
                try {
                    salida.await();
                    for (int i = 0; i < ops; i++) incremento.run();
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                } finally { meta.countDown(); }
            }, "contador-" + h).start();
        }
        long inicio = System.nanoTime();
        salida.countDown();
        meta.await();
        long ns = System.nanoTime() - inicio;
        // Verificacion: los dos deben dar el resultado exacto.
        if (lectura.getAsLong() != (long) hilos * ops) {
            throw new AssertionError("resultado incorrecto");
        }
        return ns / 1_000_000;
    }

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

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

package com.nexussoftware.bibliotech.servicio;

import com.nexussoftware.bibliotech.dominio.Material;

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

/**
 * Catalogo concurrente de BiblioTech.
 *
 * Frente a la version con ReadWriteLock de 08-04:
 *  - No hay ningun candado explicito que soltar en un finally.
 *  - Las lecturas no bloquean NADA, ni siquiera a otras lecturas.
 *  - Las escrituras en cubetas distintas ocurren en paralelo.
 *  - Las operaciones compuestas se resuelven con los metodos atomicos
 *    del propio mapa, no encapsulando secciones criticas a mano.
 *
 * LIMITE HONESTO: un invariante que abarque VARIAS estructuras
 * (como el de RegistroPrestamos entre porId y porEmpleado) sigue
 * necesitando un candado. Las colecciones concurrentes garantizan
 * la atomicidad de UNA operacion sobre UNA coleccion, no de dos.
 */
public class CatalogoConcurrente {

    /** Indice principal por ISBN. Lecturas sin bloqueo. */
    private final ConcurrentMap<String, Material> porIsbn = new ConcurrentHashMap<>();

    /** Materiales agrupados por tipo. El valor es una lista concurrente. */
    private final ConcurrentMap<TipoMaterial, List<Material>> porTipo =
            new ConcurrentHashMap<>();

    /** Oyentes de eventos: muchas lecturas, casi ninguna escritura. */
    private final List<OyenteCatalogo> oyentes = new CopyOnWriteArrayList<>();

    // --- Estadisticas: LongAdder por su alta frecuencia de escritura ---
    private final LongAdder consultas = new LongAdder();
    private final LongAdder aciertos  = new LongAdder();
    private final LongAdder altas     = new LongAdder();
    private final AtomicLong ultimaModificacionMs = new AtomicLong();

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

    /**
     * Anade un material si su ISBN no estaba.
     * putIfAbsent es ATOMICO: aunque diez hilos anadan el mismo ISBN
     * a la vez, exactamente uno recibe true. Es el comprobar-luego-actuar
     * resuelto sin candados.
     */
    public boolean anadir(Material m) {
        if (porIsbn.putIfAbsent(m.isbn(), m) != null) {
            return false;                       // ya existia
        }
        // computeIfAbsent crea la lista solo si no existe, atomicamente.
        // CopyOnWriteArrayList porque estas listas se recorren mucho
        // mas de lo que se modifican.
        porTipo.computeIfAbsent(m.tipo(), t -> new CopyOnWriteArrayList<>()).add(m);

        altas.increment();
        ultimaModificacionMs.set(System.currentTimeMillis());
        notificarAlta(m);
        return true;
    }

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

        List<Material> lista = porTipo.get(m.tipo());
        if (lista != null) lista.remove(m);

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

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

    /** Sin candados. Con 100 hilos consultando, ninguno espera a otro. */
    public Material buscarPorIsbn(String isbn) {
        consultas.increment();
        Material m = porIsbn.get(isbn);
        if (m != null) aciertos.increment();
        return m;
    }

    /**
     * Devuelve la lista de un tipo. Como es CopyOnWriteArrayList,
     * el llamante puede iterarla con total seguridad aunque otro hilo
     * la modifique: su iterador trabaja sobre una instantanea inmutable.
     * No hace falta copiar defensivamente, a diferencia de 08-04.
     */
    public List<Material> porTipo(TipoMaterial tipo) {
        return porTipo.getOrDefault(tipo, List.of());
    }

    /**
     * Recorrido completo del catalogo.
     * El iterador es DEBILMENTE CONSISTENTE: no lanza
     * ConcurrentModificationException y no bloquea a los escritores.
     */
    public void recorrer(java.util.function.Consumer<Material> accion) {
        for (Material m : porIsbn.values()) {
            accion.accept(m);
        }
    }

    /** OJO: aproximado (apartado 7). Vale para metricas, no para control. */
    public int tamanoAproximado() {
        return porIsbn.size();
    }

    // ---------- OYENTES ----------

    public void registrarOyente(OyenteCatalogo o) { oyentes.add(o); }

    private void notificarAlta(Material m) {
        // Sin candado durante la notificacion: la regla 3 de 08-04
        // ("nunca llames a codigo ajeno con un candado") se cumple
        // automaticamente gracias a CopyOnWriteArrayList.
        for (OyenteCatalogo o : oyentes) {
            try {
                o.materialAnadido(m);
            } catch (RuntimeException e) {
                LOG.log(Level.WARNING, "Oyente fallido", e);
            }
        }
    }

    // ---------- METRICAS ----------

    public String metricas() {
        long c = consultas.sum();
        long a = aciertos.sum();
        return String.format("consultas=%d aciertos=%d tasa=%.1f%% altas=%d materiales~%d",
                c, a, c == 0 ? 0.0 : 100.0 * a / c, altas.sum(), porIsbn.size());
    }
}

public class PruebaCatalogoConcurrente {

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

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

        CatalogoConcurrente catalogo = new CatalogoConcurrente();
        CountDownLatch salida = new CountDownLatch(1);
        CountDownLatch meta   = new CountDownLatch(HILOS);

        for (int h = 0; h < HILOS; h++) {
            final int id = h;
            new Thread(() -> {
                try {
                    salida.await();
                    ThreadLocalRandom azar = ThreadLocalRandom.current();
                    for (int i = 0; i < OPS; i++) {
                        if (azar.nextInt(100) < 90) {
                            catalogo.buscarPorIsbn("978-" + azar.nextInt(1000));
                        } else {
                            catalogo.anadir(new Libro(
                                    "978-" + azar.nextInt(1000), "Titulo", "Autor"));
                        }
                    }
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                } finally { meta.countDown(); }
            }, "catalogo-" + id).start();
        }

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

        System.out.println("Operaciones : " + (HILOS * OPS));
        System.out.println("Tiempo      : " + ms + " ms");
        System.out.println("Throughput  : " + (HILOS * OPS / Math.max(ms, 1)) + " ops/ms");
        System.out.println(catalogo.metricas());
    }
}

Operaciones : 1600000
Tiempo      : 312 ms
Throughput  : 5128 ops/ms
Metricas    : consultas=1439871 aciertos=1438204 tasa=99.9% altas=1000 materiales~1000

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

public class TresGeneraciones {

    static final int HILOS = 12;
    static final int OPS = 100_000;
    static final int CLAVES = 5_000;

    record Resultado(String nombre, long ms, int entradas, String incidencia) { }

    static Resultado medir(String nombre, Map<Integer, String> mapa)
            throws InterruptedException {

        CountDownLatch salida = new CountDownLatch(1);
        CountDownLatch meta   = new CountDownLatch(HILOS);
        // volatile no basta para acumular texto desde varios hilos:
        // usamos una cola concurrente para recoger incidencias.
        Queue<String> incidencias = new ConcurrentLinkedQueue<>();

        for (int h = 0; h < HILOS; h++) {
            Thread t = new Thread(() -> {
                try {
                    salida.await();
                    ThreadLocalRandom azar = ThreadLocalRandom.current();
                    for (int i = 0; i < OPS; i++) {
                        int clave = azar.nextInt(CLAVES);
                        if (azar.nextInt(100) < 80) {
                            mapa.get(clave);
                        } else {
                            mapa.put(clave, "v" + i);
                        }
                    }
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                } catch (RuntimeException e) {
                    incidencias.add(e.getClass().getSimpleName());
                } finally {
                    meta.countDown();
                }
            }, nombre + "-" + h);
            t.setDaemon(true);      // demonio: si entra en bucle infinito,
            t.start();              // no impedira que la JVM termine
        }

        long inicio = System.nanoTime();
        salida.countDown();

        // Plazo: el HashMap sin proteccion puede no terminar NUNCA.
        boolean completado = meta.await(20, TimeUnit.SECONDS);
        long ms = (System.nanoTime() - inicio) / 1_000_000;

        String inc = completado
                ? (incidencias.isEmpty() ? "-" : incidencias.peek())
                : "NO TERMINO (bucle infinito o corrupcion)";

        int entradas;
        try {
            entradas = mapa.size();
        } catch (RuntimeException e) {
            entradas = -1;
        }
        return new Resultado(nombre, ms, entradas, inc);
    }

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

        System.out.printf("%d hilos x %d ops (80%% lectura) sobre %d claves%n%n",
                HILOS, OPS, CLAVES);

        List<Resultado> resultados = new ArrayList<>();
        resultados.add(medir("HashMap", new HashMap<>()));
        resultados.add(medir("synchronizedMap", Collections.synchronizedMap(new HashMap<>())));
        resultados.add(medir("ConcurrentHashMap", new ConcurrentHashMap<>()));

        System.out.printf("%-20s | %8s | %10s | %-40s%n",
                "Implementacion", "ms", "entradas", "incidencia");
        System.out.println("---------------------|----------|------------|"
                + "------------------------------------------");
        for (Resultado r : resultados) {
            System.out.printf("%-20s | %8d | %10d | %-40s%n",
                    r.nombre(), r.ms(), r.entradas(), r.incidencia());
        }

        System.out.println();
        System.out.println("Esperado: " + CLAVES + " entradas (todas las claves tocadas)");
    }
}

12 hilos x 100000 ops (80% lectura) sobre 5000 claves

Implementacion       |       ms |   entradas | incidencia
---------------------|----------|------------|------------------------------------------
HashMap              |    20003 |       4211 | NO TERMINO (bucle infinito o corrupcion)
synchronizedMap      |     1876 |       5000 | -
ConcurrentHashMap    |      147 |       5000 | -

Esperado: 5000 entradas (todas las claves tocadas)

package com.nexussoftware.bibliotech.persistencia;

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

public class PipelineImportacion {

    private static final String PILDORA = "__FIN__";
    private static final int CAPACIDAD = 20;
    private static final int PRODUCTORES = 2;
    private static final int CONSUMIDORES = 4;
    private static final int LINEAS_POR_PRODUCTOR = 150;

    // Cola ACOTADA: si los consumidores no dan abasto, los productores
    // se bloquean en put(). Contrapresion.
    private final BlockingQueue<String> cola = new ArrayBlockingQueue<>(CAPACIDAD);

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

    // LongAdder: escrituras muy frecuentes, lecturas ocasionales.
    private final LongAdder leidas     = new LongAdder();
    private final LongAdder creados    = new LongAdder();
    private final LongAdder descartadas = new LongAdder();

    private volatile boolean enMarcha = true;

    // ---------- ETAPA 1: PRODUCTORES ----------

    private void producir(int idProductor) {
        try {
            for (int i = 0; i < LINEAS_POR_PRODUCTOR; i++) {
                String linea = "978-" + idProductor + String.format("%05d", i)
                        + ";Titulo " + i + ";Autor";
                cola.put(linea);      // BLOQUEA si la cola esta llena
                leidas.increment();
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }

    // ---------- ETAPA 2: CONSUMIDORES ----------

    private void consumir() {
        String yo = Thread.currentThread().getName();
        try {
            while (true) {
                String linea = cola.take();      // BLOQUEA si esta vacia

                // Pildora venenosa: comparacion por IDENTIDAD.
                if (linea == PILDORA) {
                    System.out.println("  [" + yo + "] pildora recibida, termino");
                    return;
                }
                try {
                    TimeUnit.MILLISECONDS.sleep(30);      // conversion "cara"
                    String[] campos = linea.split(";");
                    if (campos.length < 3) {
                        throw new IllegalArgumentException("linea incompleta");
                    }
                    materiales.put(campos[0], campos[1]);
                    creados.increment();
                } catch (IllegalArgumentException e) {
                    descartadas.increment();               // degradar (06-07)
                }
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }

    // ---------- ORQUESTACION ----------

    public void ejecutar() throws InterruptedException {

        ExecutorService productores = Executors.newFixedThreadPool(PRODUCTORES,
                new NombradorHilos("pipeline-productor"));
        ExecutorService consumidores = Executors.newFixedThreadPool(CONSUMIDORES,
                new NombradorHilos("pipeline-consumidor"));

        for (int c = 0; c < CONSUMIDORES; c++) consumidores.execute(this::consumir);

        CountDownLatch produccionTerminada = new CountDownLatch(PRODUCTORES);
        for (int p = 0; p < PRODUCTORES; p++) {
            final int id = p;
            productores.execute(() -> {
                try { producir(id); }
                finally { produccionTerminada.countDown(); }   // SIEMPRE
            });
        }

        // Monitor: demuestra que la cola se llena y frena a los productores.
        Thread monitor = new Thread(() -> {
            try {
                while (enMarcha) {
                    System.out.printf("      [monitor] cola=%2d/%d  leidas=%d  creados=%d%n",
                            cola.size(), CAPACIDAD, leidas.sum(), creados.sum());
                    TimeUnit.MILLISECONDS.sleep(300);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }, "pipeline-monitor");
        monitor.setDaemon(true);
        monitor.start();

        // 1. Esperar a que los productores acaben.
        produccionTerminada.await();
        System.out.println("  Produccion terminada; inyectando pildoras");

        // 2. UNA pildora POR CONSUMIDOR, al final de la cola:
        //    todo lo anterior se procesa antes.
        for (int c = 0; c < CONSUMIDORES; c++) cola.put(PILDORA);

        // 3. Apagado ordenado en dos fases.
        productores.shutdown();
        consumidores.shutdown();
        boolean ok = consumidores.awaitTermination(30, TimeUnit.SECONDS);
        if (!ok) consumidores.shutdownNow();

        enMarcha = false;
        monitor.interrupt();

        // 4. Verificacion.
        long total = LINEAS_POR_PRODUCTOR * PRODUCTORES;
        System.out.println();
        System.out.println("=== RESULTADO ===");
        System.out.println("Lineas producidas : " + leidas.sum() + " (esperado " + total + ")");
        System.out.println("Materiales creados: " + creados.sum());
        System.out.println("Descartadas       : " + descartadas.sum());
        System.out.println("En el mapa        : " + materiales.size());
        System.out.println("Cola al final     : " + cola.size() + " (debe ser 0)");
        System.out.println("Sin perdidas      : "
                + (creados.sum() + descartadas.sum() == total));
    }

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

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

      [monitor] cola=20/20  leidas= 42  creados= 22
      [monitor] cola=20/20  leidas= 82  creados= 62
      [monitor] cola=20/20  leidas=122  creados=102
      [monitor] cola=20/20  leidas=162  creados=142
      ...
  Produccion terminada; inyectando pildoras
  [pipeline-consumidor-2] pildora recibida, termino
  [pipeline-consumidor-1] pildora recibida, termino
  [pipeline-consumidor-4] pildora recibida, termino
  [pipeline-consumidor-3] pildora recibida, termino

=== RESULTADO ===
Lineas producidas : 300 (esperado 300)
Materiales creados: 300
Descartadas       : 0
En el mapa        : 300
Cola al final     : 0 (debe ser 0)
Sin perdidas      : true

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

public class ComparativaEstadisticas {

    interface Contador {
        void registrarPrestamo();
        long total();
        String nombre();
    }

    /** (a) long protegido con synchronized. */
    static class ConSynchronized implements Contador {
        private long prestamos = 0;
        public synchronized void registrarPrestamo() { prestamos++; }
        public synchronized long total() { return prestamos; }
        public String nombre() { return "synchronized"; }
    }

    /** (b) AtomicLong: bucle CAS por debajo. */
    static class ConAtomicLong implements Contador {
        private final AtomicLong prestamos = new AtomicLong();
        public void registrarPrestamo() { prestamos.incrementAndGet(); }
        public long total() { return prestamos.get(); }
        public String nombre() { return "AtomicLong"; }
    }

    /** (c) LongAdder: celdas separadas, suma al leer. */
    static class ConLongAdder implements Contador {
        private final LongAdder prestamos = new LongAdder();
        public void registrarPrestamo() { prestamos.increment(); }
        public long total() { return prestamos.sum(); }
        public String nombre() { return "LongAdder"; }
    }

    /** (d) AtomicReference sobre un record inmutable de TRES campos. */
    static class ConAtomicReference implements Contador {

        record Estado(long prestamos, long devoluciones, long multas) {
            Estado conPrestamo() {
                return new Estado(prestamos + 1, devoluciones, multas);
            }
        }

        private final AtomicReference<Estado> estado =
                new AtomicReference<>(new Estado(0, 0, 0));

        public void registrarPrestamo() {
            // updateAndGet reintenta si otro hilo se adelanto.
            // La funcion debe ser PURA: puede ejecutarse varias veces.
            estado.updateAndGet(Estado::conPrestamo);
        }

        public long total() { return estado.get().prestamos(); }

        /** VENTAJA UNICA: instantanea COHERENTE de los tres campos. */
        public Estado instantanea() { return estado.get(); }

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

    static long medir(Contador c, int hilos, int porHilo) throws InterruptedException {
        CountDownLatch salida = new CountDownLatch(1);
        CountDownLatch meta   = new CountDownLatch(hilos);

        for (int h = 0; h < hilos; h++) {
            new Thread(() -> {
                try {
                    salida.await();
                    for (int i = 0; i < porHilo; i++) c.registrarPrestamo();
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                } finally { meta.countDown(); }
            }, "est-" + h).start();
        }

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

        long esperado = (long) hilos * porHilo;
        if (c.total() != esperado) {
            throw new AssertionError(c.nombre() + " INCORRECTO: "
                    + c.total() + " != " + esperado);
        }
        return ms;
    }

    static Contador nueva(int tipo) {
        return switch (tipo) {
            case 0 -> new ConSynchronized();
            case 1 -> new ConAtomicLong();
            case 2 -> new ConLongAdder();
            default -> new ConAtomicReference();
        };
    }

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

        final int TOTAL = 8_000_000;

        // Calentamiento (JIT).
        for (int t = 0; t < 4; t++) medir(nueva(t), 4, 50_000);

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

            for (int t = 0; t < 4; t++) {
                Contador c = nueva(t);
                long ms = medir(c, hilos, TOTAL / hilos);
                System.out.printf("%-26s | %8d | %14d%n",
                        c.nombre(), ms, TOTAL / Math.max(ms, 1));
            }
        }

        // Demostracion de la ventaja unica de AtomicReference.
        ConAtomicReference ar = new ConAtomicReference();
        medir(ar, 8, 100_000);
        ConAtomicReference.Estado foto = ar.instantanea();
        System.out.printf("%nInstantanea COHERENTE: prestamos=%d devoluciones=%d multas=%d%n",
                foto.prestamos(), foto.devoluciones(), foto.multas());
        System.out.println("Los tres campos vienen del MISMO instante, cosa que");
        System.out.println("tres contadores independientes no pueden garantizar.");
    }
}

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

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

Instantanea COHERENTE: prestamos=800000 devoluciones=0 multas=0
Los tres campos vienen del MISMO instante, cosa que
tres contadores independientes no pueden garantizar.