public void exemple() {
    int comptador = 42;                             // el VALOR es a la pila
    Llibre llibre = new Llibre("978-0000000001", "Java Eficac");
    //   ^ la REFERENCIA es a la pila          ^ l OBJECTE es al heap
}

public class MemoriaDisponible {

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

        System.out.printf("Maxima  (-Xmx):  %,d MB%n", rt.maxMemory()   / 1024 / 1024);
        System.out.printf("Total reservada: %,d MB%n", rt.totalMemory() / 1024 / 1024);
        System.out.printf("Lliure en total: %,d MB%n", rt.freeMemory()  / 1024 / 1024);
        System.out.printf("En us:           %,d MB%n",
                (rt.totalMemory() - rt.freeMemory()) / 1024 / 1024);
        System.out.printf("Processadors:    %d%n", rt.availableProcessors());
    }
}

Maxima  (-Xmx):  4.096 MB
Total reservada: 258 MB
Lliure en total: 196 MB
En us:           62 MB
Processadors:    8

public class Marcs {

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

    static void primer(int x) {                 // marc 2
        String text = "BiblioTech";
        segon(x * 2, text);
    }

    static void segon(int y, String t) {        // marc 3
        System.out.println(y + " " + t);
    }                                            // el marc 3 es descarta
}

public class DesbordamentDePila {

    private static int profunditat = 0;

    static void recursioInfinita() {
        profunditat++;
        recursioInfinita();                     // sense cas base
    }

    public static void main(String[] args) {
        try {
            recursioInfinita();
        } catch (StackOverflowError e) {
            System.out.println("StackOverflowError als " + profunditat + " marcs");
        }
    }
}

StackOverflowError als 21847 marcs

java -Xss1m ElMeuPrograma      # 1 MB per fil (tipic per defecte a 64 bits)
java -Xss16m ElMeuPrograma     # per a recursio profunda legitima
java -Xss256k ElMeuPrograma    # per tenir MOLTS fils

Llibre llibre = new Llibre("978-0000000001", "Java Eficac", "Joshua Bloch", 412, 4.85);

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

bool UseCompressedOops = true    {lp64_product} {default}

java -XX:MaxMetaspaceSize=256m ElMeuPrograma

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

java -XX:ReservedCodeCacheSize=512m ElMeuPrograma

// Buffer DIRECTE: la memoria NO es al heap
ByteBuffer directe = ByteBuffer.allocateDirect(64 * 1024 * 1024);   // 64 MB natius

// Buffer normal: SI que es al heap
ByteBuffer alHeap = ByteBuffer.allocate(64 * 1024 * 1024);

java -XX:MaxDirectMemorySize=512m ElMeuPrograma

Memoria total ≈ Heap (-Xmx)
              + Metaspace
              + Memoria cau de codi
              + (Nombre de fils × -Xss)
              + Buffers directes
              + Estructures internes de la JVM (~100-300 MB)

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

package com.nexussoftware.bibliotech.diagnostic;

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

public class ProvocarOutOfMemory {

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

        List<byte[]> retinguts = new ArrayList<>();
        int blocs = 0;

        try {
            while (true) {
                retinguts.add(new byte[1024 * 1024]);      // 1 MB cada vegada
                blocs++;
            }
        } catch (OutOfMemoryError e) {
            // Capturar OOM nomes per DIAGNOSTICAR i sortir. Mai per continuar.
            System.err.println("OutOfMemoryError despres de " + blocs + " MB");
            System.err.println("Missatge: " + e.getMessage());
            retinguts.clear();                              // alliberar per poder imprimir
            System.exit(1);
        }
    }
}

OutOfMemoryError despres de 61 MB
Missatge: 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 ProvaDAssignacio

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.servei;

import java.util.*;

/**
 * FUITA: la memoria cau creix indefinidament.
 */
public class CacheAmbFuita {

    // static: es una ARREL DEL GC. Tot el que pengi d aqui viu
    // mentre visqui la classe, es a dir, per sempre.
    private static final Map<String, Fitxa> CACHE = new HashMap<>();

    public Fitxa obtenir(String isbn) {
        return CACHE.computeIfAbsent(isbn, this::calcularFitxa);
    }
    // Mai no s elimina res. Amb un milio d ISBN diferents,
    // un milio de fitxes retingudes per sempre.
}

/** CORRECTE: memoria cau ACOTADA amb expulsio LRU (10-01). */
public class CacheAcotada {

    private static final int CAPACITAT = 10_000;

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

    public Fitxa obtenir(String isbn) {
        return cache.computeIfAbsent(isbn, this::calcularFitxa);
    }
}

package com.nexussoftware.bibliotech.presentacio;

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

public class GestorEsdeveniments {

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

    public static void subscriure(Consumer<String> subscriptor) {
        SUBSCRIPTORS.add(subscriptor);
    }

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

/** FUITA: se subscriu i mai no es dona de baixa. */
public class FinestraPrestecs {

    private final List<Prestec> prestecs = new ArrayList<>(10_000);   // objecte pesat

    public FinestraPrestecs() {
        // La LAMBDA captura 'this' implicitament en fer servir un camp.
        // GestorEsdeveniments.SUBSCRIPTORS (static) rete la lambda,
        // la lambda rete aquesta FinestraPrestecs,
        // i aquesta finestra rete els seus 10.000 prestecs. PER SEMPRE.
        GestorEsdeveniments.subscriure(esdeveniment -> actualitzar(esdeveniment));
    }

    private void actualitzar(String esdeveniment) { /* fa servir prestecs */ }

    public void tancar() {
        // No hi ha manera de donar se de baixa: no guardem la referencia
    }
}

/** CORRECTE: guardar la referencia i donar se de baixa. */
public class FinestraPrestecsCorrecta implements AutoCloseable {

    private final List<Prestec> prestecs = new ArrayList<>(10_000);
    private final Consumer<String> subscriptor;

    public FinestraPrestecsCorrecta() {
        this.subscriptor = this::actualitzar;      // guardem la referencia
        GestorEsdeveniments.subscriure(subscriptor);
    }

    private void actualitzar(String esdeveniment) { }

    @Override
    public void close() {
        GestorEsdeveniments.dessubscriure(subscriptor);  // simetria: subscriure/dessubscriure
    }
}

package com.nexussoftware.bibliotech.servei;

/**
 * FUITA: el fil del pool NO mor, aixi que el seu ThreadLocal tampoc.
 */
public class ContextAmbFuita {

    private static final ThreadLocal<ContextPeticio> CONTEXT = new ThreadLocal<>();

    public static void processar(String empleat, Runnable tasca) {
        CONTEXT.set(new ContextPeticio(empleat));         // es guarda...
        tasca.run();
        // ...i MAI no es neteja.
    }
}

/** CORRECTE: neteja garantida amb finally. */
public class ContextCorrecte {

    private static final ThreadLocal<ContextPeticio> CONTEXT = new ThreadLocal<>();

    public static void processar(String empleat, Runnable tasca) {
        CONTEXT.set(new ContextPeticio(empleat));
        try {
            tasca.run();
        } finally {
            CONTEXT.remove();           // OBLIGATORI, i en finally
        }
    }
}

package com.nexussoftware.bibliotech.servei;

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

public class CatalegPesat {

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

