JIT, GC y memoria en Java (JDK 26), medidos

JIT de 349 a 46 µs, -Xint 20× más lento, escape analysis, cuatro GC comparados con -Xlog:gc, un OOM de G1 a la mitad del heap y una fuga hallada con jcmd.

Serie: curso de Java 6/6 (avanzado). Para quien ya escribe Java correcto y ahora quiere saber qué hace la JVM con él: cuándo el código se vuelve rápido, adónde se va la memoria y por qué el mismo programa se comporta distinto con otro flag. Al terminar vas a poder leer la salida de -Xlog:gc, elegir un recolector con mediciones y no con folclore, encontrar una fuga con jcmd y detectar un benchmark que te está mintiendo.

Casi todos los reportes de "Java es lento" que llegan a un equipo, ya sea en una startup que escala su primer backend o en una consultora que mantiene sistemas de un banco, salen de uno de tres lugares: medir antes de que el JIT haya compilado algo, un recolector elegido por costumbre o una memoria que solo crece. Este curso desarma cada uno con programas pequeños, y cada número de abajo sale de una ejecución en la máquina que describimos a continuación. Donde los resultados nos sorprendieron (un heap que se agotó a la mitad de su tamaño, un attach que falló mientras una fuga agonizaba) conservamos la salida cruda.

Entorno: OpenJDK 26 (Temurin 26+35), Mac con Apple Silicon (M1 Pro, 8 núcleos, 16 GB), macOS. Heap por defecto en esta máquina: 4 GB máximo, G1. La mayoría de los tiempos son la mediana de 3 ejecuciones; las de calentamiento del JIT muestran cada lote por separado, porque el calentamiento es justamente lo que queremos ver.

El calentamiento del JIT, medido: los primeros lotes contra el estado estable

HotSpot empieza cada método en el intérprete de bytecode, cuenta llamadas e iteraciones de bucles, y compila los métodos calientes por niveles (tiers): primero C1 con profiling (tier 3), luego C2 usando ese perfil (tier 4). Para verlo, medimos el mismo lote pequeño 2,000 veces:

/** Time the same small batch 2,000 times and watch the JIT kick in. */
public class Warmup {
    static int collatzSteps(long n) {                // pure CPU, no allocation
        int steps = 0;
        while (n != 1) { n = (n & 1) == 0 ? n >>> 1 : 3 * n + 1; steps++; }
        return steps;
    }
    static long batch() {                            // 1,000 calls per batch
        long total = 0;
        for (long n = 1; n <= 1_000; n++) total += collatzSteps(n);
        return total;
    }
    public static void main(String[] args) {
        int[] show = {1, 2, 3, 5, 10, 20, 50, 100, 200, 500, 1000, 2000};
        long check = 0; int k = 0;
        long start = System.nanoTime();
        for (int b = 1; b <= 2000; b++) {
            long t0 = System.nanoTime();
            check += batch();
            long us = (System.nanoTime() - t0) / 1_000;
            if (k < show.length && b == show[k]) { System.out.printf("batch %4d: %,6d us%n", b, us); k++; }
        }
        System.out.printf("total %,d ms, checksum %d%n", (System.nanoTime() - start) / 1_000_000, check);
    }
}
Lote Por defecto, ejecución 1 Ejecución 2 Ejecución 3 -Xint Solo C1 (-XX:TieredStopAtLevel=1)
1 334 µs 349 µs 373 µs 919 µs 258 µs
2 215 µs 227 µs 209 µs 900 µs 109 µs
5 82 µs 81 µs 79 µs 908 µs 142 µs
50 75 µs 74 µs 76 µs 926 µs 95 µs
200 47 µs 49 µs 47 µs 1,011 µs 76 µs
2000 46 µs 45 µs 49 µs 1,043 µs 76 µs
total 117 ms 119 ms 116 ms 1,940 ms 174 ms

