Java Academy · Lezione

Algoritmi GC: Serial, G1, ZGC, Shenandoah

Confronti le caratteristiche delle pause del GC e i compromessi relativi al throughput tra i moderni collector della JVM.

Algoritmi GC: Serial, G1, ZGC, Shenandoah è una lezione Java Academy gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Java Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Java Academy include 4 lezioni in totale.

Scegliere un algoritmo GC

La JVM include diversi algoritmi GC, ciascuno ottimizzato per carichi di lavoro differenti. La scelta di quello giusto dipende dalle dimensioni dell'heap, dai requisiti di latenza e dagli obiettivi di throughput.

// 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 utilizza un singolo thread per la raccolta. Durante il GC, tutti i thread dell'applicazione vengono arrestati, con una pausa "stop-the-world". È adatto solo a heap di piccole dimensioni o ad ambienti con una sola CPU, come i sistemi embedded.

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

Parallel GC (Throughput Collector)

Parallel GC utilizza più thread per i Minor GC e i Major GC. Le pause stop-the-world sono più brevi rispetto a Serial, ma restano significative. È ideale per l'elaborazione batch, dove il throughput è più importante della latenza.

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

G1 GC (Garbage-First)

G1 divide l'heap in regioni di dimensioni uguali, da ~2 KB a 32 MB. Raccoglie prima le regioni con più garbage, rispettando un obiettivo di pausa configurabile. È il GC predefinito da 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

Tipi di regioni G1

Le regioni G1 vengono assegnate dinamicamente come Eden, Survivor, Old o Humongous, per gli oggetti di grandi dimensioni che superano il 50% della dimensione della regione. Questa flessibilità consente una raccolta incrementale.

ZGC (Z Garbage Collector)

ZGC esegue la maggior parte del lavoro in concorrenza con l'applicazione. I tempi di pausa sono generalmente inferiori a 1 ms, indipendentemente dalle dimensioni dell'heap. È pronto per l'uso in produzione da 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

Anche Shenandoah, sviluppato da Red Hat, raggiunge pause inferiori al millisecondo tramite la compattazione concorrente. È disponibile nelle build di OpenJDK. Ha obiettivi molto simili a ZGC, ma utilizza algoritmi interni diversi.

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

ZGC generazionale (Java 21+)

Java 21 ha introdotto ZGC generazionale, che combina l'approccio a bassa latenza di ZGC con la raccolta generazionale, riducendo il sovraccarico della CPU e mantenendo pause minime.

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

Compromesso tra tempo di pausa del GC e throughput

Nessun algoritmo GC è il migliore in ogni situazione. Parallel GC massimizza il throughput. G1 bilancia throughput e latenza. ZGC e Shenandoah riducono al minimo le pause al costo di una lieve riduzione del throughput.

Abilitare il logging del GC

Registri gli eventi del GC con -Xlog:gc*:file=gc.log:time,uptime,level. Analizzi i log con strumenti come GCViewer o GCEasy per individuare pause lunghe e picchi di allocazione.

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

Monitorare il GC con le metriche della JVM

Utilizzi ManagementFactory.getGarbageCollectorMXBeans() per leggere programmaticamente il numero e la durata dei GC, oppure li esporti in Prometheus tramite Micrometer nelle applicazioni Spring Boot.

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

Verifica rapida

Quale algoritmo GC punta a tempi di pausa inferiori al millisecondo in produzione?

Riepilogo

Serial GC è adatto a heap molto piccoli, Parallel GC al throughput dei processi batch, G1 ai carichi di lavoro bilanciati, essendo il GC predefinito, e ZGC o Shenandoah alla latenza ultrabassa. Abiliti il logging del GC in produzione per individuare tempestivamente i problemi.

Domande Frequenti

La lezione «Algoritmi GC: Serial, G1, ZGC, Shenandoah» è gratuita?

Sì — il testo completo di «Algoritmi GC: Serial, G1, ZGC, Shenandoah» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Java Academy, passa a CoddyKit PRO. Il corso Java Academy include 4 lezioni in totale.

Cosa imparerò in «Algoritmi GC: Serial, G1, ZGC, Shenandoah»?

Confronti le caratteristiche delle pause del GC e i compromessi relativi al throughput tra i moderni collector della JVM. Eserciti Java Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Java Academy?

Non è richiesta alcuna esperienza precedente. Java Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.

Quanto tempo richiede la lezione «Algoritmi GC: Serial, G1, ZGC, Shenandoah»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Java Academy?

Sì. Ogni lezione Java Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

Regioni dell'heap della JVM e ciclo di vita degli oggetti
Algoritmi GC: Serial, G1, ZGC, Shenandoah
Rilevare e correggere i memory leak
Flag per il tuning del GC e profiling con JVisualVM

← Torna a Java Academy