public void ejemplo() {
    int contador = 42;                              // el VALOR está en la pila
    Libro libro = new Libro("978-0000000001", "Java Efectivo");
    //   ^ la REFERENCIA está en la pila       ^ el OBJETO está en el heap
}

public class MemoriaDisponible {

    public static void main(String[] args) {
        Runtime rt = Runtime.getRuntime();

        System.out.printf("Máxima  (-Xmx):  %,d MB%n", rt.maxMemory()   / 1024 / 1024);
        System.out.printf("Total reservada: %,d MB%n", rt.totalMemory() / 1024 / 1024);
        System.out.printf("Libre en total:  %,d MB%n", rt.freeMemory()  / 1024 / 1024);
        System.out.printf("En uso:          %,d MB%n",
                (rt.totalMemory() - rt.freeMemory()) / 1024 / 1024);
        System.out.printf("Procesadores:    %d%n", rt.availableProcessors());
    }
}

Máxima  (-Xmx):  4.096 MB
Total reservada: 258 MB
Libre en total:  196 MB
En uso:          62 MB
Procesadores:    8

public class Marcos {

    public static void main(String[] args) {    // marco 1
        int a = 10;
        primero(a);
    }

    static void primero(int x) {                // marco 2
        String texto = "BiblioTech";
        segundo(x * 2, texto);
    }

    static void segundo(int y, String t) {      // marco 3
        System.out.println(y + " " + t);
    }                                            // marco 3 se descarta
}

public class DesbordamientoDePila {

    private static int profundidad = 0;

    static void recursionInfinita() {
        profundidad++;
        recursionInfinita();                    // sin caso base
    }

    public static void main(String[] args) {
        try {
            recursionInfinita();
        } catch (StackOverflowError e) {
            System.out.println("StackOverflowError a los " + profundidad + " marcos");
        }
    }
}

StackOverflowError a los 21847 marcos

java -Xss1m MiPrograma      # 1 MB por hilo (típico por defecto en 64 bits)
java -Xss16m MiPrograma     # para recursión profunda legítima
java -Xss256k MiPrograma    # para tener MUCHOS hilos

Libro libro = new Libro("978-0000000001", "Java Efectivo", "Joshua Bloch", 412, 4.85);

java -XX:+PrintFlagsFinal -version | grep -i UseCompressedOops

bool UseCompressedOops = true    {lp64_product} {default}

java -XX:MaxMetaspaceSize=256m MiPrograma

Java HotSpot(TM) 64-Bit Server VM warning: CodeCache is full.
    Compiler has been disabled.

java -XX:ReservedCodeCacheSize=512m MiPrograma

// Buffer DIRECTO: la memoria NO está en el heap
ByteBuffer directo = ByteBuffer.allocateDirect(64 * 1024 * 1024);   // 64 MB nativos

// Buffer normal: SÍ está en el heap
ByteBuffer enHeap = ByteBuffer.allocate(64 * 1024 * 1024);

java -XX:MaxDirectMemorySize=512m MiPrograma

Memoria total ≈ Heap (-Xmx)
              + Metaspace
              + Caché de código
              + (Número de hilos × -Xss)
              + Buffers directos
              + Estructuras internas de la JVM (~100-300 MB)

java -XX:MaxRAMPercentage=70 -jar bibliotech.jar

package com.nexussoftware.bibliotech.diagnostico;

import java.util.ArrayList;
import java.util.List;

public class ProvocarOutOfMemory {

    /** Ejecutar con: java -Xmx64m -XX:+HeapDumpOnOutOfMemoryError */
    public static void main(String[] args) {

        List<byte[]> retenidos = new ArrayList<>();
        int bloques = 0;

        try {
            while (true) {
                retenidos.add(new byte[1024 * 1024]);      // 1 MB cada vez
                bloques++;
            }
        } catch (OutOfMemoryError e) {
            // Capturar OOM solo para DIAGNOSTICAR y salir. Nunca para continuar.
            System.err.println("OutOfMemoryError tras " + bloques + " MB");
            System.err.println("Mensaje: " + e.getMessage());
            retenidos.clear();                              // liberar para poder imprimir
            System.exit(1);
        }
    }
}

OutOfMemoryError tras 61 MB
Mensaje: Java heap space

java -XX:+HeapDumpOnOutOfMemoryError \
     -XX:HeapDumpPath=/var/log/bibliotech/heapdumps/ \
     -XX:+ExitOnOutOfMemoryError \
     -jar bibliotech.jar

java -Xlog:gc -Xmx256m -jar bibliotech.jar

[0.412s][info][gc] GC(0) Pause Young (Normal) (G1 Evacuation Pause) 51M->8M(256M) 6.412ms
[1.238s][info][gc] GC(1) Pause Young (Normal) (G1 Evacuation Pause) 59M->12M(256M) 5.891ms
[2.104s][info][gc] GC(2) Pause Young (Normal) (G1 Evacuation Pause) 63M->14M(256M) 7.203ms
[8.771s][info][gc] GC(9) Pause Full (System.gc()) 198M->31M(256M) 187.442ms

java -XX:+DisableExplicitGC -jar bibliotech.jar

java -Xlog:safepoint -jar bibliotech.jar

[3.201s][info][safepoint] Safepoint "G1CollectForAllocation", Time since last: 812 ms,
    Reaching safepoint: 47 ms, At safepoint: 8 ms, Total: 55 ms

java -XX:+UseG1GC -XX:MaxGCPauseMillis=200 -Xmx8g -jar bibliotech.jar

java -XX:+UseZGC -XX:+ZGenerational -Xmx16g -jar bibliotech.jar

java -XX:+UnlockExperimentalVMOptions -XX:+UseEpsilonGC -Xmx1g PruebaDeAsignacion

java -XX:+PrintFlagsFinal -version | wc -l

1247

java -Xmx4g -jar bibliotech.jar

java -XX:MaxRAMPercentage=70 -jar bibliotech.jar

java -Xms4g -Xmx4g -jar bibliotech.jar

java -XX:+UseG1GC -XX:MaxGCPauseMillis=200 ...

java -Xms2g -Xmx2g \
     -XX:+UseG1GC \
     -XX:MaxGCPauseMillis=200 \
     -XX:+HeapDumpOnOutOfMemoryError \
     -XX:HeapDumpPath=/var/log/bibliotech/ \
     -XX:+ExitOnOutOfMemoryError \
     -Xlog:gc*:file=/var/log/bibliotech/gc.log:time,uptime:filecount=5,filesize=10M \
     -jar bibliotech.jar

[3600.1s] GC(1201) Pause Young 892M->741M(1024M) 41.2ms
[3612.4s] GC(1202) Pause Young 901M->768M(1024M) 44.8ms
[3625.9s] GC(1203) Pause Young 918M->794M(1024M) 48.1ms
[3641.2s] GC(1204) Pause Full  1010M->961M(1024M) 892.3ms
[3644.7s] GC(1205) Pause Full  1014M->978M(1024M) 941.7ms
[3648.1s] GC(1206) Pause Full  1020M->1009M(1024M) 1102.4ms
java.lang.OutOfMemoryError: GC overhead limit exceeded

package com.nexussoftware.bibliotech.servicio;

import java.util.*;

/**
 * FUGA: la cache crece indefinidamente.
 */
public class CacheConFuga {

    // static: es una RAIZ DEL GC. Todo lo que cuelgue de aqui vive
    // mientras viva la clase, es decir, para siempre.
    private static final Map<String, Ficha> CACHE = new HashMap<>();

    public Ficha obtener(String isbn) {
        return CACHE.computeIfAbsent(isbn, this::calcularFicha);
    }
    // Nunca se elimina nada. Con un millon de ISBN distintos,
    // un millon de fichas retenidas para siempre.
}

/** CORRECTO: cache ACOTADA con expulsion LRU (10-01). */
public class CacheAcotada {

    private static final int CAPACIDAD = 10_000;

    private final Map<String, Ficha> cache =
            Collections.synchronizedMap(new LinkedHashMap<>(CAPACIDAD, 0.75f, true) {
                @Override
                protected boolean removeEldestEntry(Map.Entry<String, Ficha> masAntigua) {
                    return size() > CAPACIDAD;
                }
            });

    public Ficha obtener(String isbn) {
        return cache.computeIfAbsent(isbn, this::calcularFicha);
    }
}

package com.nexussoftware.bibliotech.presentacion;

import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;

public class GestorDeEventos {

    private static final List<Consumer<String>> SUSCRIPTORES = new ArrayList<>();

    public static void suscribir(Consumer<String> suscriptor) {
        SUSCRIPTORES.add(suscriptor);
    }

    public static void publicar(String evento) {
        SUSCRIPTORES.forEach(s -> s.accept(evento));
    }
}

/** FUGA: se suscribe y nunca se da de baja. */
public class VentanaPrestamos {

    private final List<Prestamo> prestamos = new ArrayList<>(10_000);   // objeto pesado

    public VentanaPrestamos() {
        // La LAMBDA captura 'this' implicitamente al usar un campo.
        // GestorDeEventos.SUSCRIPTORES (static) retiene la lambda,
        // la lambda retiene esta VentanaPrestamos,
        // y esta ventana retiene sus 10.000 prestamos. PARA SIEMPRE.
        GestorDeEventos.suscribir(evento -> actualizar(evento));
    }

    private void actualizar(String evento) { /* usa prestamos */ }

