0Pricing
Java Academy · Lección

Algoritmos de GC: Serial, G1, ZGC y Shenandoah

Compare las características de las pausas del GC y las ventajas y desventajas del rendimiento de los collectors modernos de la JVM.

Algoritmos de GC: Serial, G1, ZGC y Shenandoah es una lección gratuita de Java Academy en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Java Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Java Academy incluye 4 lecciones en total.

Elegir un algoritmo de GC

La JVM incluye varios algoritmos de GC, cada uno optimizado para distintas cargas de trabajo. La elección adecuada depende del tamaño del heap, los requisitos de latencia y los objetivos de rendimiento.

// Enable GC algorithms:
// -XX:+UseSerialGC
// -XX:+UseParallelGC
// -XX:+UseG1GC       (default since Java 9)
// -XX:+UseZGC        (Java 15+ production)
// -XX:+UseShenandoahGC (Red Hat / OpenJDK builds)

Serial GC

Serial GC utiliza un solo subproceso para la recopilación. Todos los subprocesos de la aplicación se detienen durante el GC («stop-the-world»). Solo es adecuado para heaps pequeños o entornos con una sola CPU, como los sistemas integrados.

// Use:
// java -XX:+UseSerialGC -Xmx256m MyApp
// Pauses: long (proportional to heap size)
// Throughput: low
// Best for: CLI tools, small heaps < 100 MB

Parallel GC (recolector orientado al rendimiento)

Parallel GC utiliza varios subprocesos para los Minor GC y Major GC. Las pausas stop-the-world son más cortas que con Serial, pero siguen siendo considerables. Es ideal para el procesamiento por lotes, donde el rendimiento importa más que la latencia.

// Use:
// java -XX:+UseParallelGC -XX:ParallelGCThreads=8 MyApp
// Pauses: moderate
// Throughput: high
// Best for: batch jobs, number crunching

G1 GC (Garbage-First)

G1 divide el heap en regiones del mismo tamaño (aproximadamente de 2 KB a 32 MB). Recopila primero las regiones con más basura y cumple un objetivo de pausa configurable. Es el valor predeterminado desde Java 9.

// Use:
// java -XX:+UseG1GC -XX:MaxGCPauseMillis=200 MyApp
// Pauses: bounded by target (but not guaranteed)
// Throughput: good
// Best for: large heaps (4 GB+), mixed workloads

Tipos de regiones de G1

Las regiones de G1 se asignan dinámicamente como Eden, Survivor, Old o Humongous (para objetos grandes de más del 50 % del tamaño de la región). Esta flexibilidad permite una recopilación incremental.

ZGC (Z Garbage Collector)

ZGC realiza la mayor parte del trabajo de forma concurrente con la aplicación. Los tiempos de pausa suelen ser inferiores a 1 ms, independientemente del tamaño del heap. Está listo para producción desde Java 15.

// Use:
// java -XX:+UseZGC -Xmx16g MyApp
// Pauses: < 1 ms (usually)
// Throughput: slightly lower than G1 (concurrent work has CPU cost)
// Best for: large heaps, low-latency services (APIs, trading)

Shenandoah GC

Shenandoah (Red Hat) también consigue pausas inferiores a un milisegundo mediante la compactación concurrente. Está disponible en las compilaciones de OpenJDK. Tiene objetivos muy similares a los de ZGC, pero utiliza algoritmos internos diferentes.

// Use:
// java -XX:+UseShenandoahGC MyApp
// Available in: Red Hat builds, some AdoptOpenJDK distributions
// Pauses: sub-millisecond
// Best for: latency-sensitive workloads

ZGC generacional (Java 21+)

Java 21 introdujo el ZGC generacional, que combina el enfoque de pausas reducidas de ZGC con la recopilación generacional, disminuyendo la sobrecarga de CPU y manteniendo las pausas al mínimo.

// Enable in Java 21+:
// java -XX:+UseZGC -XX:+ZGenerational -Xmx8g MyApp

Equilibrio entre tiempo de pausa del GC y rendimiento

Ningún algoritmo de GC es el mejor en todos los aspectos. Parallel GC maximiza el rendimiento. G1 equilibra el rendimiento y la latencia. ZGC/Shenandoah minimizan las pausas con un pequeño coste de rendimiento.

Habilitar el registro del GC

Registre los eventos del GC con -Xlog:gc*:file=gc.log:time,uptime,level. Analice los registros con herramientas como GCViewer o GCEasy para encontrar pausas largas y picos de asignación.

// JVM flags:
// -Xlog:gc*:file=gc.log:time,uptime,level,tags
// Inspect logs:
// cat gc.log | grep "Pause"

Supervisar el GC con métricas de la JVM

Utilice ManagementFactory.getGarbageCollectorMXBeans() para leer mediante programación el número y el tiempo de los GC, o expórtelos a Prometheus mediante Micrometer en aplicaciones Spring Boot.

ManagementFactory.getGarbageCollectorMXBeans().forEach(gc ->
    System.out.printf("%s: %d collections, %d ms%n",
        gc.getName(), gc.getCollectionCount(), gc.getCollectionTime()));

Comprobación rápida

¿Qué algoritmo de GC tiene como objetivo conseguir pausas inferiores a un milisegundo en producción?

Resumen

Serial GC para heaps diminutos, Parallel GC para el rendimiento en procesos por lotes, G1 para cargas equilibradas (predeterminado) y ZGC/Shenandoah para una latencia ultrabaja. Habilite el registro del GC en producción para detectar los problemas pronto.

Preguntas frecuentes

¿La lección «Algoritmos de GC: Serial, G1, ZGC y Shenandoah» es gratis?

Sí — el texto completo de «Algoritmos de GC: Serial, G1, ZGC y Shenandoah» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Java Academy, actualiza a CoddyKit PRO. El curso de Java Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Algoritmos de GC: Serial, G1, ZGC y Shenandoah»?

Compare las características de las pausas del GC y las ventajas y desventajas del rendimiento de los collectors modernos de la JVM. Practicas Java Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Java Academy?

No se requiere experiencia previa. Java Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.

¿Cuánto tiempo toma la lección «Algoritmos de GC: Serial, G1, ZGC y Shenandoah»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Java Academy?

Sí. Cada lección de Java Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Regiones del heap de la JVM y ciclo de vida de los objetos
  2. Algoritmos de GC: Serial, G1, ZGC y Shenandoah
  3. Detección y corrección de fugas de memoria
  4. Indicadores de ajuste del GC y creación de perfiles con JVisualVM
← Volver a Java Academy