    /**
     * NO estatica: rete implicitament CatalegPesat.
     */
    public class ComptadorSimple {
        private int compte;
        public void incrementar() { compte++; }
        public int getCompte()    { return compte; }
        // No fa servir 'materials' per a res, i tanmateix el rete
    }

    public ComptadorSimple crearComptador() {
        return new ComptadorSimple();
    }
}

// Es crea el cataleg de 50 MB, se n treu un comptador de 16 bytes
// i es descarta el cataleg... pero el comptador el rete.
ComptadorSimple comptador;
{
    CatalegPesat cataleg = new CatalegPesat();
    comptador = cataleg.crearComptador();
}
// 'cataleg' ja no es abastable... EXCEPTE a traves de comptador.this$0
// Els 50 MB continuen alla.

/** CORRECTE: static, sense referencia a l externa. */
public static class ComptadorSimple {
    private int compte;
    public void incrementar() { compte++; }
    public int getCompte()    { return compte; }
}

package com.nexussoftware.bibliotech.diagnostic;

import java.lang.ref.*;

public class ForcesDeReferencia {

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

        // --- FORTA: el GC no la toca ---
        Llibre forta = new Llibre("978-0000000001", "Java Eficac");
        System.gc();
        Thread.sleep(100);
        System.out.println("Forta despres del GC:  " + (forta != null));      // true

        // --- FEBLE: desapareix al seguent GC ---
        WeakReference<Llibre> feble = new WeakReference<>(
                new Llibre("978-0000000002", "Patrons de Disseny"));
        System.out.println("Feble abans:           " + (feble.get() != null)); // true
        System.gc();
        Thread.sleep(100);
        System.out.println("Feble despres del GC:  " + (feble.get() != null)); // false

        // --- TOVA: sobreviu mentre hi hagi memoria ---
        SoftReference<Llibre> tova = new SoftReference<>(
                new Llibre("978-0000000003", "Refactoritzacio"));
        System.gc();
        Thread.sleep(100);
        System.out.println("Tova despres del GC:   " + (tova.get() != null));  // true

        // --- FANTASMA: get() SEMPRE retorna null ---
        ReferenceQueue<Llibre> cua = new ReferenceQueue<>();
        PhantomReference<Llibre> fantasma = new PhantomReference<>(
                new Llibre("978-0000000004", "Codi Net"), cua);
        System.out.println("Fantasma.get():        " + fantasma.get());        // sempre null

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

Forta despres del GC:  true
Feble abans:           true
Feble despres del GC:  false
Tova despres del GC:   true
Fantasma.get():        null
Notificada?            true

package com.nexussoftware.bibliotech.diagnostic;

import java.util.*;

public class ComparacioDeMapes {

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

        Map<Llibre, String> normal = new HashMap<>();
        Map<Llibre, String> feble = new WeakHashMap<>();

        Llibre retingut = new Llibre("978-0000000001", "Java Eficac");
        Llibre temporal = new Llibre("978-0000000002", "Patrons de Disseny");

        normal.put(retingut, "prestatge A-1");
        normal.put(temporal, "prestatge A-2");
        feble.put(retingut, "prestatge A-1");
        feble.put(temporal, "prestatge A-2");

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

        temporal = null;          // es perd l ultima referencia FORTA
        System.gc();
        Thread.sleep(200);

        System.out.println("Despres -> HashMap: " + normal.size()
                         + ", WeakHashMap: " + feble.size());
    }
}

Abans -> HashMap: 2, WeakHashMap: 2
Despres -> HashMap: 2, WeakHashMap: 1

package com.nexussoftware.bibliotech.servei;

import com.nexussoftware.bibliotech.domini.*;

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

/**
 * Memoria cau de fitxes de BiblioTech amb dos nivells.
 *
 * Nivell 1 (WeakHashMap): fitxes associades a materials VIUS.
 *   Si el material desapareix del cataleg, la seva fitxa s allibera sola.
 *
 * Nivell 2 (LinkedHashMap LRU): fitxes per ISBN, acotada.
 *   Sobreviu a la desaparicio del material, pero amb sostre.
 */
public class CacheFitxes {

    private static final int CAPACITAT_LRU = 5_000;

    /**
     * Clau: l objecte Material. Referencia FEBLE.
     * Si ningu mes no referencia el material, l entrada se n va sola.
     */
    private final Map<Material, Fitxa> perMaterial =
            Collections.synchronizedMap(new WeakHashMap<>());

    /**
     * Clau: l ISBN (un String, referencia forta).
     * Aqui SI que cal politica d expulsio explicita.
     */
    private final Map<String, Fitxa> perIsbn =
            Collections.synchronizedMap(new LinkedHashMap<>(CAPACITAT_LRU, 0.75f, true) {
                @Override
                protected boolean removeEldestEntry(Map.Entry<String, Fitxa> mesAntiga) {
                    return size() > CAPACITAT_LRU;
                }
            });

    private long encertsFebles = 0;
    private long encertsLru = 0;
    private long fallades = 0;

    public Fitxa obtenir(Material material) {
        Fitxa perObjecte = perMaterial.get(material);
        if (perObjecte != null) {
            encertsFebles++;
            return perObjecte;
        }

        Fitxa perClau = perIsbn.get(material.getIsbn());
        if (perClau != null) {
            encertsLru++;
            perMaterial.put(material, perClau);       // repoblar el nivell 1
            return perClau;
        }

        fallades++;
        Fitxa nova = calcular(material);
        perMaterial.put(material, nova);
        perIsbn.put(material.getIsbn(), nova);
        return nova;
    }

    private Fitxa calcular(Material material) {
        // Calcul costos: consultes, agregats, format
        return new Fitxa(material.getIsbn(), material.getTitol(), true);
    }

    public String estadistiques() {
        long total = encertsFebles + encertsLru + fallades;
        return """
                CacheFitxes
                  Nivell 1 (WeakHashMap): %d entrades vives, %d encerts
                  Nivell 2 (LRU %d):      %d entrades, %d encerts
                  Fallades:               %d
                  Taxa d encert:          %.1f %%"""
                .formatted(perMaterial.size(), encertsFebles,
                           CAPACITAT_LRU, perIsbn.size(), encertsLru,
                           fallades, total == 0 ? 0.0
                                   : (encertsFebles + encertsLru) * 100.0 / total);
    }
}

// FUITA: el valor apunta a la clau, que aixi mai no queda inabastable
WeakHashMap<Llibre, Prestec> mapa = new WeakHashMap<>();
mapa.put(llibre, new Prestec(..., llibre));     // Prestec guarda el Llibre

// NO FACIS AIXO MAI
@Override
protected void finalize() throws Throwable {
    if (fitxer != null) {
        fitxer.close();
    }
}

package com.nexussoftware.bibliotech.persistencia;

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

/**
 * Recurs amb tancament determinista (AutoCloseable) MES una xarxa
 * de seguretat amb Cleaner per si algu s oblida de tancar lo.
 */
public class MagatzemPrestecs implements AutoCloseable {

    /** UN per aplicacio: crea un fil. */
    private static final Cleaner NETEJADOR = Cleaner.create();