    public void cerrar() {
        // No hay forma de darse de baja: no guardamos la referencia
    }
}

/** CORRECTO: guardar la referencia y darse de baja. */
public class VentanaPrestamosCorrecta implements AutoCloseable {

    private final List<Prestamo> prestamos = new ArrayList<>(10_000);
    private final Consumer<String> suscriptor;

    public VentanaPrestamosCorrecta() {
        this.suscriptor = this::actualizar;       // guardamos la referencia
        GestorDeEventos.suscribir(suscriptor);
    }

    private void actualizar(String evento) { }

    @Override
    public void close() {
        GestorDeEventos.desuscribir(suscriptor);   // simetria: suscribir/desuscribir
    }
}

package com.nexussoftware.bibliotech.servicio;

/**
 * FUGA: el hilo del pool NO muere, asi que su ThreadLocal tampoco.
 */
public class ContextoConFuga {

    private static final ThreadLocal<ContextoPeticion> CONTEXTO = new ThreadLocal<>();

    public static void procesar(String empleado, Runnable tarea) {
        CONTEXTO.set(new ContextoPeticion(empleado));    // se guarda...
        tarea.run();
        // ...y NUNCA se limpia.
    }
}

/** CORRECTO: limpieza garantizada con finally. */
public class ContextoCorrecto {

    private static final ThreadLocal<ContextoPeticion> CONTEXTO = new ThreadLocal<>();

    public static void procesar(String empleado, Runnable tarea) {
        CONTEXTO.set(new ContextoPeticion(empleado));
        try {
            tarea.run();
        } finally {
            CONTEXTO.remove();          // OBLIGATORIO, y en finally
        }
    }
}

package com.nexussoftware.bibliotech.servicio;

import java.util.ArrayList;
import java.util.List;

public class CatalogoPesado {

    private final List<Material> materiales = new ArrayList<>(100_000);   // ~50 MB

    /**
     * NO estatica: retiene implicitamente a CatalogoPesado.
     */
    public class ContadorSimple {
        private int cuenta;
        public void incrementar() { cuenta++; }
        public int getCuenta()    { return cuenta; }
        // No usa 'materiales' para nada, y sin embargo lo retiene
    }

    public ContadorSimple crearContador() {
        return new ContadorSimple();
    }
}

// Se crea el catalogo de 50 MB, se saca un contador de 16 bytes
// y se descarta el catalogo... pero el contador lo retiene.
ContadorSimple contador;
{
    CatalogoPesado catalogo = new CatalogoPesado();
    contador = catalogo.crearContador();
}
// 'catalogo' ya no es alcanzable... EXCEPTO a traves de contador.this$0
// Los 50 MB siguen ahí.

/** CORRECTO: static, sin referencia a la externa. */
public static class ContadorSimple {
    private int cuenta;
    public void incrementar() { cuenta++; }
    public int getCuenta()    { return cuenta; }
}

package com.nexussoftware.bibliotech.diagnostico;

import java.lang.ref.*;

public class FuerzasDeReferencia {

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

        // --- FUERTE: el GC no la toca ---
        Libro fuerte = new Libro("978-0000000001", "Java Efectivo");
        System.gc();
        Thread.sleep(100);
        System.out.println("Fuerte tras GC:  " + (fuerte != null));      // true

        // --- DEBIL: desaparece en el siguiente GC ---
        WeakReference<Libro> debil = new WeakReference<>(
                new Libro("978-0000000002", "Patrones de Diseño"));
        System.out.println("Débil antes:     " + (debil.get() != null)); // true
        System.gc();
        Thread.sleep(100);
        System.out.println("Débil tras GC:   " + (debil.get() != null)); // false

        // --- BLANDA: sobrevive mientras haya memoria ---
        SoftReference<Libro> blanda = new SoftReference<>(
                new Libro("978-0000000003", "Refactorización"));
        System.gc();
        Thread.sleep(100);
        System.out.println("Blanda tras GC:  " + (blanda.get() != null)); // true

        // --- FANTASMA: get() SIEMPRE devuelve null ---
        ReferenceQueue<Libro> cola = new ReferenceQueue<>();
        PhantomReference<Libro> fantasma = new PhantomReference<>(
                new Libro("978-0000000004", "Código Limpio"), cola);
        System.out.println("Fantasma.get():  " + fantasma.get());        // siempre null

        System.gc();
        Thread.sleep(100);
        Reference<?> encolada = cola.poll();
        System.out.println("¿Notificada?     " + (encolada != null));    // true
    }
}

Fuerte tras GC:  true
Débil antes:     true
Débil tras GC:   false
Blanda tras GC:  true
Fantasma.get():  null
¿Notificada?     true

package com.nexussoftware.bibliotech.diagnostico;

import java.util.*;

public class ComparacionDeMapas {

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

        Map<Libro, String> normal = new HashMap<>();
        Map<Libro, String> debil = new WeakHashMap<>();

        Libro retenido  = new Libro("978-0000000001", "Java Efectivo");
        Libro temporal  = new Libro("978-0000000002", "Patrones de Diseño");

        normal.put(retenido, "estante A-1");
        normal.put(temporal, "estante A-2");
        debil.put(retenido, "estante A-1");
        debil.put(temporal, "estante A-2");

        System.out.println("Antes -> HashMap: " + normal.size()
                         + ", WeakHashMap: " + debil.size());

        temporal = null;          // se pierde la ultima referencia FUERTE
        System.gc();
        Thread.sleep(200);

        System.out.println("Después -> HashMap: " + normal.size()
                         + ", WeakHashMap: " + debil.size());
    }
}

Antes -> HashMap: 2, WeakHashMap: 2
Después -> HashMap: 2, WeakHashMap: 1

package com.nexussoftware.bibliotech.servicio;

import com.nexussoftware.bibliotech.dominio.*;

import java.time.Instant;
import java.util.*;

/**
 * Caché de fichas de BiblioTech con dos niveles.
 *
 * Nivel 1 (WeakHashMap): fichas asociadas a materiales VIVOS.
 *   Si el material desaparece del catálogo, su ficha se libera sola.
 *
 * Nivel 2 (LinkedHashMap LRU): fichas por ISBN, acotada.
 *   Sobrevive a la desaparición del material, pero con tope.
 */
public class CacheFichas {

    private static final int CAPACIDAD_LRU = 5_000;

    /**
     * Clave: el objeto Material. Referencia DEBIL.
     * Si nadie más referencia al material, la entrada se va sola.
     */
    private final Map<Material, Ficha> porMaterial =
            Collections.synchronizedMap(new WeakHashMap<>());

    /**
     * Clave: el ISBN (un String, referencia fuerte).
     * Aquí SI hace falta política de expulsión explícita.
     */
    private final Map<String, Ficha> porIsbn =
            Collections.synchronizedMap(new LinkedHashMap<>(CAPACIDAD_LRU, 0.75f, true) {
                @Override
                protected boolean removeEldestEntry(Map.Entry<String, Ficha> masAntigua) {
                    return size() > CAPACIDAD_LRU;
                }
            });

    private long aciertosDebiles = 0;
    private long aciertosLru = 0;
    private long fallos = 0;

    public Ficha obtener(Material material) {
        Ficha porObjeto = porMaterial.get(material);
        if (porObjeto != null) {
            aciertosDebiles++;
            return porObjeto;
        }

        Ficha porClave = porIsbn.get(material.getIsbn());
        if (porClave != null) {
            aciertosLru++;
            porMaterial.put(material, porClave);      // repoblar el nivel 1
            return porClave;
        }

        fallos++;
        Ficha nueva = calcular(material);
        porMaterial.put(material, nueva);
        porIsbn.put(material.getIsbn(), nueva);
        return nueva;
    }

    private Ficha calcular(Material material) {
        // Cálculo costoso: consultas, agregados, formateo
        return new Ficha(material.getIsbn(), material.getTitulo(), true);
    }

    public String estadisticas() {
        long total = aciertosDebiles + aciertosLru + fallos;
        return """
                CacheFichas
                  Nivel 1 (WeakHashMap): %d entradas vivas, %d aciertos
                  Nivel 2 (LRU %d):      %d entradas, %d aciertos
                  Fallos:                %d
                  Tasa de acierto:       %.1f %%"""
                .formatted(porMaterial.size(), aciertosDebiles,
                           CAPACIDAD_LRU, porIsbn.size(), aciertosLru,
                           fallos, total == 0 ? 0.0
                                   : (aciertosDebiles + aciertosLru) * 100.0 / total);
    }
}

// FUGA: el valor apunta a la clave, que asi nunca queda inalcanzable
WeakHashMap<Libro, Prestamo> mapa = new WeakHashMap<>();
mapa.put(libro, new Prestamo(..., libro));      // Prestamo guarda el Libro

// NUNCA HAGAS ESTO
@Override
protected void finalize() throws Throwable {
    if (fichero != null) {
        fichero.close();
    }
}

package com.nexussoftware.bibliotech.persistencia;

import java.lang.ref.Cleaner;
import java.nio.channels.FileChannel;
import java.nio.file.*;

/**
 * Recurso con cierre determinista (AutoCloseable) MAS una red
 * de seguridad con Cleaner por si alguien olvida cerrarlo.
 */
public class AlmacenPrestamos implements AutoCloseable {