Se ven tres mesetas: el primer lote en unos 350 µs (parte interpretado, parte compilando), unos 75 µs desde el lote 5 y 46 µs desde alrededor del lote 200. El estado estable es 7.6× más rápido que el lote 1. -XX:+PrintCompilation muestra exactamente cuándo ocurrió cada paso (columnas: ms desde el inicio, id de compilación, % = on-stack replacement, tier):

20    8       3       Warmup::collatzSteps (38 bytes)
20    9 %     4       Warmup::collatzSteps @ 2 (38 bytes)
36  116       4       Warmup::collatzSteps (38 bytes)
37    8       3       Warmup::collatzSteps (38 bytes)   made not entrant: not used
...
44  127 %     4       Warmup::batch @ 4 (29 bytes)
45  128       4       Warmup::batch (29 bytes)

collatzSteps llegó a C2 (tier 4) a los 36 ms, y la versión de C1 se descartó ("made not entrant"). La segunda bajada, alrededor de los lotes 100–200, coincide con el momento en que el llamador batch() se compiló en tier 4 a los 45 ms, lo que permite a C2 hacer inlining de collatzSteps dentro del bucle. La columna Solo C1 muestra lo que aporta C2: C1 se estabilizó en 76 µs, C2 en 46 µs.

Diagrama de flujo de la compilación por niveles. Un método empieza en el intérprete a unos 910 microsegundos por lote, la velocidad medida con -Xint. Tras unos miles de llamadas, C1 lo compila con profiling, tier 3, y los lotes tardan unos 75 microsegundos. Con ese perfil, C2 lo compila en tier 4 y los lotes se estabilizan en unos 46 microsegundos. Si se rompe una suposición de C2, el código se desoptimiza y el método vuelve al intérprete.
Los niveles por los que pasó un método caliente en JDK 26, con el tiempo medido por lote de 1,000 llamadas. -XX:+PrintCompilation mostró los cambios de nivel.

-Xint contra el modo por defecto: cuánto vale el JIT

-Xint apaga el JIT. Entonces cada lote cuesta unos 900 µs, y la ejecución completa tardó 1,940 ms en lugar de 117 ms: 16.6× más lento en total, unas 20× en estado estable (910 µs contra 46 µs). El intérprete nunca mejora, y por eso su columna es plana. -Xint sirve para una sola cosa: si un bug desaparece con -Xint, sospecha de un problema relacionado con el JIT (o de una data race que el compilador hizo visible). Nunca lo uses para que los tiempos sean "justos".

Escape analysis, en pocas palabras

C2 revisa si un objeto puede verse fuera del método que lo creó. Si no, puede saltarse la asignación y mantener los campos en registros ("scalar replacement"). Un record que nunca sale del bucle:

record Point(double x, double y) {}

static double sumDistances(int n) {
    double s = 0;
    for (int i = 0; i < n; i++) {
        Point p = new Point(i, i + 1);            // never stored, never returned
        s += Math.sqrt(p.x() * p.x() + p.y() * p.y());
    }
    return s;
}

Contamos los bytes asignados por el thread con com.sun.management.ThreadMXBean.getThreadAllocatedBytes para 50 millones de iteraciones por ronda:

== default (EA on)
round 1:   57 ms, allocated      7 MB
round 3:   50 ms, allocated      0 MB
round 5:   49 ms, allocated      0 MB
== -XX:-DoEscapeAnalysis
round 1:  326 ms, allocated  1,525 MB
round 3:   80 ms, allocated  1,525 MB
round 5:  117 ms, allocated  1,525 MB

1,525 MB son exactamente 50 millones × 32 bytes, un Point por iteración. Con escape analysis activado, el estado estable no asignó nada. La lección práctica no es "apágalo"; es que los objetos pequeños y de vida corta dentro de bucles calientes muchas veces salen gratis, así que no hagas inlining manual de records por velocidad sin medir. Escape analysis se rinde cuando el objeto se guarda en un campo, se pasa a un método al que no se le hace inlining, o el método es demasiado grande para el inlining.