    /**
     * ESTATICA i sense referencia a l objecte extern.
     * Si tingues una referencia a MagatzemPrestecs, aquest mai no
     * seria inabastable i el Cleaner NO s activaria MAI.
     * Es la fuita 4 de l apartat 12, aplicada aqui.
     */
    private static class EstatANetejar implements Runnable {

        private final FileChannel canal;
        private final Path cami;

        EstatANetejar(FileChannel canal, Path cami) {
            this.canal = canal;
            this.cami = cami;
        }

        @Override
        public void run() {
            try {
                if (canal.isOpen()) {
                    System.err.println("AVIS: MagatzemPrestecs(" + cami
                            + ") no s ha tancat; el tanca el Cleaner");
                    canal.close();
                }
            } catch (Exception e) {
                // El Cleaner s empassa les excepcions: no hi ha a qui propagar les
            }
        }
    }

    private final EstatANetejar estat;
    private final Cleaner.Cleanable neteja;

    public MagatzemPrestecs(Path cami) throws java.io.IOException {
        FileChannel canal = FileChannel.open(cami,
                StandardOpenOption.CREATE, StandardOpenOption.WRITE);
        this.estat = new EstatANetejar(canal, cami);
        this.neteja = NETEJADOR.register(this, estat);
    }

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

    @Override
    public void close() {
        neteja.clean();        // tancament DETERMINISTA i idempotent
    }
}

// US NORMAL: try-with-resources, tancament garantit i determinista
try (var magatzem = new MagatzemPrestecs(Path.of("prestecs.dat"))) {
    magatzem.guardar("PR-2026-0041;978-0000000001;Marta Ruiz");
}

millora = 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

# Estadistiques de GC cada segon, 10 vegades
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 d objectes vius, ordenat per mida
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.domini.Prestec
   4:        198432        9524736  java.util.HashMap$Node
   5:        412008        6592128  java.time.LocalDate
   6:         98211        4713-28  java.util.ArrayList

# Bolcat COMPLET del heap per analitzar amb eines grafiques
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              # bolcat de fils: interbloqueigs (08-04)
jcmd 14237 VM.flags                  # opcions efectives de la JVM
jcmd 14237 GC.class_histogram
jcmd 14237 VM.native_memory summary  # requereix -XX:NativeMemoryTracking=summary

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

jconsole 14237

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

# Sobre un proces en marxa
jcmd 14237 JFR.start name=diagnostic settings=profile duration=120s \
     filename=/tmp/bibliotech.jfr

jcmd 14237 JFR.check
jcmd 14237 JFR.dump name=diagnostic filename=/tmp/instantania.jfr
jcmd 14237 JFR.stop name=diagnostic

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

# Esdeveniments concrets
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.diagnostic;

public class BenchmarkEnganyos {

    public static void main(String[] args) {

        long inici = System.nanoTime();

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

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

100 milions de sqrt en 3,41 ms

// El JIT pot substituir aixo per  int r = 5050;
int suma = 0;
for (int i = 1; i <= 100; i++) suma += i;

public class BenchmarkMenysDolent {

    /** volatile: impedeix que el JIT elimini el calcul */
    private static volatile double embornal;

    public static void main(String[] args) {
        // 1. ESCALFAMENT
        for (int r = 0; r < 10; r++) {
            mesurar();
        }
        // 2. Diverses repeticions, i MEDIANA (menys sensible a pics que la mitjana)
        long[] temps = new long[11];
        for (int r = 0; r < temps.length; r++) {
            temps[r] = mesurar();
        }
        java.util.Arrays.sort(temps);
        System.out.printf("Mediana: %.2f ms%n", temps[temps.length / 2] / 1_000_000.0);
    }

    private static long mesurar() {
        long inici = System.nanoTime();
        double acumulat = 0;
        for (int i = 0; i < 100_000_000; i++) {
            acumulat += Math.sqrt(i);
        }
        embornal = acumulat;         // consumir el resultat
        return System.nanoTime() - inici;
    }
}

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 mida;

    private List<Llibre> cataleg;

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

    @Benchmark
    public long ambBucle() {
        long total = 0;
        for (Llibre l : cataleg) {
            if (l.getPagines() > 400) {
                total += l.getPagines();
            }
        }
        return total;
    }

    @Benchmark
    public long ambStream() {
        return cataleg.stream()
                .filter(l -> l.getPagines() > 400)
                .mapToLong(Llibre::getPagines)
                .sum();
    }

    @Benchmark
    public long ambStreamParallel() {
        return cataleg.parallelStream()
                .filter(l -> l.getPagines() > 400)
                .mapToLong(Llibre::getPagines)
                .sum();
    }

    /** Blackhole: consumeix el valor de manera que el JIT no el pugui eliminar. */
    @Benchmark
    public void agrupacio(Blackhole bh) {
        bh.consume(cataleg.stream()
                .collect(Collectors.groupingBy(Llibre::getAutor, Collectors.counting())));
    }
}

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

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

Benchmark                          (mida)  Mode  Cnt      Score  Units
ambStream:gc.alloc.rate.norm        10000  avgt   20    128,004  B/op
ambBucle: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...GestorPrestecs::prestar (218 bytes)
   1204   198       3       com...EstadistiquesBiblioTech::recomptePerTipus (94 bytes)
   2841   142       4       com...GestorPrestecs::prestar (218 bytes)   made not entrant

// Tu escrius
public int paginesTotals(List<Llibre> llibres) {
    int total = 0;
    for (Llibre l : llibres) {
        total += l.getPagines();     // crida a un getter
    }
    return total;
}

// El JIT integra getPagines() i genera alguna cosa equivalent a
for (Llibre l : llibres) {
    total += l.pagines;              // acces directe al camp
}

public double distancia(int x1, int y1, int x2, int y2) {
    Punt a = new Punt(x1, y1);        // no escapa
    Punt b = new Punt(x2, y2);        // no escapa
    return Math.hypot(a.x() - b.x(), a.y() - b.y());
}
// El JIT pot NO CREAR els dos objectes: zero assignacio al heap

// O(n*m): per a cada material, recorre TOTS els prestecs
for (Material m : materials) {                        // n = 10.000
    for (Prestec p : prestecs) {                      // m = 50.000
        if (p.getIsbn().equals(m.getIsbn())) { ... }
    }
}
// 500.000.000 comparacions

// O(n+m): indexar primer
Map<String, Prestec> perIsbn = prestecs.stream()
        .collect(Collectors.toMap(Prestec::getIsbn, p -> p, (a, b) -> a));

for (Material m : materials) {
    Prestec p = perIsbn.get(m.getIsbn());             // O(1)
}
// 60.000 operacions: 8.000 vegades menys

// MALAMENT: compila l expressio regular a CADA crida
public boolean esIsbnValid(String isbn) {
    return isbn.matches("978-\\d{10}");     // Pattern.compile intern cada vegada
}

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

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

// MALAMENT: consulta dins del bucle
for (Prestec p : prestecs) {
    Material m = cataleg.consultarABaseDeDades(p.getIsbn());     // N consultes
}

// BE: una consulta per lots
Map<String, Material> materials = cataleg.consultarPerLot(
        prestecs.stream().map(Prestec::getIsbn).distinct().toList());

public class ServeisBiblioTech {