    /** UNO por aplicación: crea un hilo. */
    private static final Cleaner LIMPIADOR = Cleaner.create();

    /**
     * ESTATICA y sin referencia al objeto externo.
     * Si tuviera una referencia a AlmacenPrestamos, este nunca
     * sería inalcanzable y el Cleaner NUNCA se activaría.
     * Es la fuga 4 del apartado 12, aplicada aquí.
     */
    private static class EstadoALimpiar implements Runnable {

        private final FileChannel canal;
        private final Path ruta;

        EstadoALimpiar(FileChannel canal, Path ruta) {
            this.canal = canal;
            this.ruta = ruta;
        }

        @Override
        public void run() {
            try {
                if (canal.isOpen()) {
                    System.err.println("AVISO: AlmacenPrestamos(" + ruta
                            + ") no se cerró; lo cierra el Cleaner");
                    canal.close();
                }
            } catch (Exception e) {
                // El Cleaner traga las excepciones: no hay a quién propagarlas
            }
        }
    }

    private final EstadoALimpiar estado;
    private final Cleaner.Cleanable limpieza;

    public AlmacenPrestamos(Path ruta) throws java.io.IOException {
        FileChannel canal = FileChannel.open(ruta,
                StandardOpenOption.CREATE, StandardOpenOption.WRITE);
        this.estado = new EstadoALimpiar(canal, ruta);
        this.limpieza = LIMPIADOR.register(this, estado);
    }

    public void guardar(String linea) { /* ... */ }

    @Override
    public void close() {
        limpieza.clean();      // cierre DETERMINISTA e idempotente
    }
}

// USO NORMAL: try-with-resources, cierre garantizado y determinista
try (var almacen = new AlmacenPrestamos(Path.of("prestamos.dat"))) {
    almacen.guardar("PR-2026-0041;978-0000000001;Marta Ruiz");
}

mejora = 1 / ((1 - p) + p/s)

jps -lvm

14237 com.nexussoftware.bibliotech.BiblioTechApp -Xms2g -Xmx2g -XX:+UseG1GC
14891 jdk.jcmd/sun.tools.jps.Jps -Dapplication.home=/usr/lib/jvm/jdk-21

# Estadisticas de GC cada segundo, 10 veces
jstat -gcutil 14237 1000 10

  S0     S1     E      O      M     CCS    YGC   YGCT    FGC   FGCT    GCT
  0.00  62.31  41.20  18.44  96.12 92.03    142   1.204     2  0.381   1.585
  0.00  62.31  78.90  18.44  96.12 92.03    142   1.204     2  0.381   1.585
 58.44   0.00  12.03  18.51  96.12 92.03    143   1.213     2  0.381   1.594

# Histograma de objetos vivos, ordenado por tamaño
jmap -histo:live 14237 | head -20

 num     #instances         #bytes  class name
----------------------------------------------
   1:        847291       40669968  [B                        (byte[])
   2:        847012       20328288  java.lang.String
   3:        412008       19776384  com.nexussoftware.bibliotech.dominio.Prestamo
   4:        198432        9524736  java.util.HashMap$Node
   5:        412008        6592128  java.time.LocalDate
   6:         98211        4713-28  java.util.ArrayList

# Volcado COMPLETO del heap para analizar con herramientas gráficas
jmap -dump:live,format=b,file=/tmp/bibliotech.hprof 14237

jcmd 14237 help

GC.class_histogram
GC.heap_dump
GC.heap_info
GC.run
JFR.start
JFR.dump
Thread.print
VM.flags
VM.native_memory
VM.system_properties
VM.uptime

jcmd 14237 GC.heap_info
jcmd 14237 Thread.print              # volcado de hilos: interbloqueos (08-04)
jcmd 14237 VM.flags                  # opciones efectivas de la JVM
jcmd 14237 GC.class_histogram
jcmd 14237 VM.native_memory summary  # requiere -XX:NativeMemoryTracking=summary

Found one Java-level deadlock:
=============================
"cliente-42":
  waiting to lock monitor 0x00007f... (object 0x000000071ab2, a java.lang.Object),
  which is held by "cliente-17"
"cliente-17":
  waiting to lock monitor 0x00007f... (object 0x000000071ab3, a java.lang.Object),
  which is held by "cliente-42"

jconsole 14237

# Al arrancar
java -XX:StartFlightRecording=duration=120s,filename=/tmp/bibliotech.jfr \
     -jar bibliotech.jar

# Sobre un proceso en marcha
jcmd 14237 JFR.start name=diagnostico settings=profile duration=120s \
     filename=/tmp/bibliotech.jfr

jcmd 14237 JFR.check
jcmd 14237 JFR.dump name=diagnostico filename=/tmp/instantanea.jfr
jcmd 14237 JFR.stop name=diagnostico

jfr summary /tmp/bibliotech.jfr

 Event Type                        Count    Size (bytes)
=========================================================
 jdk.ObjectAllocationSample        18421         589472
 jdk.ExecutionSample                9204         294528
 jdk.GCPhasePause                    412          13184
 jdk.JavaMonitorEnter                287          14924
 jdk.SocketRead                      194           9312
 jdk.ThreadPark                      142           5680

# Eventos concretos
jfr print --events GCPhasePause /tmp/bibliotech.jfr | head -30
jfr print --events ObjectAllocationSample /tmp/bibliotech.jfr | head -40
jfr print --events JavaMonitorEnter /tmp/bibliotech.jfr

java -XX:StartFlightRecording=disk=true,maxsize=512m,maxage=12h,\
settings=default,filename=/var/log/bibliotech/recording.jfr \
     -XX:FlightRecorderOptions=repository=/var/log/bibliotech/jfr \
     -jar bibliotech.jar

package com.nexussoftware.bibliotech.diagnostico;

public class BenchmarkEnganoso {

    public static void main(String[] args) {

        long inicio = System.nanoTime();

        for (int i = 0; i < 100_000_000; i++) {
            Math.sqrt(i);                          // "medimos" sqrt
        }

        long ns = System.nanoTime() - inicio;
        System.out.printf("100 millones de sqrt en %.2f ms%n", ns / 1_000_000.0);
    }
}

100 millones de sqrt en 3,41 ms

// El JIT puede sustituir esto por  int r = 5050;
int suma = 0;
for (int i = 1; i <= 100; i++) suma += i;

public class BenchmarkMenosMalo {

    /** volatile: impide que el JIT elimine el calculo */
    private static volatile double sumidero;

    public static void main(String[] args) {
        // 1. CALENTAMIENTO
        for (int r = 0; r < 10; r++) {
            medir();
        }
        // 2. Varias repeticiones, y MEDIANA (menos sensible a picos que la media)
        long[] tiempos = new long[11];
        for (int r = 0; r < tiempos.length; r++) {
            tiempos[r] = medir();
        }
        java.util.Arrays.sort(tiempos);
        System.out.printf("Mediana: %.2f ms%n", tiempos[tiempos.length / 2] / 1_000_000.0);
    }

    private static long medir() {
        long inicio = System.nanoTime();
        double acumulado = 0;
        for (int i = 0; i < 100_000_000; i++) {
            acumulado += Math.sqrt(i);
        }
        sumidero = acumulado;        // consumir el resultado
        return System.nanoTime() - inicio;
    }
}

Mediana: 312,47 ms

package com.nexussoftware.bibliotech.benchmark;

import org.openjdk.jmh.annotations.*;
import org.openjdk.jmh.infra.Blackhole;

import java.util.*;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MICROSECONDS)
@State(Scope.Benchmark)
@Warmup(iterations = 5, time = 1)
@Measurement(iterations = 10, time = 1)
@Fork(2)
public class BenchmarkBiblioTech {

    @Param({"100", "10000", "1000000"})
    private int tamano;

    private List<Libro> catalogo;

    @Setup
    public void preparar() {
        catalogo = IntStream.range(0, tamano)
                .mapToObj(i -> new Libro(String.format("978-%010d", i),
                                         "Título " + i, "Autor " + (i % 100),
                                         200 + (i % 400), 3.0 + (i % 20) / 10.0))
                .collect(Collectors.toCollection(ArrayList::new));
    }

    @Benchmark
    public long conBucle() {
        long total = 0;
        for (Libro l : catalogo) {
            if (l.getPaginas() > 400) {
                total += l.getPaginas();
            }
        }
        return total;
    }

    @Benchmark
    public long conStream() {
        return catalogo.stream()
                .filter(l -> l.getPaginas() > 400)
                .mapToLong(Libro::getPaginas)
                .sum();
    }

    @Benchmark
    public long conStreamParalelo() {
        return catalogo.parallelStream()
                .filter(l -> l.getPaginas() > 400)
                .mapToLong(Libro::getPaginas)
                .sum();
    }

    /** Blackhole: consume el valor de forma que el JIT no pueda eliminarlo. */
    @Benchmark
    public void agrupacion(Blackhole bh) {
        bh.consume(catalogo.stream()
                .collect(Collectors.groupingBy(Libro::getAutor, Collectors.counting())));
    }
}

mvn clean package
java -jar target/benchmarks.jar BenchmarkBiblioTech -prof gc