Cuatro recolectores de basura con el mismo programa

Un programa que asigna mucho: 20 millones de byte[] de 16 a 495 bytes (con Random(42) como semilla), de los que 1 de cada 8 se guarda en un anillo de 200,000 posiciones, para que haya un conjunto de trabajo vivo de unos 50 MB.

Random rnd = new Random(42);
byte[][] live = new byte[200_000][];          // the long-lived working set
for (int i = 0; i < 20_000_000; i++) {
    byte[] b = new byte[16 + rnd.nextInt(480)];
    b[0] = (byte) i;
    if ((i & 7) == 0) live[rnd.nextInt(live.length)] = b;   // 1 in 8 survives a while
    checksum += b[0];
}

Se ejecuta con java -XX:+Use<X>GC -Xmx1g -Xlog:gc:file=gc.log Churn. Líneas reales, recortadas:

G1        [0.874s][info][gc] GC(23) Pause Young (Normal) (G1 Evacuation Pause) 675M->207M(862M) 7.355ms
Serial    [1.218s][info][gc] GC(122) Pause Young (Allocation Failure) 606M->449M(622M) 17.816ms
Parallel  [0.779s][info][gc] GC(32) Pause Young (Allocation Failure) 341M->104M(342M) 5.028ms
ZGC       [0.275s][info][gc] GC(3) Minor Collection (Allocation Rate) 432M(42%)->226M(22%) 0.047s

La línea de ZGC es la trampa: 0.047 s es la duración de todo el ciclo concurrente mientras el programa seguía corriendo, no una pausa. El -Xlog:gc simple no imprime las pausas de ZGC; agrega gc+phases:

[0.375s][info][gc,phases] GC(5) Y: Pause Mark Start (Major) 0.009ms
[0.386s][info][gc,phases] GC(5) Y: Concurrent Mark 10.114ms
[0.386s][info][gc,phases] GC(5) Y: Pause Mark End 0.008ms
[0.387s][info][gc,phases] GC(5) Y: Pause Relocate Start 0.006ms

Sumando cada línea "Pause" (un script de Python sobre los logs, 3 ejecuciones de cada uno):

Recolector Tiempo total (mediana) Pausas Pausa total Pausa máxima Tiempo de CPU de usuario
G1 (por defecto) 990 ms 26 107 ms 10.8 ms 1.09 s
Serial 1,283 ms 125 591 ms 20.7 ms 1.18 s
Parallel 844 ms 35 151 ms 9.2 ms 1.36 s
ZGC 939 ms ~60 0.4 ms 0.02 ms 1.69 s

El tiempo de CPU de usuario sale de ejecuciones aparte del mismo programa con /usr/bin/time -p y sin logging.

Gráfico de barras del tiempo total de pausas del GC. Serial 591 milisegundos en 125 pausas, Parallel 151 milisegundos en 35 pausas, G1 107 milisegundos en 26 pausas, ZGC 0.4 milisegundos en unas 60 pausas muy cortas. ZGC fue el que menos pausó, pero el que más tiempo de CPU usó.
Tiempo total de pausas stop-the-world según -Xlog:gc para el mismo programa con muchas asignaciones y -Xmx1g, mediana de 3 ejecuciones. La cifra de ZGC es la suma de sus fases Pause de gc+phases.

Cómo leerlo: Parallel terminó primero porque lanza los 8 núcleos a cada pausa y no hace nada de forma concurrente. ZGC casi nunca detuvo la aplicación, pero quemó 55% más CPU que G1 haciendo su trabajo en otros threads, algo que pagas en un servidor ocupado. Serial usó un solo thread de GC y, con su generación joven pequeña por defecto, recolectó 125 veces. G1 queda en el medio en todas las columnas, y por eso es el predeterminado. La dispersión entre ejecuciones de G1 fue grande (835–1,087 ms), así que aquí las diferencias por debajo de ~15% son ruido.