    // Immutables i segurs entre fils: UN per aplicacio (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();
}

// MALAMENT: quadratic. Cada + crea un String nou copiant ho tot
String informe = "";
for (Prestec p : prestecs) {
    informe += p.getId() + ";" + p.getEmpleat() + "\n";
}

// BE: lineal
StringBuilder sb = new StringBuilder(prestecs.size() * 48);
for (Prestec p : prestecs) {
    sb.append(p.getId()).append(';').append(p.getEmpleat()).append('\n');
}
String informe = sb.toString();

// MILLOR encara si encaixa: streams (10-04)
String informe = prestecs.stream()
        .map(p -> p.getId() + ";" + p.getEmpleat())
        .collect(Collectors.joining("\n"));

// MALAMENT: 10 milions d objectes Long
Long suma = 0L;
for (int i = 0; i < 10_000_000; i++) {
    suma += i;                          // desempaqueta, suma, EMPAQUETA
}

// BE: zero objectes
long suma = 0L;
for (int i = 0; i < 10_000_000; i++) {
    suma += i;
}

// I en streams
int total = cataleg.stream().mapToInt(Llibre::getPagines).sum();   // IntStream

// Redimensiona ~14 vegades en arribar a 10.000, copiant cada vegada
List<Prestec> llista = new ArrayList<>();

// Una sola reserva
List<Prestec> llista = new ArrayList<>(10_000);

// HashMap: capacitat / factor de carrega, per no rehaixejar
Map<String, Prestec> mapa = new HashMap<>((int) (10_000 / 0.75f) + 1);

public class PoolDeCadenes {