Benchmark                        (tamano)  Mode  Cnt      Score      Error  Units
BenchmarkBiblioTech.conBucle          100  avgt   20      0,082 ±    0,003  us/op
BenchmarkBiblioTech.conBucle        10000  avgt   20      8,914 ±    0,142  us/op
BenchmarkBiblioTech.conBucle      1000000  avgt   20   1102,412 ±   28,331  us/op
BenchmarkBiblioTech.conStream         100  avgt   20      0,341 ±    0,012  us/op
BenchmarkBiblioTech.conStream       10000  avgt   20     11,208 ±    0,201  us/op
BenchmarkBiblioTech.conStream     1000000  avgt   20   1284,904 ±   31,204  us/op
BenchmarkBiblioTech.conStreamParalelo 100  avgt   20     12,041 ±    1,412  us/op
BenchmarkBiblioTech.conStreamParalelo 10000 avgt  20     28,114 ±    2,031  us/op
BenchmarkBiblioTech.conStreamParalelo 1000000 avgt 20   241,882 ±   18,442  us/op

Benchmark                        (tamano)  Mode  Cnt      Score  Units
conStream:gc.alloc.rate.norm        10000  avgt   20    128,004  B/op
conBucle:gc.alloc.rate.norm         10000  avgt   20      0,001  B/op

java -XX:+PrintCompilation -jar bibliotech.jar 2>&1 | head -20

    112    1       3       java.lang.String::hashCode (49 bytes)
    118    2       3       java.util.HashMap::hash (20 bytes)
    134    5       4       java.lang.String::equals (65 bytes)
    891   142       4       com...GestorPrestamos::prestar (218 bytes)
   1204   198       3       com...EstadisticasBiblioTech::conteoPorTipo (94 bytes)
   2841   142       4       com...GestorPrestamos::prestar (218 bytes)   made not entrant

// Tu escribes
public int paginasTotales(List<Libro> libros) {
    int total = 0;
    for (Libro l : libros) {
        total += l.getPaginas();     // llamada a un getter
    }
    return total;
}

// El JIT integra getPaginas() y genera algo equivalente a
for (Libro l : libros) {
    total += l.paginas;              // acceso directo al campo
}

public double distancia(int x1, int y1, int x2, int y2) {
    Punto a = new Punto(x1, y1);      // no escapa
    Punto b = new Punto(x2, y2);      // no escapa
    return Math.hypot(a.x() - b.x(), a.y() - b.y());
}
// El JIT puede NO CREAR los dos objetos: cero asignación en el heap

// O(n·m): para cada material, recorre TODOS los prestamos
for (Material m : materiales) {                       // n = 10.000
    for (Prestamo p : prestamos) {                    // m = 50.000
        if (p.getIsbn().equals(m.getIsbn())) { ... }
    }
}
// 500.000.000 comparaciones

// O(n+m): indexar primero
Map<String, Prestamo> porIsbn = prestamos.stream()
        .collect(Collectors.toMap(Prestamo::getIsbn, p -> p, (a, b) -> a));

for (Material m : materiales) {
    Prestamo p = porIsbn.get(m.getIsbn());            // O(1)
}
// 60.000 operaciones: 8.000 veces menos

// MAL: compila la expresion regular en CADA llamada
public boolean esIsbnValido(String isbn) {
    return isbn.matches("978-\\d{10}");     // Pattern.compile interno cada vez
}

// BIEN: compilada una sola vez
private static final Pattern ISBN = Pattern.compile("978-\\d{10}");

public boolean esIsbnValido(String isbn) {
    return ISBN.matcher(isbn).matches();
}

// MAL: consulta dentro del bucle
for (Prestamo p : prestamos) {
    Material m = catalogo.consultarEnBaseDeDatos(p.getIsbn());   // N consultas
}

// BIEN: una consulta por lotes
Map<String, Material> materiales = catalogo.consultarPorLote(
        prestamos.stream().map(Prestamo::getIsbn).distinct().toList());

public class ServiciosBiblioTech {

    // Inmutables y seguros entre hilos: UNO por aplicación (10-05, 09-06)
    private static final DateTimeFormatter ISO = DateTimeFormatter.ISO_LOCAL_DATE;
    private static final Pattern ISBN = Pattern.compile("978-\\d{10}");
    private static final HttpClient HTTP = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(5)).build();
}

// MAL: cuadratico. Cada + crea un String nuevo copiando todo
String informe = "";
for (Prestamo p : prestamos) {
    informe += p.getId() + ";" + p.getEmpleado() + "\n";
}

// BIEN: lineal
StringBuilder sb = new StringBuilder(prestamos.size() * 48);
for (Prestamo p : prestamos) {
    sb.append(p.getId()).append(';').append(p.getEmpleado()).append('\n');
}
String informe = sb.toString();

// MEJOR aún si encaja: streams (10-04)
String informe = prestamos.stream()
        .map(p -> p.getId() + ";" + p.getEmpleado())
        .collect(Collectors.joining("\n"));

// MAL: 10 millones de objetos Long
Long suma = 0L;
for (int i = 0; i < 10_000_000; i++) {
    suma += i;                          // desempaqueta, suma, EMPAQUETA
}

// BIEN: cero objetos
long suma = 0L;
for (int i = 0; i < 10_000_000; i++) {
    suma += i;
}

// Y en streams
int total = catalogo.stream().mapToInt(Libro::getPaginas).sum();   // IntStream

// Redimensiona ~14 veces al llegar a 10.000, copiando cada vez
List<Prestamo> lista = new ArrayList<>();

// Una sola reserva
List<Prestamo> lista = new ArrayList<>(10_000);

// HashMap: capacidad / factor de carga, para no rehashear
Map<String, Prestamo> mapa = new HashMap<>((int) (10_000 / 0.75f) + 1);

public class PoolDeCadenas {

    public static void main(String[] args) {

        String a = "Java Efectivo";                          // literal: al POOL
        String b = "Java Efectivo";                          // MISMO objeto del pool
        String c = new String("Java Efectivo");              // objeto NUEVO en el heap
        String d = c.intern();                               // busca en el pool

        System.out.println("a == b: " + (a == b));           // true
        System.out.println("a == c: " + (a == c));           // false
        System.out.println("a == d: " + (a == d));           // true
        System.out.println("a.equals(c): " + a.equals(c));   // true

        // Concatenacion en TIEMPO DE COMPILACION: es un literal
        String e = "Java " + "Efectivo";
        System.out.println("a == e: " + (a == e));           // true

        // Concatenacion en EJECUCION: objeto nuevo
        String parte = "Java ";
        String f = parte + "Efectivo";
        System.out.println("a == f: " + (a == f));           // false
    }
}

a == b: true
a == c: false
a == d: true
a.equals(c): true
a == e: true
a == f: false

package com.nexussoftware.bibliotech.benchmark;

import org.openjdk.jmh.annotations.*;
import java.util.concurrent.TimeUnit;

@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MICROSECONDS)
@State(Scope.Benchmark)
@Warmup(iterations = 5) @Measurement(iterations = 10) @Fork(2)
public class BenchmarkCadenas {

    @Param({"10", "100", "1000", "10000"})
    private int n;

    @Benchmark
    public String concatenacionConMas() {
        String resultado = "";
        for (int i = 0; i < n; i++) {
            resultado += "PR-2026-" + i + ";";        // CUADRATICO
        }
        return resultado;
    }

    @Benchmark
    public String conStringBuilder() {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < n; i++) {
            sb.append("PR-2026-").append(i).append(';');
        }
        return sb.toString();
    }

    @Benchmark
    public String conStringBuilderDimensionado() {
        StringBuilder sb = new StringBuilder(n * 16);   // capacidad estimada
        for (int i = 0; i < n; i++) {
            sb.append("PR-2026-").append(i).append(';');
        }
        return sb.toString();
    }
}

Benchmark                                     (n)  Mode  Cnt        Score      Error  Units
BenchmarkCadenas.concatenacionConMas           10  avgt   20        0,412 ±    0,011  us/op
BenchmarkCadenas.concatenacionConMas          100  avgt   20        8,204 ±    0,204  us/op
BenchmarkCadenas.concatenacionConMas         1000  avgt   20      512,891 ±   14,201  us/op
BenchmarkCadenas.concatenacionConMas        10000  avgt   20    48204,112 ± 1204,441  us/op
BenchmarkCadenas.conStringBuilder              10  avgt   20        0,198 ±    0,008  us/op
BenchmarkCadenas.conStringBuilder             100  avgt   20        1,412 ±    0,041  us/op
BenchmarkCadenas.conStringBuilder            1000  avgt   20       14,208 ±    0,312  us/op
BenchmarkCadenas.conStringBuilder           10000  avgt   20      148,904 ±    3,204  us/op
BenchmarkCadenas.conStringBuilderDimensionado 10000 avgt 20      104,412 ±    2,118  us/op

BenchmarkCadenas.concatenacionConMas:gc.alloc.rate.norm  10000  avgt  20  512048912,0  B/op
BenchmarkCadenas.conStringBuilder:gc.alloc.rate.norm     10000  avgt  20     524312,0  B/op

package com.nexussoftware.bibliotech.diagnostico;

import java.util.*;
import java.util.function.Consumer;

/**
 * Reproduce los cuatro patrones clasicos de fuga y sus correcciones.
 * NO es codigo de produccion: es un laboratorio didactico.
 */
public class LaboratorioDeFugas {

    // ==================================================================
    // FUGA 1: coleccion que crece sin limite
    // ==================================================================

    static class CacheConFuga {
        // static + nunca se limpia = raiz del GC que retiene todo
        private static final Map<String, byte[]> CACHE = new HashMap<>();