Tamaño del heap, OutOfMemoryError y una sorpresa de G1

Llena el heap con bloques de 1 MB bajo -Xmx64m:

List<byte[]> keep = new ArrayList<>();
while (true) {
    keep.add(new byte[1 << 20]);
    if (keep.size() % 16 == 0) System.out.println("holding " + keep.size() + " MB");
}
max heap = 64 MB
holding 16 MB
Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
    at Oom.main(Oom.java:10)

Nunca imprimió "holding 32 MB". Un heap de 64 MB se agotó tras 31 arrays de 1 MB. El log lo explica: Pause Young (Normal) (G1 Humongous Allocation). Con este heap, G1 eligió regiones de 1 MB (-XX:+PrintFlagsFinal muestra G1HeapRegionSize = 1048576). Cualquier objeto de media región o más es humongous y recibe regiones completas solo para él, y new byte[1048576] es 1 MB de datos más una cabecera de 16 bytes, así que necesita dos regiones. Contamos cuántos arrays cupieron antes del error:

Tamaño del array G1 Serial
1,048,576 bytes (1 MB) 31 (31.0 MB) 59 (59.0 MB)
1,048,560 bytes (1 MB − 16) 62 (62.0 MB) 60 (60.0 MB)
524,288 bytes 62 (31.0 MB) 120 (60.0 MB)
262,144 bytes 189 (47.3 MB) 242 (60.5 MB)

Dieciséis bytes menos duplicaron lo que G1 podía guardar. Los buffers de exactamente una potencia de dos que son grandes en relación con el tamaño de región son el peor caso. Soluciones: un heap más grande (el tamaño de región crece con él), -XX:G1HeapRegionSize=, o buffers un poco más pequeños.

Dos salidas reales más que vale la pena conocer. -XX:+ExitOnOutOfMemoryError imprime Terminating due to java.lang.OutOfMemoryError: Java heap space y termina con código de salida 3, que un supervisor puede reiniciar, en lugar de dejar un proceso medio muerto. Y cuando el heap está tan lleno que ni siquiera el handler de errores puede asignar memoria, solo obtienes esto, sin stack trace:

Exception: java.lang.OutOfMemoryError thrown from the UncaughtExceptionHandler in thread "main"

Error común: una fuga de memoria con un mapa static

El error: un HashMap static usado como caché, con una clave nueva en cada petición.

static final Map<String, Session> CACHE = new HashMap<>();          // the leak
...
cache.put("req-" + req, new Session("user" + (req % 100), new byte[1024]));

Lo que pasa en realidad con -Xmx256m:

requests=   50,000  entries=   50,001  heapUsed=  63 MB
requests=  100,000  entries=  100,001  heapUsed= 120 MB
requests=  150,000  entries=  150,001  heapUsed= 180 MB
requests=  200,000  entries=  200,001  heapUsed= 253 MB

Exception: java.lang.OutOfMemoryError thrown from the UncaughtExceptionHandler in thread "main"

Mientras corría, jstat y jcmd, que vienen con el JDK, lo mostraron desde afuera:

$ jcmd -l
69893 Leak
$ jstat -gcutil <pid> 3000
  S0     S1     E      O      M     CCS    YGC     YGCT     FGC    FGCT  ...
     - 100.00   0.00  91.67  73.19  20.54      8     0.009     0     0.000
     - 100.00   0.00  98.34  73.26  20.54     37     0.037     0     0.000
     -      -  33.33  67.30  73.84  20.54     44     0.054     1     0.024
     - 100.00  12.50  99.99  73.84  20.54     55     0.086     1     0.024