    public static void main(String[] args) {

        String a = "Java Eficac";                            // literal: al POOL
        String b = "Java Eficac";                            // MATEIX objecte del pool
        String c = new String("Java Eficac");                // objecte NOU al heap
        String d = c.intern();                               // cerca al 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

        // Concatenacio en TEMPS DE COMPILACIO: es un literal
        String e = "Java " + "Eficac";
        System.out.println("a == e: " + (a == e));           // true

        // Concatenacio en EXECUCIO: objecte nou
        String part = "Java ";
        String f = part + "Eficac";
        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 BenchmarkCadenes {

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

    @Benchmark
    public String concatenacioAmbMes() {
        String resultat = "";
        for (int i = 0; i < n; i++) {
            resultat += "PR-2026-" + i + ";";         // QUADRATIC
        }
        return resultat;
    }

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

    @Benchmark
    public String ambStringBuilderDimensionat() {
        StringBuilder sb = new StringBuilder(n * 16);   // capacitat 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
BenchmarkCadenes.concatenacioAmbMes            10  avgt   20        0,412 ±    0,011  us/op
BenchmarkCadenes.concatenacioAmbMes           100  avgt   20        8,204 ±    0,204  us/op
BenchmarkCadenes.concatenacioAmbMes          1000  avgt   20      512,891 ±   14,201  us/op
BenchmarkCadenes.concatenacioAmbMes         10000  avgt   20    48204,112 ± 1204,441  us/op
BenchmarkCadenes.ambStringBuilder              10  avgt   20        0,198 ±    0,008  us/op
BenchmarkCadenes.ambStringBuilder             100  avgt   20        1,412 ±    0,041  us/op
BenchmarkCadenes.ambStringBuilder            1000  avgt   20       14,208 ±    0,312  us/op
BenchmarkCadenes.ambStringBuilder           10000  avgt   20      148,904 ±    3,204  us/op
BenchmarkCadenes.ambStringBuilderDimensionat 10000 avgt 20      104,412 ±    2,118  us/op

BenchmarkCadenes.concatenacioAmbMes:gc.alloc.rate.norm  10000  avgt  20  512048912,0  B/op
BenchmarkCadenes.ambStringBuilder:gc.alloc.rate.norm    10000  avgt  20     524312,0  B/op

package com.nexussoftware.bibliotech.diagnostic;

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

/**
 * Reprodueix els quatre patrons classics de fuita i les seves correccions.
 * NO es codi de produccio: es un laboratori didactic.
 */
public class LaboratoriDeFuites {

    // ==================================================================
    // FUITA 1: colleccio que creix sense limit
    // ==================================================================

    static class CacheAmbFuita {
        // static + mai no es neteja = arrel del GC que ho rete tot
        private static final Map<String, byte[]> CACHE = new HashMap<>();

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

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

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

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

    // ==================================================================
    // FUITA 2: listeners no donats de baixa
    // ==================================================================

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

        static void subscriure(Consumer<String> s)    { SUBSCRIPTORS.add(s); }
        static void dessubscriure(Consumer<String> s) { SUBSCRIPTORS.remove(s); }
        static int quants()                           { return SUBSCRIPTORS.size(); }
        static void netejar()                         { SUBSCRIPTORS.clear(); }
    }

    /** FUITA: se subscriu amb una lambda que captura this i mai no es dona de baixa. */
    static class FinestraAmbFuita {
        private final byte[] dadesPesades = new byte[100 * 1024];   // 100 KB

        FinestraAmbFuita() {
            GestorEsdeveniments.subscriure(esdev -> processar(esdev));  // captura this
        }
        private void processar(String e) { /* fa servir dadesPesades */ }
    }

    /** CORRECTE: guarda la referencia i ofereix close(). */
    static class FinestraCorrecta implements AutoCloseable {
        private final byte[] dadesPesades = new byte[100 * 1024];
        private final Consumer<String> subscriptor;

        FinestraCorrecta() {
            this.subscriptor = this::processar;
            GestorEsdeveniments.subscriure(subscriptor);
        }
        private void processar(String e) { }

        @Override public void close() { GestorEsdeveniments.dessubscriure(subscriptor); }
    }

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

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

        static void processar() {
            CONTEXT.set(new byte[500 * 1024]);       // 500 KB
            // sense remove(): el fil del pool el rete per sempre
        }
    }

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

        static void processar() {
            CONTEXT.set(new byte[500 * 1024]);
            try {
                // feina real
            } finally {
                CONTEXT.remove();                     // OBLIGATORI
            }
        }
    }

    // ==================================================================
    // FUITA 4: classe interna no estatica
    // ==================================================================

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

        /** NO estatica: rete CatalegPesat.this */
        class ComptadorAmbFuita {
            private int compte;
            void incrementar() { compte++; }
        }

        /** static: no rete res de l externa */
        static class ComptadorCorrecte {
            private int compte;
            void incrementar() { compte++; }
        }

        ComptadorAmbFuita crearAmbFuita()          { return new ComptadorAmbFuita(); }
        static ComptadorCorrecte crearCorrecte()   { return new ComptadorCorrecte(); }
    }

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

    /**
     * Mesura la memoria RETINGUDA (despres del GC), no la usada.
     *
     * Aqui System.gc() SI que esta justificat: es una eina de
     * diagnostic, no codi de produccio, i necessitem saber
     * quanta memoria sobreviu a una recolleccio.
     */
    static class MonitorDeMemoria {

        private final List<Long> mostres = new ArrayList<>();
        private final String nom;

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

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

        /** Creixement monoton en almenys el 80 % dels trams = fuita. */
        boolean detectaFuita() {
            if (mostres.size() < 4) {
                return false;
            }
            int creixents = 0;
            for (int i = 1; i < mostres.size(); i++) {
                if (mostres.get(i) > mostres.get(i - 1)) {
                    creixents++;
                }
            }
            double proporcio = (double) creixents / (mostres.size() - 1);
            long delta = mostres.get(mostres.size() - 1) - mostres.get(0);
            return proporcio >= 0.8 && delta > 5;       // 5 MB de llindar
        }

        String veredicte() {
            long inicial = mostres.get(0);
            long finalM = mostres.get(mostres.size() - 1);
            return String.format("%-26s %4d MB -> %4d MB  (Δ %+4d MB)  %s",
                    nom, inicial, finalM, finalM - inicial,
                    detectaFuita() ? "*** FUITA DETECTADA ***" : "estable");
        }
    }

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

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

        System.out.println("Heap maxim: "
                + Runtime.getRuntime().maxMemory() / 1024 / 1024 + " MB");
        System.out.println("Executar amb: java -Xmx512m LaboratoriDeFuites");
        System.out.println("=".repeat(74));

        provarFuita1();
        provarFuita2();
        provarFuita3();
        provarFuita4();

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

                DIAGNOSTIC AMB EINES REALS
                ──────────────────────────
                1. Localitzar el proces:
                     jps -lvm

                2. Veure si la generacio vella creix sense baixar (columna O):
                     jstat -gcutil <PID> 1000 30

                3. Histograma d objectes vius, dues vegades separades per minuts:
                     jcmd <PID> GC.class_histogram | head -20
                   La classe el recompte de la qual creix sense parar es la sospitosa.

                4. Bolcat complet per a l analisi:
                     jcmd <PID> GC.heap_dump /tmp/bibliotech.hprof

                5. Obrir el .hprof amb Eclipse MAT:
                     - "Leak Suspects Report" dona el culpable al 80 % dels casos
                     - Ordenar per "Retained Heap": quanta memoria allibera cada objecte
                     - "Path to GC Roots" sobre el sospitos: QUI el rete
                       (excloent referencies febles i toves)
                """);
    }

    private static void provarFuita1() {
        System.out.println("\n--- FUITA 1: colleccio sense limit ---");

        var monitor = new MonitorDeMemoria("HashMap sense limit");
        monitor.mostrejar();
        for (int ronda = 0; ronda < 5; ronda++) {
            for (int i = 0; i < 2_000; i++) {
                CacheAmbFuita.usar("isbn-" + ronda + "-" + i);
            }
            monitor.mostrejar();
        }
        System.out.println(monitor.veredicte());
        System.out.println("  Entrades retingudes: " + CacheAmbFuita.mida());
        CacheAmbFuita.netejar();

        var monitor2 = new MonitorDeMemoria("LinkedHashMap acotat");
        monitor2.mostrejar();
        for (int ronda = 0; ronda < 5; ronda++) {
            for (int i = 0; i < 2_000; i++) {
                CacheAcotada.usar("isbn-" + ronda + "-" + i);
            }
            monitor2.mostrejar();
        }
        System.out.println(monitor2.veredicte());
        System.out.println("  Entrades retingudes: " + CacheAcotada.mida() + " (sostre 500)");
        CacheAcotada.netejar();
    }

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

        var monitor = new MonitorDeMemoria("Sense dessubscriure");
        monitor.mostrejar();
        for (int ronda = 0; ronda < 5; ronda++) {
            for (int i = 0; i < 500; i++) {
                new FinestraAmbFuita();        // es crea, es descarta... i es rete
            }
            monitor.mostrejar();
        }
        System.out.println(monitor.veredicte());
        System.out.println("  Subscriptors vius: " + GestorEsdeveniments.quants());
        GestorEsdeveniments.netejar();

        var monitor2 = new MonitorDeMemoria("Amb try-with-resources");
        monitor2.mostrejar();
        for (int ronda = 0; ronda < 5; ronda++) {
            for (int i = 0; i < 500; i++) {
                try (var v = new FinestraCorrecta()) {
                    // us
                }
            }
            monitor2.mostrejar();
        }
        System.out.println(monitor2.veredicte());
        System.out.println("  Subscriptors vius: " + GestorEsdeveniments.quants());
    }

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

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

        var monitor = new MonitorDeMemoria("ThreadLocal sense remove");
        monitor.mostrejar();
        for (int ronda = 0; ronda < 4; ronda++) {
            var latch = new java.util.concurrent.CountDownLatch(200);
            for (int i = 0; i < 200; i++) {
                pool.submit(() -> { ContextAmbFuita.processar(); latch.countDown(); });
            }
            latch.await();
            monitor.mostrejar();
        }
        System.out.println(monitor.veredicte());
        System.out.println("  50 fils × 500 KB retinguts ≈ 25 MB que no s alliberen");

        var monitor2 = new MonitorDeMemoria("ThreadLocal amb remove");
        monitor2.mostrejar();
        for (int ronda = 0; ronda < 4; ronda++) {
            var latch = new java.util.concurrent.CountDownLatch(200);
            for (int i = 0; i < 200; i++) {
                pool.submit(() -> { ContextCorrecte.processar(); latch.countDown(); });
            }
            latch.await();
            monitor2.mostrejar();
        }
        System.out.println(monitor2.veredicte());

        pool.shutdown();
    }

    private static void provarFuita4() {
        System.out.println("\n--- FUITA 4: classe interna no estatica ---");

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

        var monitor = new MonitorDeMemoria("Classe interna NO estatica");
        monitor.mostrejar();
        for (int ronda = 0; ronda < 4; ronda++) {
            for (int i = 0; i < 20; i++) {
                CatalegPesat cataleg = new CatalegPesat();          // 2 MB
                comptadors.add(cataleg.crearAmbFuita());            // rete els 2 MB
            }
            monitor.mostrejar();
        }
        System.out.println(monitor.veredicte());
        System.out.println("  " + comptadors.size()
                + " comptadors de 16 bytes retenint " + (comptadors.size() * 2) + " MB");
        comptadors.clear();

        var monitor2 = new MonitorDeMemoria("Classe interna estatica");
        monitor2.mostrejar();
        for (int ronda = 0; ronda < 4; ronda++) {
            for (int i = 0; i < 20; i++) {
                CatalegPesat cataleg = new CatalegPesat();
                comptadors.add(CatalegPesat.crearCorrecte());       // no rete res
            }
            monitor2.mostrejar();
        }
        System.out.println(monitor2.veredicte());
        System.out.println("  " + comptadors.size()
                + " comptadors sense retenir cap cataleg");
    }
}

Heap maxim: 512 MB
Executar amb: java -Xmx512m LaboratoriDeFuites
==========================================================================

--- FUITA 1: colleccio sense limit ---
HashMap sense limit          12 MB ->  116 MB  (Δ +104 MB)  *** FUITA DETECTADA ***
  Entrades retingudes: 10000
LinkedHashMap acotat         14 MB ->   19 MB  (Δ   +5 MB)  estable
  Entrades retingudes: 500 (sostre 500)

--- FUITA 2: listeners ---
Sense dessubscriure          14 MB ->  272 MB  (Δ +258 MB)  *** FUITA DETECTADA ***
  Subscriptors vius: 2500
Amb try-with-resources       14 MB ->   15 MB  (Δ   +1 MB)  estable
  Subscriptors vius: 0

--- FUITA 3: ThreadLocal en pool ---
ThreadLocal sense remove     15 MB ->   40 MB  (Δ  +25 MB)  *** FUITA DETECTADA ***
  50 fils × 500 KB retinguts ≈ 25 MB que no s alliberen
ThreadLocal amb remove       15 MB ->   16 MB  (Δ   +1 MB)  estable

--- FUITA 4: classe interna no estatica ---
Classe interna NO estatica   16 MB ->  176 MB  (Δ +160 MB)  *** FUITA DETECTADA ***
  80 comptadors de 16 bytes retenint 160 MB
Classe interna estatica      17 MB ->   18 MB  (Δ   +1 MB)  estable
  80 comptadors sense retenir cap cataleg

package com.nexussoftware.bibliotech.diagnostic;

import com.nexussoftware.bibliotech.domini.Fitxa;

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

/**
 * Comparativa de tres estrategies de memoria cau.
 *
 * ADVERTIMENT: mesurament CASOLA. Els temps son orientatius.
 * Veure el comentari final sobre JMH.
 */
public class ComparativaDeCaches {

    /** Contracte comu. */
    interface Cache {
        Fitxa obtenir(String isbn, Function<String, Fitxa> calcul);
        int mida();
        long encerts();
        long fallades();
        String nom();

        default double taxaEncerts() {
            long total = encerts() + fallades();
            return total == 0 ? 0 : encerts() * 100.0 / total;
        }
    }

    /** ESTRATEGIA 1: sense limit. Es la fuita de l apartat 12. */
    static class CacheSenseLimit implements Cache {
        private final Map<String, Fitxa> mapa = new HashMap<>();
        private long encerts, fallades;

        public Fitxa obtenir(String isbn, Function<String, Fitxa> calcul) {
            Fitxa f = mapa.get(isbn);
            if (f != null) { encerts++; return f; }
            fallades++;
            f = calcul.apply(isbn);
            mapa.put(isbn, f);
            return f;
        }
        public int mida()      { return mapa.size(); }
        public long encerts()  { return encerts; }
        public long fallades() { return fallades; }
        public String nom()    { return "HashMap sense limit"; }
    }

    /** ESTRATEGIA 2: LRU acotada. */
    static class CacheLru implements Cache {
        private final int capacitat;
        private final LinkedHashMap<String, Fitxa> mapa;
        private long encerts, fallades;

        CacheLru(int capacitat) {
            this.capacitat = capacitat;
            this.mapa = new LinkedHashMap<>(capacitat, 0.75f, true) {
                @Override protected boolean removeEldestEntry(Map.Entry<String, Fitxa> e) {
                    return size() > CacheLru.this.capacitat;
                }
            };
        }
        public Fitxa obtenir(String isbn, Function<String, Fitxa> calcul) {
            Fitxa f = mapa.get(isbn);
            if (f != null) { encerts++; return f; }
            fallades++;
            f = calcul.apply(isbn);
            mapa.put(isbn, f);
            return f;
        }
        public int mida()      { return mapa.size(); }
        public long encerts()  { return encerts; }
        public long fallades() { return fallades; }
        public String nom()    { return "LRU (" + capacitat + ")"; }
    }

    /**
     * ESTRATEGIA 3: claus febles.
     *
     * COMPTE: les claus son String. Si vinguessin d un pool internat,
     * NO es recollectarien mai. Aqui es construeixen dinamicament,
     * aixi que si que son elegibles.
     */
    static class CacheFeble implements Cache {
        private final Map<String, Fitxa> mapa = new WeakHashMap<>();
        private long encerts, fallades;

        public Fitxa obtenir(String isbn, Function<String, Fitxa> calcul) {
            Fitxa f = mapa.get(isbn);
            if (f != null) { encerts++; return f; }
            fallades++;
            f = calcul.apply(isbn);
            mapa.put(isbn, f);
            return f;
        }
        public int mida()      { return mapa.size(); }
        public long encerts()  { return encerts; }
        public long fallades() { return fallades; }
        public String nom()    { return "WeakHashMap"; }
    }

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

    private static final int ACCESSOS = 100_000;
    private static final int ISBNS_DIFERENTS = 20_000;
    private static final int CALENTS = ISBNS_DIFERENTS / 5;    // el 20 %

    /** Calcul costos simulat. */
    private static Fitxa calcular(String isbn) {
        double acumulat = 0;
        for (int i = 1; i <= 2_000; i++) {
            acumulat += Math.sqrt(i);
        }
        return new Fitxa(isbn, "Fitxa " + isbn + " (" + (long) acumulat + ")", true);
    }

    /** Distribucio 80/20: el 80 % dels accessos sobre el 20 % de les claus. */
    private static List<String> generarAccessos(Random atzar) {
        List<String> accessos = new ArrayList<>(ACCESSOS);
        for (int i = 0; i < ACCESSOS; i++) {
            int index = atzar.nextInt(100) < 80
                    ? atzar.nextInt(CALENTS)
                    : CALENTS + atzar.nextInt(ISBNS_DIFERENTS - CALENTS);
            accessos.add(String.format("978-%010d", index));
        }
        return accessos;
    }

    record Resultat(String nom, double taxaEncerts, long memoriaMb,
                    long ms, int entrades, int supervivents) { }

    private static Resultat mesurar(Cache cache, List<String> accessos) throws Exception {

        long memoriaAbans = memoriaRetinguda();
        long inici = System.nanoTime();

        for (String isbn : accessos) {
            cache.obtenir(isbn, ComparativaDeCaches::calcular);
        }

        long ms = (System.nanoTime() - inici) / 1_000_000;
        long memoriaDespres = memoriaRetinguda();
        int entrades = cache.mida();

        // Pressio de memoria: reservar i deixar anar per forcar recollections agressives
        try {
            List<byte[]> pressio = new ArrayList<>();
            for (int i = 0; i < 200; i++) {
                pressio.add(new byte[1024 * 1024]);
            }
            pressio.clear();
        } catch (OutOfMemoryError e) {
            // esperat: es el que busquem
        }
        memoriaRetinguda();
        int supervivents = cache.mida();

        return new Resultat(cache.nom(), cache.taxaEncerts(),
                Math.max(0, memoriaDespres - memoriaAbans), ms, entrades, supervivents);
    }

    private static long memoriaRetinguda() 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 atzar = new Random(42);                // llavor fixa: reproduible
        List<String> accessos = generarAccessos(atzar);

        System.out.printf("""
                Accessos: %,d sobre %,d ISBN diferents (distribucio 80/20)
                Heap maxim: %d MB
                """, ACCESSOS, ISBNS_DIFERENTS,
                Runtime.getRuntime().maxMemory() / 1024 / 1024);

        List<Resultat> resultats = new ArrayList<>();
        resultats.add(mesurar(new CacheSenseLimit(), accessos));
        resultats.add(mesurar(new CacheLru(CALENTS), accessos));
        resultats.add(mesurar(new CacheLru(1_000), accessos));
        resultats.add(mesurar(new CacheFeble(), accessos));

        System.out.printf("%n%-22s %9s %9s %8s %10s %14s%n",
                "ESTRATEGIA", "ENCERTS", "MEMORIA", "TEMPS", "ENTRADES", "SOTA PRESSIO");
        System.out.println("-".repeat(78));

        resultats.forEach(r -> System.out.printf("%-22s %8.1f%% %7d MB %6d ms %10d %14d%n",
                r.nom(), r.taxaEncerts(), r.memoriaMb(), r.ms(),
                r.entrades(), r.supervivents()));

        System.out.println("""

                RECOMANACIO
                ───────────
                • HashMap sense limit: la taxa d encerts mes alta i la pitjor decisio.
                  Rete TOTES les entrades indefinidament: es la fuita 1 de
                  l apartat 12. Nomes acceptable si el nombre de claus esta acotat
                  per disseny (un enum, una llista fixa de configuracio).

                • LRU dimensionada al conjunt calent: la millor relacio.
                  Amb una distribucio 80/20, una LRU de la mida del 20 % calent
                  captura gairebe tots els encerts amb una fraccio de la memoria.
                  ES L ELECCIO PER DEFECTE.

                • LRU infradimensionada: la taxa d encerts s enfonsa perque les
                  entrades calentes s expulsen entre elles (thrashing). Dimensionar
                  una memoria cau per sota del conjunt de treball es pitjor que no tenir ne.

                • WeakHashMap: memoria autoregulada, pero comportament
                  IMPREDICTIBLE: les entrades desapareixen quan el GC ho decideix.
                  El seu cas real no es "memoria cau acotada" sino "metadades associades a
                  objectes vius que no controlo" (apartat 14).

                SOBRE AQUEST MESURAMENT
                ───────────────────────
                Es CASOLA i els seus numeros son orientatius:
                  - No hi ha escalfament suficient: les primeres estrategies
                    mesurades paguen la compilacio JIT de calcular().
                  - System.gc() es un suggeriment: la memoria "retinguda" es
                    aproximada.
                  - No hi ha repeticions ni intervals de confianca.
                  - L ordre d execucio hi influeix (la primera memoria cau deixa el
                    heap en un estat diferent per a la seguent).

                Per mesurar de debo: JMH amb @State(Scope.Benchmark),
                @Setup(Level.Iteration) recreant la memoria cau, @Fork(3) per aillar
                processos i -prof gc per a l assignacio normalitzada per operacio.
                """);
    }
}

Accessos: 100.000 sobre 20.000 ISBN diferents (distribucio 80/20)
Heap maxim: 512 MB

ESTRATEGIA               ENCERTS   MEMORIA    TEMPS   ENTRADES   SOTA PRESSIO
------------------------------------------------------------------------------
HashMap sense limit        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

RECOMANACIO
───────────
• HashMap sense limit: la taxa d encerts mes alta i la pitjor decisio.
  ...

package com.nexussoftware.bibliotech.diagnostic;

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

/**
 * Autodiagnostic de rendiment de BiblioTech.
 * Fa servir unicament l API de gestio del JDK: sense dependencies externes.
 */
public class InformeDeRendiment {

    // --- Seccions de l informe com a tipus segellat (10-06) ---

    public sealed interface Seccio {

        record Memoria(long heapUsatMb, long heapMaxMb, long heapCompromesMb,
                       long noHeapUsatMb, List<Pool> pools) implements Seccio { }

        record Pool(String nom, String tipus, long usatMb, long maxMb) { }

        record Recolleccio(List<EstadisticaGc> recollectors, long tempsTotalMs,
                           long tempsDeVidaMs) implements Seccio { }

        record EstadisticaGc(String nom, long recolleccions, long tempsMs) { }

        record Fils(int vius, int dimonis, int pic, long totalCreats,
                    List<String> interbloqueigs) implements Seccio { }

        record Classes(long carregades, long totalCarregades, long descarregades) implements Seccio { }

        record Compilacio(String compilador, long tempsMs) implements Seccio { }
    }

    public enum Salut { VERD, AMBRE, VERMELL }

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

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

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

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

    public Seccio.Recolleccio recollirGc() {
        List<Seccio.EstadisticaGc> recollectors =
                ManagementFactory.getGarbageCollectorMXBeans().stream()
                        .map(gc -> new Seccio.EstadisticaGc(
                                gc.getName(), gc.getCollectionCount(), gc.getCollectionTime()))
                        .toList();

        long total = recollectors.stream()
                .mapToLong(Seccio.EstadisticaGc::tempsMs).sum();

        return new Seccio.Recolleccio(recollectors, total,
                ManagementFactory.getRuntimeMXBean().getUptime());
    }

    public Seccio.Fils recollirFils() {
        ThreadMXBean fils = ManagementFactory.getThreadMXBean();

        List<String> interbloqueigs = new ArrayList<>();
        long[] bloquejats = fils.findDeadlockedThreads();
        if (bloquejats != null) {
            for (ThreadInfo info : fils.getThreadInfo(bloquejats, true, true)) {
                interbloqueigs.add(String.format("%s (id %d) bloquejat a %s, retingut per %s",
                        info.getThreadName(), info.getThreadId(),
                        info.getLockName(), info.getLockOwnerName()));
            }
        }

        return new Seccio.Fils(
                fils.getThreadCount(), fils.getDaemonThreadCount(),
                fils.getPeakThreadCount(), fils.getTotalStartedThreadCount(),
                interbloqueigs);
    }

    public Seccio.Classes recollirClasses() {
        ClassLoadingMXBean classes = ManagementFactory.getClassLoadingMXBean();
        return new Seccio.Classes(classes.getLoadedClassCount(),
                classes.getTotalLoadedClassCount(), classes.getUnloadedClassCount());
    }

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

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

    /** Semafor de salut amb regles justificades, mitjancant switch exhaustiu. */
    public Salut avaluar(Seccio seccio) {
        return switch (seccio) {

            // Regla: per sobre del 90 % del heap despres del GC, risc real d OOM
            case Seccio.Memoria(var usat, var max, var compromes, var noHeap, var pools) -> {
                double us = max <= 0 ? 0 : usat * 100.0 / max;
                yield us > 90 ? Salut.VERMELL : us > 75 ? Salut.AMBRE : Salut.VERD;
            }

            // Regla: mes del 10 % del temps de vida en GC indica un problema seriso
            case Seccio.Recolleccio(var recollectors, var totalMs, var vidaMs) -> {
                double percentatge = vidaMs == 0 ? 0 : totalMs * 100.0 / vidaMs;
                yield percentatge > 10 ? Salut.VERMELL : percentatge > 5 ? Salut.AMBRE : Salut.VERD;
            }

            // Regla: un interbloqueig es SEMPRE vermell
            case Seccio.Fils(var vius, var dimonis, var pic, var creats, var bloquejos) -> {
                if (!bloquejos.isEmpty()) yield Salut.VERMELL;
                yield vius > 1_000 ? Salut.AMBRE : Salut.VERD;
            }

            // Regla: moltes classes carregades i cap descarregada suggereix fuita de metaspace
            case Seccio.Classes(var carregades, var total, var descarregades) ->
                    carregades > 50_000 ? Salut.AMBRE : Salut.VERD;

            // El temps de JIT alt nomes es informatiu
            case Seccio.Compilacio c -> Salut.VERD;
        };
    }

    private String icona(Salut s) {
        return switch (s) {
            case VERD    -> "[ OK ]";
            case AMBRE   -> "[AVIS]";
            case VERMELL -> "[ MAL ]";
        };
    }

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

    public String generar() {
        var memoria = recollirMemoria();
        var gc = recollirGc();
        var fils = recollirFils();
        var classes = recollirClasses();
        var jit = recollirCompilacio();

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

        StringBuilder sb = new StringBuilder();

        sb.append("""
                ══════════════════════════════════════════════════════════
                  INFORME DE RENDIMENT -- BiblioTech
                ══════════════════════════════════════════════════════════
                  JVM:        %s %s
                  Proveidor:  %s
                  Sistema:    %s %s (%d processadors)
                  En marxa:   %s
                  PID:        %d
                """.formatted(
                        runtime.getVmName(), runtime.getVmVersion(), runtime.getVmVendor(),
                        so.getName(), so.getArch(), so.getAvailableProcessors(),
                        formatarDurada(runtime.getUptime()),
                        ProcessHandle.current().pid()));

        // --- MEMORIA ---
        sb.append("\n%s MEMORIA%n".formatted(icona(avaluar(memoria))));
        sb.append("  Heap:     %,d MB usats / %,d MB compromesos / %,d MB maxim (%.1f %%)%n"
                .formatted(memoria.heapUsatMb(), memoria.heapCompromesMb(),
                           memoria.heapMaxMb(),
                           memoria.heapMaxMb() <= 0 ? 0
                                   : memoria.heapUsatMb() * 100.0 / memoria.heapMaxMb()));
        sb.append("  No-heap:  %,d MB (metaspace, memoria cau de codi)%n"
                .formatted(memoria.noHeapUsatMb()));
        sb.append("  Regions:%n");
        memoria.pools().forEach(p -> sb.append("    %-28s %6d MB%s%n".formatted(
                p.nom(), p.usatMb(), p.maxMb() < 0 ? "" : " / " + p.maxMb() + " MB")));

        // --- GC ---
        double percentatgeGc = gc.tempsDeVidaMs() == 0 ? 0
                : gc.tempsTotalMs() * 100.0 / gc.tempsDeVidaMs();
        sb.append("\n%s RECOLLECCIO DE BROSSA%n".formatted(icona(avaluar(gc))));
        gc.recollectors().forEach(r -> sb.append(
                "  %-28s %,8d recolleccions  %,8d ms  (mitjana %.1f ms)%n".formatted(
                        r.nom(), r.recolleccions(), r.tempsMs(),
                        r.recolleccions() == 0 ? 0.0 : (double) r.tempsMs() / r.recolleccions())));
        sb.append("  Total en GC: %,d ms de %,d ms de vida (%.2f %%)%n"
                .formatted(gc.tempsTotalMs(), gc.tempsDeVidaMs(), percentatgeGc));

        // --- FILS ---
        sb.append("\n%s FILS%n".formatted(icona(avaluar(fils))));
        sb.append("  Vius: %d (%d dimonis)   Pic: %d   Creats en total: %,d%n"
                .formatted(fils.vius(), fils.dimonis(), fils.pic(), fils.totalCreats()));
        if (fils.interbloqueigs().isEmpty()) {
            sb.append("  Sense interbloqueigs detectats%n".formatted());
        } else {
            sb.append("  *** INTERBLOQUEIG DETECTAT ***%n".formatted());
            fils.interbloqueigs().forEach(i -> sb.append("    ").append(i).append('\n'));
        }

        // --- CLASSES I JIT ---
        sb.append("\n%s CLASSES%n".formatted(icona(avaluar(classes))));
        sb.append("  Carregades ara: %,d   Total historic: %,d   Descarregades: %,d%n"
                .formatted(classes.carregades(), classes.totalCarregades(), classes.descarregades()));

        sb.append("\n%s COMPILACIO JIT%n".formatted(icona(avaluar(jit))));
        sb.append("  Compilador: %s   Temps total: %,d ms%n"
                .formatted(jit.compilador(), jit.tempsMs()));

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

        sb.append("""

                ──────────────────────────────────────────────────────────
                  SEGUENT PAS SI ALGUNA COSA ESTA EN AVIS O EN MAL
                    jstat -gcutil %d 1000 30       (creix la columna O?)
                    jcmd %d GC.class_histogram     (quina classe creix?)
                    jcmd %d Thread.print           (interbloqueigs i piles)
                    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 formatarDurada(long ms) {
        Duration d = Duration.ofMillis(ms);
        return "%dd %02dh %02dm %02ds".formatted(
                d.toDays(), d.toHoursPart(), d.toMinutesPart(), d.toSecondsPart());
    }

    /** Arrenca una gravacio JFR sobre aquest mateix proces. */
    public void gravarJfr(String fitxer, int segons) throws Exception {
        long pid = ProcessHandle.current().pid();
        var proces = new ProcessBuilder("jcmd", String.valueOf(pid),
                "JFR.start", "name=bibliotech", "settings=profile",
                "duration=" + segons + "s", "filename=" + fitxer)
                .inheritIO().start();
        proces.waitFor();
        System.out.println("Gravacio JFR iniciada: " + fitxer);
    }

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

        // Generar una mica de carrega perque les xifres no siguin totes zero
        List<byte[]> brossa = new ArrayList<>();
        for (int i = 0; i < 500; i++) {
            brossa.add(new byte[512 * 1024]);
            if (i % 50 == 0) brossa.clear();
        }
        brossa.clear();

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

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

[ OK ] MEMORIA
  Heap:     41 MB usats / 258 MB compromesos / 4.096 MB maxim (1,0 %)
  No-heap:  22 MB (metaspace, memoria cau de codi)
  Regions:
    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 ] RECOLLECCIO DE BROSSA
  G1 Young Generation             12 recolleccions        41 ms  (mitjana 3,4 ms)
  G1 Old Generation                0 recolleccions         0 ms  (mitjana 0,0 ms)
  Total en GC: 41 ms de 2.104 ms de vida (1,95 %)

[ OK ] FILS
  Vius: 11 (9 dimonis)   Pic: 11   Creats en total: 12
  Sense interbloqueigs detectats

[ OK ] CLASSES
  Carregades ara: 1.284   Total historic: 1.284   Descarregades: 0

[ OK ] COMPILACIO JIT
  Compilador: HotSpot 64-Bit Tiered Compilers   Temps total: 412 ms

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

──────────────────────────────────────────────────────────
  SEGUENT PAS SI ALGUNA COSA ESTA EN AVIS O EN MAL
    jstat -gcutil 18492 1000 30       (creix la columna O?)
    jcmd 18492 GC.class_histogram     (quina classe creix?)
    jcmd 18492 Thread.print           (interbloqueigs i piles)
    jcmd 18492 JFR.start settings=profile duration=120s \
         filename=/tmp/bibliotech.jfr
══════════════════════════════════════════════════════════