        static void usar(String clave) {
            CACHE.computeIfAbsent(clave, k -> new byte[10 * 1024]);   // 10 KB
        }
        static int tamano() { return CACHE.size(); }
        static void limpiar() { CACHE.clear(); }
    }

    static class CacheAcotada {
        private static final int CAPACIDAD = 500;

        private static final Map<String, byte[]> CACHE =
                new LinkedHashMap<>(CAPACIDAD, 0.75f, true) {
                    @Override
                    protected boolean removeEldestEntry(Map.Entry<String, byte[]> e) {
                        return size() > CAPACIDAD;
                    }
                };

        static void usar(String clave) {
            CACHE.computeIfAbsent(clave, k -> new byte[10 * 1024]);
        }
        static int tamano() { return CACHE.size(); }
        static void limpiar() { CACHE.clear(); }
    }

    // ==================================================================
    // FUGA 2: listeners no dados de baja
    // ==================================================================

    static class GestorDeEventos {
        private static final List<Consumer<String>> SUSCRIPTORES = new ArrayList<>();

        static void suscribir(Consumer<String> s)   { SUSCRIPTORES.add(s); }
        static void desuscribir(Consumer<String> s) { SUSCRIPTORES.remove(s); }
        static int cuantos()                        { return SUSCRIPTORES.size(); }
        static void limpiar()                       { SUSCRIPTORES.clear(); }
    }

    /** FUGA: se suscribe con una lambda que captura this y nunca se da de baja. */
    static class VentanaConFuga {
        private final byte[] datosPesados = new byte[100 * 1024];   // 100 KB

        VentanaConFuga() {
            GestorDeEventos.suscribir(evento -> procesar(evento));  // captura this
        }
        private void procesar(String e) { /* usa datosPesados */ }
    }

    /** CORRECTO: guarda la referencia y ofrece close(). */
    static class VentanaCorrecta implements AutoCloseable {
        private final byte[] datosPesados = new byte[100 * 1024];
        private final Consumer<String> suscriptor;

        VentanaCorrecta() {
            this.suscriptor = this::procesar;
            GestorDeEventos.suscribir(suscriptor);
        }
        private void procesar(String e) { }

        @Override public void close() { GestorDeEventos.desuscribir(suscriptor); }
    }

    // ==================================================================
    // FUGA 3: ThreadLocal en un pool
    // ==================================================================

    static class ContextoConFuga {
        private static final ThreadLocal<byte[]> CONTEXTO = new ThreadLocal<>();

        static void procesar() {
            CONTEXTO.set(new byte[500 * 1024]);      // 500 KB
            // sin remove(): el hilo del pool lo retiene para siempre
        }
    }

    static class ContextoCorrecto {
        private static final ThreadLocal<byte[]> CONTEXTO = new ThreadLocal<>();

        static void procesar() {
            CONTEXTO.set(new byte[500 * 1024]);
            try {
                // trabajo real
            } finally {
                CONTEXTO.remove();                    // OBLIGATORIO
            }
        }
    }

    // ==================================================================
    // FUGA 4: clase interna no estatica
    // ==================================================================

    static class CatalogoPesado {
        private final byte[] materiales = new byte[2 * 1024 * 1024];   // 2 MB

        /** NO estatica: retiene CatalogoPesado.this */
        class ContadorConFuga {
            private int cuenta;
            void incrementar() { cuenta++; }
        }

        /** static: no retiene nada de la externa */
        static class ContadorCorrecto {
            private int cuenta;
            void incrementar() { cuenta++; }
        }

        ContadorConFuga crearConFuga()          { return new ContadorConFuga(); }
        static ContadorCorrecto crearCorrecto() { return new ContadorCorrecto(); }
    }

    // ==================================================================
    // MONITOR
    // ==================================================================

    /**
     * Mide la memoria RETENIDA (tras GC), no la usada.
     *
     * Aqui System.gc() SI esta justificado: es una herramienta de
     * diagnostico, no codigo de produccion, y necesitamos saber
     * cuanta memoria sobrevive a una recoleccion.
     */
    static class MonitorDeMemoria {

        private final List<Long> muestras = new ArrayList<>();
        private final String nombre;

        MonitorDeMemoria(String nombre) { this.nombre = nombre; }

        long muestrear() {
            System.gc();
            try { Thread.sleep(120); } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            Runtime rt = Runtime.getRuntime();
            long usada = (rt.totalMemory() - rt.freeMemory()) / 1024 / 1024;
            muestras.add(usada);
            return usada;
        }

        /** Crecimiento monotono en al menos el 80 % de los tramos = fuga. */
        boolean detectaFuga() {
            if (muestras.size() < 4) {
                return false;
            }
            int crecientes = 0;
            for (int i = 1; i < muestras.size(); i++) {
                if (muestras.get(i) > muestras.get(i - 1)) {
                    crecientes++;
                }
            }
            double proporcion = (double) crecientes / (muestras.size() - 1);
            long delta = muestras.get(muestras.size() - 1) - muestras.get(0);
            return proporcion >= 0.8 && delta > 5;      // 5 MB de umbral
        }

        String veredicto() {
            long inicial = muestras.get(0);
            long finalM = muestras.get(muestras.size() - 1);
            return String.format("%-26s %4d MB -> %4d MB  (Δ %+4d MB)  %s",
                    nombre, inicial, finalM, finalM - inicial,
                    detectaFuga() ? "*** FUGA DETECTADA ***" : "estable");
        }
    }

    // ==================================================================

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

        System.out.println("Heap máximo: "
                + Runtime.getRuntime().maxMemory() / 1024 / 1024 + " MB");
        System.out.println("Ejecutar con: java -Xmx512m LaboratorioDeFugas");
        System.out.println("=".repeat(74));

        probarFuga1();
        probarFuga2();
        probarFuga3();
        probarFuga4();

        System.out.println("=".repeat(74));
        System.out.println("""

                DIAGNÓSTICO CON HERRAMIENTAS REALES
                ───────────────────────────────────
                1. Localizar el proceso:
                     jps -lvm

                2. Ver si la generación vieja crece sin bajar (columna O):
                     jstat -gcutil <PID> 1000 30

                3. Histograma de objetos vivos, dos veces separadas por minutos:
                     jcmd <PID> GC.class_histogram | head -20
                   La clase cuyo recuento crece sin parar es la sospechosa.

                4. Volcado completo para análisis:
                     jcmd <PID> GC.heap_dump /tmp/bibliotech.hprof

                5. Abrir el .hprof con Eclipse MAT:
                     - "Leak Suspects Report" da el culpable en el 80 % de los casos
                     - Ordenar por "Retained Heap": cuánta memoria libera cada objeto
                     - "Path to GC Roots" sobre el sospechoso: QUIÉN lo retiene
                       (excluyendo referencias débiles y blandas)
                """);
    }

    private static void probarFuga1() {
        System.out.println("\n--- FUGA 1: colección sin límite ---");

        var monitor = new MonitorDeMemoria("HashMap sin límite");
        monitor.muestrear();
        for (int ronda = 0; ronda < 5; ronda++) {
            for (int i = 0; i < 2_000; i++) {
                CacheConFuga.usar("isbn-" + ronda + "-" + i);
            }
            monitor.muestrear();
        }
        System.out.println(monitor.veredicto());
        System.out.println("  Entradas retenidas: " + CacheConFuga.tamano());
        CacheConFuga.limpiar();

        var monitor2 = new MonitorDeMemoria("LinkedHashMap acotado");
        monitor2.muestrear();
        for (int ronda = 0; ronda < 5; ronda++) {
            for (int i = 0; i < 2_000; i++) {
                CacheAcotada.usar("isbn-" + ronda + "-" + i);
            }
            monitor2.muestrear();
        }
        System.out.println(monitor2.veredicto());
        System.out.println("  Entradas retenidas: " + CacheAcotada.tamano() + " (tope 500)");
        CacheAcotada.limpiar();
    }

    private static void probarFuga2() {
        System.out.println("\n--- FUGA 2: listeners ---");

        var monitor = new MonitorDeMemoria("Sin desuscribir");
        monitor.muestrear();
        for (int ronda = 0; ronda < 5; ronda++) {
            for (int i = 0; i < 500; i++) {
                new VentanaConFuga();          // se crea, se descarta... y se retiene
            }
            monitor.muestrear();
        }
        System.out.println(monitor.veredicto());
        System.out.println("  Suscriptores vivos: " + GestorDeEventos.cuantos());
        GestorDeEventos.limpiar();

        var monitor2 = new MonitorDeMemoria("Con try-with-resources");
        monitor2.muestrear();
        for (int ronda = 0; ronda < 5; ronda++) {
            for (int i = 0; i < 500; i++) {
                try (var v = new VentanaCorrecta()) {
                    // uso
                }
            }
            monitor2.muestrear();
        }
        System.out.println(monitor2.veredicto());
        System.out.println("  Suscriptores vivos: " + GestorDeEventos.cuantos());
    }

    private static void probarFuga3() throws Exception {
        System.out.println("\n--- FUGA 3: ThreadLocal en pool ---");

        var pool = java.util.concurrent.Executors.newFixedThreadPool(50);

        var monitor = new MonitorDeMemoria("ThreadLocal sin remove");
        monitor.muestrear();
        for (int ronda = 0; ronda < 4; ronda++) {
            var latch = new java.util.concurrent.CountDownLatch(200);
            for (int i = 0; i < 200; i++) {
                pool.submit(() -> { ContextoConFuga.procesar(); latch.countDown(); });
            }
            latch.await();
            monitor.muestrear();
        }
        System.out.println(monitor.veredicto());
        System.out.println("  50 hilos × 500 KB retenidos ≈ 25 MB que no se liberan");

        var monitor2 = new MonitorDeMemoria("ThreadLocal con remove");
        monitor2.muestrear();
        for (int ronda = 0; ronda < 4; ronda++) {
            var latch = new java.util.concurrent.CountDownLatch(200);
            for (int i = 0; i < 200; i++) {
                pool.submit(() -> { ContextoCorrecto.procesar(); latch.countDown(); });
            }
            latch.await();
            monitor2.muestrear();
        }
        System.out.println(monitor2.veredicto());

        pool.shutdown();
    }

    private static void probarFuga4() {
        System.out.println("\n--- FUGA 4: clase interna no estática ---");

        List<Object> contadores = new ArrayList<>();

        var monitor = new MonitorDeMemoria("Clase interna NO estática");
        monitor.muestrear();
        for (int ronda = 0; ronda < 4; ronda++) {
            for (int i = 0; i < 20; i++) {
                CatalogoPesado catalogo = new CatalogoPesado();      // 2 MB
                contadores.add(catalogo.crearConFuga());            // retiene los 2 MB
            }
            monitor.muestrear();
        }
        System.out.println(monitor.veredicto());
        System.out.println("  " + contadores.size()
                + " contadores de 16 bytes reteniendo " + (contadores.size() * 2) + " MB");
        contadores.clear();

        var monitor2 = new MonitorDeMemoria("Clase interna estática");
        monitor2.muestrear();
        for (int ronda = 0; ronda < 4; ronda++) {
            for (int i = 0; i < 20; i++) {
                CatalogoPesado catalogo = new CatalogoPesado();
                contadores.add(CatalogoPesado.crearCorrecto());      // no retiene nada
            }
            monitor2.muestrear();
        }
        System.out.println(monitor2.veredicto());
        System.out.println("  " + contadores.size()
                + " contadores sin retener ningún catálogo");
    }
}