$ jcmd <pid> GC.class_histogram
 num     #instances         #bytes  class name (module)
   1:        227556       79768448  [B (java.base@26)
   2:        155023        3720552  java.lang.String (java.base@26)
   3:         75104        2403328  java.util.HashMap$Node (java.base@26)
   4:         72451        1738824  Leak$Session

La columna O (generación vieja, % de ocupación) vuelve a subir a 99.99 después de un full GC (FGC = 1): son datos vivos, no basura. En el histograma, las cuentas de Leak$Session y HashMap$Node se mueven juntas, lo que apunta directo al mapa. jcmd <pid> GC.heap_info agregó 86 old (86M), 1 humongous (1M). Una trampa más: en una ejecución anterior, más rápida, jcmd falló con AttachNotSupportedException: ... state is not ready to participate in attach handshake! porque la JVM estaba atascada en full GCs seguidos. Conéctate temprano, o arranca con -XX:+HeapDumpOnOutOfMemoryError.

La solución: ponle un límite a la caché. Un LinkedHashMap ordenado por acceso es un LRU de 5 líneas:

static final Map<String, Session> LRU = new LinkedHashMap<>(16, 0.75f, true) {
    @Override protected boolean removeEldestEntry(Map.Entry<String, Session> e) {
        return size() > 10_000;
    }
};

Mismo programa, mismo heap, 80 segundos: 600,000 peticiones, entries= 10,000 en todas las líneas y el heap entre 17 y 53 MB. (No es thread-safe; para cachés compartidas, envuélvelo o usa una librería de caché de verdad.)

Arranque: java File.java contra una clase compilada

java Hello.java compila el código fuente en memoria en cada arranque. Medianas de 20 arranques de cada uno, medidas desde un script de Python:

Comando Mediana
java Hello.java (arranque desde el fuente) 291 ms
java -Xshare:off -cp cls Hello 64 ms
java -cp hello.jar Hello 43 ms
java -cp cls Hello 39 ms
java -XX:AOTCache=hello.aot -cp hello.jar Hello 35 ms
Gráfico de barras del tiempo de arranque. java Hello.java, que primero compila en memoria, tardó 291 milisegundos. Una clase compilada con class data sharing desactivado tardó 64 milisegundos. Un jar tardó 43, un directorio de clases 39 y un jar con caché AOT 35 milisegundos.
Tiempo total para ejecutar un hola mundo, mediana de 20 ejecuciones de cada uno, medido desde un script de Python que lanza el proceso.

Arrancar desde el fuente cuesta unos 250 ms de compilación cada vez: está bien para scripts y clases, pero no para una herramienta de línea de comandos que se llama dentro de un bucle. -Xshare:off desactiva el archivo de class data sharing que trae el JDK y suma unos 25 ms. Nuestro primer intento de caché AOT falló con errores reales:

$ java -XX:AOTCacheOutput=hello.aot -cp cls Hello
Error occurred during CDS dumping
Cannot have non-empty directory in paths

La caché AOT solo acepta JARs en el class path. Después de empaquetar un JAR con la herramienta jar del JDK, -XX:AOTCacheOutput escribió una caché de 10 MB y el arranque bajó de 43 a 35 ms. Antes de eso, como el primer paso había fallado, -XX:AOTCache=hello.aot apuntaba a un archivo que no existía: la JVM imprimió [error][aot] Unable to map shared spaces, ejecutó el programa de todos modos sin la caché y terminó con código 0, algo que un script de build no notaría.

Advertencias honestas sobre benchmarks (sin JMH)

Cada número de arriba se midió con System.nanoTime() en bucles simples, no con JMH, que este entorno no incluía. Funciona solo porque los efectos son grandes. Lo que puede salir mal al medir a mano:

  • Sin calentamiento: el lote 1 fue 7.6× más lento que el estado estable. Descarta siempre las primeras rondas, y muéstralas si el calentamiento le importa a tus usuarios.
  • Código muerto: si un resultado no se usa, C2 puede borrar el trabajo. Cada programa de aquí imprime un checksum.
  • El inlining cambia lo que mides: la segunda aceleración vino de compilar al llamador. Un micro-benchmark mide tu método en un contexto de inlining concreto.
  • Ruido: el tiempo total de G1 varió entre 835 y 1,087 ms en ejecuciones idénticas. Repite, reporta medianas y desconfía de diferencias menores a ~15%.
  • Máquina: una M1 Pro tiene 6 núcleos de rendimiento y 2 de eficiencia; el planificador decide cuál te toca.

Para cualquier diferencia menor a unas 2×, usa JMH.

Tabla de decisión y notas de versión

Objetivo Haz esto Evidencia de arriba
Micro-mediciones justas calienta, imprime un checksum, repite, toma la mediana 349 → 46 µs
CLI de vida corta JAR compilado, considera una caché AOT 291 contra 35 ms
Proceso batch de throughput Parallel GC menor tiempo total, 844 ms
Servicio sensible a la latencia ZGC, presupuesta la CPU extra pausa máxima 0.02 ms, +55% CPU
No estás seguro G1 (por defecto) en el medio en todas las columnas
Buffers grandes en un heap pequeño evita tamaños exactos de potencia de dos ≥ media región 31 contra 62 arrays
Sospecha de fuga jstat -gcutil, luego jcmd GC.class_histogram O de vuelta en 99.99% tras un full GC
  • Comprobado solo en JDK 26. ZGC es generacional por defecto desde JDK 23 (las líneas Y:/O: de arriba); el flag de un solo paso -XX:AOTCacheOutput se agregó en JDK 25 y la caché AOT en sí en JDK 24 (JEP 483). No ejecutamos JDKs anteriores para confirmarlo.
  • El arranque desde un archivo fuente (java Hello.java) existe desde JDK 11; los programas fuente de varios archivos, desde JDK 22. Aquí solo usamos la forma de un archivo.
  • La herramienta de línea de comandos jfr no estaba en esta imagen del JDK; jcmd y jstat sí.

Este es el último curso de Java. El curso 5 cubrió el lado de los threads del mismo runtime.


Anterior: Curso 5: virtual threads y concurrencia · Volver al inicio: Curso 1: tipos, strings e igualdad

Relacionados: curso de Python 6: profiling y optimización · VB.NET 6: VB.NET en .NET 10 e interoperabilidad con C# (en inglés)

Preguntas frecuentes

¿Cuánto tarda el calentamiento del JIT en Java?

En nuestra prueba, un lote de 1,000 llamadas tardó 349 µs la primera vez, unos 75 µs desde el lote 5 (compilado con C1) y 46 µs desde alrededor del lote 200 (compilado con C2), todo en menos de 0.1 s. El mismo lote tardó unos 910 µs con -Xint, que desactiva el JIT. Los benchmarks cortos que no calientan miden sobre todo el intérprete y el compilador.

¿Qué recolector de basura (GC) conviene usar en JDK 26?

Quédate con G1, el predeterminado, salvo que tengas un motivo medido. En una prueba con muchas asignaciones y -Xmx1g, Parallel tuvo el menor tiempo total (844 ms) y ZGC las pausas más cortas (0.4 ms en total, 0.02 ms como máximo), pero usó alrededor de 55% más CPU que G1. Serial pausó 591 ms en total a lo largo de 125 recolecciones.

¿Por qué mi programa Java se quedó sin memoria a la mitad de -Xmx?

Con G1 y un heap pequeño, los objetos de media región o más son 'humongous' y ocupan regiones completas. Con -Xmx64m el tamaño de región es 1 MB, así que un byte[1048576] más su cabecera de 16 bytes necesita dos regiones: solo caben 31 de esos arrays. Con arrays 16 bytes más pequeños caben 62. Serial GC acomodó 59 de los arrays de 1 MB.

  • #Java
  • #JVM
  • #JIT
  • #recolección de basura
  • #fuga de memoria
  • #jcmd
  • #JDK 26
  • #avanzado

t.laboratory

A technical blog that records real problems from the apps, servers and services we build and run — and the code that fixed them.

Acerca de · Apps

↑