Heap máximo: 512 MB
Ejecutar con: java -Xmx512m LaboratorioDeFugas
==========================================================================

--- FUGA 1: colección sin límite ---
HashMap sin límite           12 MB ->  116 MB  (Δ +104 MB)  *** FUGA DETECTADA ***
  Entradas retenidas: 10000
LinkedHashMap acotado        14 MB ->   19 MB  (Δ   +5 MB)  estable
  Entradas retenidas: 500 (tope 500)

--- FUGA 2: listeners ---
Sin desuscribir              14 MB ->  272 MB  (Δ +258 MB)  *** FUGA DETECTADA ***
  Suscriptores vivos: 2500
Con try-with-resources       14 MB ->   15 MB  (Δ   +1 MB)  estable
  Suscriptores vivos: 0

--- FUGA 3: ThreadLocal en pool ---
ThreadLocal sin remove       15 MB ->   40 MB  (Δ  +25 MB)  *** FUGA DETECTADA ***
  50 hilos × 500 KB retenidos ≈ 25 MB que no se liberan
ThreadLocal con remove       15 MB ->   16 MB  (Δ   +1 MB)  estable

--- FUGA 4: clase interna no estática ---
Clase interna NO estática    16 MB ->  176 MB  (Δ +160 MB)  *** FUGA DETECTADA ***
  80 contadores de 16 bytes reteniendo 160 MB
Clase interna estática       17 MB ->   18 MB  (Δ   +1 MB)  estable
  80 contadores sin retener ningún catálogo

package com.nexussoftware.bibliotech.diagnostico;

import com.nexussoftware.bibliotech.dominio.Ficha;

import java.util.*;
import java.util.function.Function;

/**
 * Comparativa de tres estrategias de cache.
 *
 * ADVERTENCIA: medicion CASERA. Los tiempos son orientativos.
 * Ver el comentario final sobre JMH.
 */
public class ComparativaDeCaches {

    /** Contrato comun. */
    interface Cache {
        Ficha obtener(String isbn, Function<String, Ficha> calculo);
        int tamano();
        long aciertos();
        long fallos();
        String nombre();

        default double tasaAciertos() {
            long total = aciertos() + fallos();
            return total == 0 ? 0 : aciertos() * 100.0 / total;
        }
    }

    /** ESTRATEGIA 1: sin limite. Es la fuga del apartado 12. */
    static class CacheSinLimite implements Cache {
        private final Map<String, Ficha> mapa = new HashMap<>();
        private long aciertos, fallos;

        public Ficha obtener(String isbn, Function<String, Ficha> calculo) {
            Ficha f = mapa.get(isbn);
            if (f != null) { aciertos++; return f; }
            fallos++;
            f = calculo.apply(isbn);
            mapa.put(isbn, f);
            return f;
        }
        public int tamano()   { return mapa.size(); }
        public long aciertos() { return aciertos; }
        public long fallos()   { return fallos; }
        public String nombre() { return "HashMap sin límite"; }
    }

    /** ESTRATEGIA 2: LRU acotada. */
    static class CacheLru implements Cache {
        private final int capacidad;
        private final LinkedHashMap<String, Ficha> mapa;
        private long aciertos, fallos;

        CacheLru(int capacidad) {
            this.capacidad = capacidad;
            this.mapa = new LinkedHashMap<>(capacidad, 0.75f, true) {
                @Override protected boolean removeEldestEntry(Map.Entry<String, Ficha> e) {
                    return size() > CacheLru.this.capacidad;
                }
            };
        }
        public Ficha obtener(String isbn, Function<String, Ficha> calculo) {
            Ficha f = mapa.get(isbn);
            if (f != null) { aciertos++; return f; }
            fallos++;
            f = calculo.apply(isbn);
            mapa.put(isbn, f);
            return f;
        }
        public int tamano()   { return mapa.size(); }
        public long aciertos() { return aciertos; }
        public long fallos()   { return fallos; }
        public String nombre() { return "LRU (" + capacidad + ")"; }
    }

    /**
     * ESTRATEGIA 3: claves debiles.
     *
     * OJO: las claves son String. Si vinieran de un pool internado,
     * NO se recolectarian nunca. Aqui se construyen dinamicamente,
     * asi que si son elegibles.
     */
    static class CacheDebil implements Cache {
        private final Map<String, Ficha> mapa = new WeakHashMap<>();
        private long aciertos, fallos;

        public Ficha obtener(String isbn, Function<String, Ficha> calculo) {
            Ficha f = mapa.get(isbn);
            if (f != null) { aciertos++; return f; }
            fallos++;
            f = calculo.apply(isbn);
            mapa.put(isbn, f);
            return f;
        }
        public int tamano()   { return mapa.size(); }
        public long aciertos() { return aciertos; }
        public long fallos()   { return fallos; }
        public String nombre() { return "WeakHashMap"; }
    }

    // ------------------------------------------------------------------

    private static final int ACCESOS = 100_000;
    private static final int ISBNS_DISTINTOS = 20_000;
    private static final int CALIENTES = ISBNS_DISTINTOS / 5;   // el 20 %

    /** Calculo costoso simulado. */
    private static Ficha calcular(String isbn) {
        double acumulado = 0;
        for (int i = 1; i <= 2_000; i++) {
            acumulado += Math.sqrt(i);
        }
        return new Ficha(isbn, "Ficha " + isbn + " (" + (long) acumulado + ")", true);
    }

    /** Distribucion 80/20: el 80 % de los accesos sobre el 20 % de las claves. */
    private static List<String> generarAccesos(Random azar) {
        List<String> accesos = new ArrayList<>(ACCESOS);
        for (int i = 0; i < ACCESOS; i++) {
            int indice = azar.nextInt(100) < 80
                    ? azar.nextInt(CALIENTES)
                    : CALIENTES + azar.nextInt(ISBNS_DISTINTOS - CALIENTES);
            accesos.add(String.format("978-%010d", indice));
        }
        return accesos;
    }

    record Resultado(String nombre, double tasaAciertos, long memoriaMb,
                     long ms, int entradas, int supervivientes) { }

    private static Resultado medir(Cache cache, List<String> accesos) throws Exception {

        long memoriaAntes = memoriaRetenida();
        long inicio = System.nanoTime();

        for (String isbn : accesos) {
            cache.obtener(isbn, ComparativaDeCaches::calcular);
        }

        long ms = (System.nanoTime() - inicio) / 1_000_000;
        long memoriaDespues = memoriaRetenida();
        int entradas = cache.tamano();

        // Presion de memoria: reservar y soltar para forzar recolecciones agresivas
        try {
            List<byte[]> presion = new ArrayList<>();
            for (int i = 0; i < 200; i++) {
                presion.add(new byte[1024 * 1024]);
            }
            presion.clear();
        } catch (OutOfMemoryError e) {
            // esperado: es lo que buscamos
        }
        memoriaRetenida();
        int supervivientes = cache.tamano();

        return new Resultado(cache.nombre(), cache.tasaAciertos(),
                Math.max(0, memoriaDespues - memoriaAntes), ms, entradas, supervivientes);
    }

    private static long memoriaRetenida() throws InterruptedException {
        System.gc();
        Thread.sleep(150);
        Runtime rt = Runtime.getRuntime();
        return (rt.totalMemory() - rt.freeMemory()) / 1024 / 1024;
    }

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

        Random azar = new Random(42);                 // semilla fija: reproducible
        List<String> accesos = generarAccesos(azar);

        System.out.printf("""
                Accesos: %,d sobre %,d ISBN distintos (distribución 80/20)
                Heap máximo: %d MB
                """, ACCESOS, ISBNS_DISTINTOS,
                Runtime.getRuntime().maxMemory() / 1024 / 1024);

        List<Resultado> resultados = new ArrayList<>();
        resultados.add(medir(new CacheSinLimite(), accesos));
        resultados.add(medir(new CacheLru(CALIENTES), accesos));
        resultados.add(medir(new CacheLru(1_000), accesos));
        resultados.add(medir(new CacheDebil(), accesos));

        System.out.printf("%n%-22s %9s %9s %8s %10s %14s%n",
                "ESTRATEGIA", "ACIERTOS", "MEMORIA", "TIEMPO", "ENTRADAS", "TRAS PRESIÓN");
        System.out.println("-".repeat(78));

        resultados.forEach(r -> System.out.printf("%-22s %8.1f%% %7d MB %6d ms %10d %14d%n",
                r.nombre(), r.tasaAciertos(), r.memoriaMb(), r.ms(),
                r.entradas(), r.supervivientes()));

        System.out.println("""

                RECOMENDACIÓN
                ─────────────
                • HashMap sin límite: la mayor tasa de aciertos y la peor decisión.
                  Retiene TODAS las entradas indefinidamente: es la fuga 1 del
                  apartado 12. Solo aceptable si el número de claves está acotado
                  por diseño (un enum, una lista fija de configuración).

                • LRU dimensionada al conjunto caliente: la mejor relación.
                  Con una distribución 80/20, una LRU del tamaño del 20 % caliente
                  captura casi todos los aciertos con una fracción de la memoria.
                  ES LA ELECCIÓN POR DEFECTO.

                • LRU infradimensionada: la tasa de aciertos se hunde porque las
                  entradas calientes se expulsan entre sí (thrashing). Dimensionar
                  una caché por debajo del conjunto de trabajo es peor que no tenerla.

                • WeakHashMap: memoria autorregulada, pero comportamiento
                  IMPREDECIBLE: las entradas desaparecen cuando el GC decide.
                  Su caso real no es "caché acotada" sino "metadatos asociados a
                  objetos vivos que no controlo" (apartado 14).

                SOBRE ESTA MEDICIÓN
                ───────────────────
                Es CASERA y sus números son orientativos:
                  - No hay calentamiento suficiente: las primeras estrategias
                    medidas pagan la compilación JIT de calcular().
                  - System.gc() es una sugerencia: la memoria "retenida" es
                    aproximada.
                  - No hay repeticiones ni intervalos de confianza.
                  - El orden de ejecución influye (la primera caché deja el
                    heap en un estado distinto para la siguiente).

                Para medir en serio: JMH con @State(Scope.Benchmark),
                @Setup(Level.Iteration) recreando la caché, @Fork(3) para aislar
                procesos y -prof gc para la asignación normalizada por operación.
                """);
    }
}

Accesos: 100.000 sobre 20.000 ISBN distintos (distribución 80/20)
Heap máximo: 512 MB

ESTRATEGIA              ACIERTOS   MEMORIA   TIEMPO   ENTRADAS   TRAS PRESIÓN
------------------------------------------------------------------------------
HashMap sin límite         80,0%      12 MB    412 ms      20000          20000
LRU (4000)                 79,4%       3 MB    438 ms       4000           4000
LRU (1000)                 61,2%       1 MB    891 ms       1000           1000
WeakHashMap                79,8%       9 MB    467 ms      19884              0

RECOMENDACIÓN
─────────────
• HashMap sin límite: la mayor tasa de aciertos y la peor decisión.
  ...

package com.nexussoftware.bibliotech.diagnostico;

import java.lang.management.*;
import java.time.Duration;
import java.util.*;
import java.util.stream.Collectors;

/**
 * Autodiagnostico de rendimiento de BiblioTech.
 * Usa unicamente la API de gestion del JDK: sin dependencias externas.
 */
public class InformeDeRendimiento {

    // --- Secciones del informe como tipo sellado (10-06) ---

    public sealed interface Seccion {

        record Memoria(long heapUsadoMb, long heapMaxMb, long heapComprometidoMb,
                       long noHeapUsadoMb, List<Pool> pools) implements Seccion { }

        record Pool(String nombre, String tipo, long usadoMb, long maxMb) { }

        record Recoleccion(List<EstadisticaGc> recolectores, long tiempoTotalMs,
                           long tiempoDeVidaMs) implements Seccion { }

        record EstadisticaGc(String nombre, long recolecciones, long tiempoMs) { }

        record Hilos(int vivos, int demonios, int pico, long totalCreados,
                     List<String> interbloqueos) implements Seccion { }

        record Clases(long cargadas, long totalCargadas, long descargadas) implements Seccion { }

        record Compilacion(String compilador, long tiempoMs) implements Seccion { }
    }

    public enum Salud { VERDE, AMBAR, ROJO }

    // ------------------------------------------------------------------

    public Seccion.Memoria recogerMemoria() {
        MemoryMXBean memoria = ManagementFactory.getMemoryMXBean();
        MemoryUsage heap = memoria.getHeapMemoryUsage();
        MemoryUsage noHeap = memoria.getNonHeapMemoryUsage();

        List<Seccion.Pool> pools = ManagementFactory.getMemoryPoolMXBeans().stream()
                .map(p -> new Seccion.Pool(
                        p.getName(),
                        p.getType().toString(),
                        p.getUsage().getUsed() / 1024 / 1024,
                        p.getUsage().getMax() < 0 ? -1 : p.getUsage().getMax() / 1024 / 1024))
                .toList();

        return new Seccion.Memoria(
                heap.getUsed() / 1024 / 1024,
                heap.getMax() / 1024 / 1024,
                heap.getCommitted() / 1024 / 1024,
                noHeap.getUsed() / 1024 / 1024,
                pools);
    }

    public Seccion.Recoleccion recogerGc() {
        List<Seccion.EstadisticaGc> recolectores =
                ManagementFactory.getGarbageCollectorMXBeans().stream()
                        .map(gc -> new Seccion.EstadisticaGc(
                                gc.getName(), gc.getCollectionCount(), gc.getCollectionTime()))
                        .toList();

        long total = recolectores.stream()
                .mapToLong(Seccion.EstadisticaGc::tiempoMs).sum();

        return new Seccion.Recoleccion(recolectores, total,
                ManagementFactory.getRuntimeMXBean().getUptime());
    }

    public Seccion.Hilos recogerHilos() {
        ThreadMXBean hilos = ManagementFactory.getThreadMXBean();

        List<String> interbloqueos = new ArrayList<>();
        long[] bloqueados = hilos.findDeadlockedThreads();
        if (bloqueados != null) {
            for (ThreadInfo info : hilos.getThreadInfo(bloqueados, true, true)) {
                interbloqueos.add(String.format("%s (id %d) bloqueado en %s, retenido por %s",
                        info.getThreadName(), info.getThreadId(),
                        info.getLockName(), info.getLockOwnerName()));
            }
        }

        return new Seccion.Hilos(
                hilos.getThreadCount(), hilos.getDaemonThreadCount(),
                hilos.getPeakThreadCount(), hilos.getTotalStartedThreadCount(),
                interbloqueos);
    }

    public Seccion.Clases recogerClases() {
        ClassLoadingMXBean clases = ManagementFactory.getClassLoadingMXBean();
        return new Seccion.Clases(clases.getLoadedClassCount(),
                clases.getTotalLoadedClassCount(), clases.getUnloadedClassCount());
    }

    public Seccion.Compilacion recogerCompilacion() {
        CompilationMXBean jit = ManagementFactory.getCompilationMXBean();
        if (jit == null) {
            return new Seccion.Compilacion("(no disponible)", 0);
        }
        return new Seccion.Compilacion(jit.getName(),
                jit.isCompilationTimeMonitoringSupported() ? jit.getTotalCompilationTime() : -1);
    }

    // ------------------------------------------------------------------

    /** Semaforo de salud con reglas justificadas, mediante switch exhaustivo. */
    public Salud evaluar(Seccion seccion) {
        return switch (seccion) {

            // Regla: por encima del 90 % del heap tras GC, riesgo real de OOM
            case Seccion.Memoria(var usado, var max, var comprometido, var noHeap, var pools) -> {
                double uso = max <= 0 ? 0 : usado * 100.0 / max;
                yield uso > 90 ? Salud.ROJO : uso > 75 ? Salud.AMBAR : Salud.VERDE;
            }

            // Regla: mas del 10 % del tiempo de vida en GC indica problema serio
            case Seccion.Recoleccion(var recolectores, var totalMs, var vidaMs) -> {
                double porcentaje = vidaMs == 0 ? 0 : totalMs * 100.0 / vidaMs;
                yield porcentaje > 10 ? Salud.ROJO : porcentaje > 5 ? Salud.AMBAR : Salud.VERDE;
            }

            // Regla: un interbloqueo es SIEMPRE rojo
            case Seccion.Hilos(var vivos, var demonios, var pico, var creados, var bloqueos) -> {
                if (!bloqueos.isEmpty()) yield Salud.ROJO;
                yield vivos > 1_000 ? Salud.AMBAR : Salud.VERDE;
            }

            // Regla: muchas clases cargadas y ninguna descargada sugiere fuga de metaspace
            case Seccion.Clases(var cargadas, var total, var descargadas) ->
                    cargadas > 50_000 ? Salud.AMBAR : Salud.VERDE;

            // El tiempo de JIT alto solo es informativo
            case Seccion.Compilacion c -> Salud.VERDE;
        };
    }

    private String icono(Salud s) {
        return switch (s) {
            case VERDE -> "[ OK ]";
            case AMBAR -> "[AVISO]";
            case ROJO  -> "[ MAL ]";
        };
    }

    // ------------------------------------------------------------------

    public String generar() {
        var memoria = recogerMemoria();
        var gc = recogerGc();
        var hilos = recogerHilos();
        var clases = recogerClases();
        var jit = recogerCompilacion();

        RuntimeMXBean runtime = ManagementFactory.getRuntimeMXBean();
        OperatingSystemMXBean so = ManagementFactory.getOperatingSystemMXBean();

        StringBuilder sb = new StringBuilder();

        sb.append("""
                ══════════════════════════════════════════════════════════
                  INFORME DE RENDIMIENTO -- BiblioTech
                ══════════════════════════════════════════════════════════
                  JVM:        %s %s
                  Proveedor:  %s
                  Sistema:    %s %s (%d procesadores)
                  En marcha:  %s
                  PID:        %d
                """.formatted(
                        runtime.getVmName(), runtime.getVmVersion(), runtime.getVmVendor(),
                        so.getName(), so.getArch(), so.getAvailableProcessors(),
                        formatearDuracion(runtime.getUptime()),
                        ProcessHandle.current().pid()));

        // --- MEMORIA ---
        sb.append("\n%s MEMORIA%n".formatted(icono(evaluar(memoria))));
        sb.append("  Heap:     %,d MB usados / %,d MB comprometidos / %,d MB máximo (%.1f %%)%n"
                .formatted(memoria.heapUsadoMb(), memoria.heapComprometidoMb(),
                           memoria.heapMaxMb(),
                           memoria.heapMaxMb() <= 0 ? 0
                                   : memoria.heapUsadoMb() * 100.0 / memoria.heapMaxMb()));
        sb.append("  No-heap:  %,d MB (metaspace, caché de código)%n"
                .formatted(memoria.noHeapUsadoMb()));
        sb.append("  Regiones:%n");
        memoria.pools().forEach(p -> sb.append("    %-28s %6d MB%s%n".formatted(
                p.nombre(), p.usadoMb(), p.maxMb() < 0 ? "" : " / " + p.maxMb() + " MB")));

        // --- GC ---
        double porcentajeGc = gc.tiempoDeVidaMs() == 0 ? 0
                : gc.tiempoTotalMs() * 100.0 / gc.tiempoDeVidaMs();
        sb.append("\n%s RECOLECCIÓN DE BASURA%n".formatted(icono(evaluar(gc))));
        gc.recolectores().forEach(r -> sb.append(
                "  %-28s %,8d recolecciones  %,8d ms  (media %.1f ms)%n".formatted(
                        r.nombre(), r.recolecciones(), r.tiempoMs(),
                        r.recolecciones() == 0 ? 0.0 : (double) r.tiempoMs() / r.recolecciones())));
        sb.append("  Total en GC: %,d ms de %,d ms de vida (%.2f %%)%n"
                .formatted(gc.tiempoTotalMs(), gc.tiempoDeVidaMs(), porcentajeGc));

        // --- HILOS ---
        sb.append("\n%s HILOS%n".formatted(icono(evaluar(hilos))));
        sb.append("  Vivos: %d (%d demonios)   Pico: %d   Creados en total: %,d%n"
                .formatted(hilos.vivos(), hilos.demonios(), hilos.pico(), hilos.totalCreados()));
        if (hilos.interbloqueos().isEmpty()) {
            sb.append("  Sin interbloqueos detectados%n".formatted());
        } else {
            sb.append("  *** INTERBLOQUEO DETECTADO ***%n".formatted());
            hilos.interbloqueos().forEach(i -> sb.append("    ").append(i).append('\n'));
        }

        // --- CLASES Y JIT ---
        sb.append("\n%s CLASES%n".formatted(icono(evaluar(clases))));
        sb.append("  Cargadas ahora: %,d   Total histórico: %,d   Descargadas: %,d%n"
                .formatted(clases.cargadas(), clases.totalCargadas(), clases.descargadas()));

        sb.append("\n%s COMPILACIÓN JIT%n".formatted(icono(evaluar(jit))));
        sb.append("  Compilador: %s   Tiempo total: %,d ms%n"
                .formatted(jit.compilador(), jit.tiempoMs()));

        // --- OPCIONES ---
        sb.append("\n  OPCIONES DE LA JVM%n".formatted());
        runtime.getInputArguments().forEach(a -> sb.append("    ").append(a).append('\n'));

        sb.append("""

                ──────────────────────────────────────────────────────────
                  SIGUIENTE PASO SI ALGO ESTÁ EN AVISO O EN MAL
                    jstat -gcutil %d 1000 30       (¿crece la columna O?)
                    jcmd %d GC.class_histogram     (¿qué clase crece?)
                    jcmd %d Thread.print           (interbloqueos y pilas)
                    jcmd %d JFR.start settings=profile duration=120s \\
                         filename=/tmp/bibliotech.jfr
                ══════════════════════════════════════════════════════════
                """.formatted(ProcessHandle.current().pid(), ProcessHandle.current().pid(),
                              ProcessHandle.current().pid(), ProcessHandle.current().pid()));

        return sb.toString();
    }

    private String formatearDuracion(long ms) {
        Duration d = Duration.ofMillis(ms);
        return "%dd %02dh %02dm %02ds".formatted(
                d.toDays(), d.toHoursPart(), d.toMinutesPart(), d.toSecondsPart());
    }

    /** Arranca una grabacion JFR sobre este mismo proceso. */
    public void grabarJfr(String fichero, int segundos) throws Exception {
        long pid = ProcessHandle.current().pid();
        var proceso = new ProcessBuilder("jcmd", String.valueOf(pid),
                "JFR.start", "name=bibliotech", "settings=profile",
                "duration=" + segundos + "s", "filename=" + fichero)
                .inheritIO().start();
        proceso.waitFor();
        System.out.println("Grabación JFR iniciada: " + fichero);
    }

    public static void main(String[] args) throws Exception {
        InformeDeRendimiento informe = new InformeDeRendimiento();

        // Generar algo de carga para que las cifras no sean todas cero
        List<byte[]> basura = new ArrayList<>();
        for (int i = 0; i < 500; i++) {
            basura.add(new byte[512 * 1024]);
            if (i % 50 == 0) basura.clear();
        }
        basura.clear();

        System.out.println(informe.generar());
    }
}

══════════════════════════════════════════════════════════
  INFORME DE RENDIMIENTO -- BiblioTech
══════════════════════════════════════════════════════════
  JVM:        OpenJDK 64-Bit Server VM 21.0.1+12
  Proveedor:  Eclipse Adoptium
  Sistema:    Linux amd64 (8 procesadores)
  En marcha:  0d 00h 00m 02s
  PID:        18492

[ OK ] MEMORIA
  Heap:     41 MB usados / 258 MB comprometidos / 4.096 MB máximo (1,0 %)
  No-heap:  22 MB (metaspace, caché de código)
  Regiones:
    CodeHeap 'non-nmethods'             1 MB / 5 MB
    Metaspace                          14 MB
    CodeHeap 'profiled nmethods'        3 MB / 117 MB
    Compressed Class Space              1 MB / 1024 MB
    G1 Eden Space                      28 MB
    G1 Old Gen                         12 MB / 4096 MB
    G1 Survivor Space                   1 MB
    CodeHeap 'non-profiled nmethods'    1 MB / 117 MB

[ OK ] RECOLECCIÓN DE BASURA
  G1 Young Generation             12 recolecciones        41 ms  (media 3,4 ms)
  G1 Old Generation                0 recolecciones         0 ms  (media 0,0 ms)
  Total en GC: 41 ms de 2.104 ms de vida (1,95 %)

[ OK ] HILOS
  Vivos: 11 (9 demonios)   Pico: 11   Creados en total: 12
  Sin interbloqueos detectados

[ OK ] CLASES
  Cargadas ahora: 1.284   Total histórico: 1.284   Descargadas: 0

[ OK ] COMPILACIÓN JIT
  Compilador: HotSpot 64-Bit Tiered Compilers   Tiempo total: 412 ms

  OPCIONES DE LA JVM
    -Xms256m
    -Xmx4g
    -XX:+UseG1GC

──────────────────────────────────────────────────────────
  SIGUIENTE PASO SI ALGO ESTÁ EN AVISO O EN MAL
    jstat -gcutil 18492 1000 30       (¿crece la columna O?)
    jcmd 18492 GC.class_histogram     (¿qué clase crece?)
    jcmd 18492 Thread.print           (interbloqueos y pilas)
    jcmd 18492 JFR.start settings=profile duration=120s \
         filename=/tmp/bibliotech.jfr
══════════════════════════════════════════════════════════