Java Academy · Lektion

GC-algoritmer: Serial, G1, ZGC, Shenandoah

Sammenlign pauser og afvejninger mellem gennemstrømning for moderne JVM garbage collectors.

Lektion 2 af 413 trin

GC-algoritmer: Serial, G1, ZGC, Shenandoah er en gratis Java Academy-lektion på CoddyKit. Dette er lektion 2 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i Java Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Java Academy-kurset indeholder 4 lektioner i alt.

Valg af GC-algoritme

JVM'en leveres med flere GC-algoritmer, som hver især er optimeret til forskellige arbejdsbelastninger. Valget af den rigtige afhænger af heapstørrelsen, kravene til latenstid og målene for gennemløb.

// 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 bruger én tråd til indsamlingen. Alle programtråde stopper under GC. Den egner sig kun til små heaps eller miljøer med én CPU, f.eks. indlejrede systemer.

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

Parallel GC (gennemløbssamler)

Parallel GC bruger flere tråde til mindre og større GC-kørsler. Pauserne, hvor hele programmet stopper, er kortere end med Serial, men stadig betydelige. Den er bedst til batchbehandling, hvor gennemløb er vigtigere end latenstid.

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

G1 GC (Garbage-First)

G1 opdeler heapen i regioner af samme størrelse (~2 KB – 32 MB). Den indsamler først de regioner, der indeholder mest affald, og overholder et konfigurerbart paus mål. Den er standard siden 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

G1-regionstyper

G1-regioner tildeles dynamisk som Eden-, Survivor-, Old- eller Humongous-regioner, hvor de sidste bruges til store objekter på over 50 % af regionstørrelsen. Denne fleksibilitet muliggør trinvis indsamling.

ZGC (Z-affaldsopsamleren)

ZGC udfører det meste af arbejdet samtidig med applikationen. Pauserne er typisk under 1 ms uanset heapstørrelsen. Den har været produktionsklar siden 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 fra Red Hat opnår også pauser på under ét millisekund gennem samtidig komprimering. Den findes i OpenJDK-builds. Målet ligner ZGC's meget, men de interne algoritmer er forskellige.

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

Generationsopdelt ZGC (Java 21+)

Java 21 introducerede generationsopdelt ZGC, som kombinerer ZGC's tilgang med korte pauser med generationsopdelt indsamling. Det reducerer CPU-overheadet, samtidig med at pauserne forbliver minimale.

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

Afvejning mellem GC-pauser og gennemløb

Ingen GC-algoritme er bedst til alt. Parallel GC maksimerer gennemløbet. G1 afbalancerer gennemløb og latenstid. ZGC og Shenandoah minimerer pauserne med en mindre omkostning i gennemløb.

Aktivér GC-logning

Logfør GC-hændelser med -Xlog:gc*:file=gc.log:time,uptime,level. Analysér logfiler med værktøjer som GCViewer eller GCEasy for at finde lange pauser og pludselige stigninger i allokeringen.

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

Overvåg GC med JVM-målinger

Brug ManagementFactory.getGarbageCollectorMXBeans() til programmatisk at aflæse antallet af GC-kørsler og deres varighed, eller eksportér dem til Prometheus via Micrometer i Spring Boot-applikationer.

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

Hurtigt tjek

Hvilken GC-algoritme sigter mod pauser på under ét millisekund i produktion?

Besvar den i den interaktive lektion

Opsummering

Serial GC er til meget små heaps, Parallel GC til batchgennemløb, G1 til afbalancerede arbejdsbelastninger og er standard, mens ZGC og Shenandoah er til ultralav latenstid. Aktivér GC-logning i produktion for at opdage problemer tidligt.

Gratis at komme i gang

Lær Java med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 104
Lektioner: 374

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “GC-algoritmer: Serial, G1, ZGC, Shenandoah” gratis?

Ja — hele teksten til “GC-algoritmer: Serial, G1, ZGC, Shenandoah” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af Java Academy-kurset, skal du opgradere til CoddyKit PRO. Java Academy-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “GC-algoritmer: Serial, G1, ZGC, Shenandoah”?

Sammenlign pauser og afvejninger mellem gennemstrømning for moderne JVM garbage collectors. Du øver dig i Java Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på Java Academy?

Der kræves ingen tidligere erfaring. Java Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 2 af 4.

Hvor lang tid tager lektionen “GC-algoritmer: Serial, G1, ZGC, Shenandoah”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne Java Academy-lektion?

Ja. Alle Java Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

JVM-heapområder og objekters livscyklus
GC-algoritmer: Serial, G1, ZGC, Shenandoah
Registrering og udbedring af memory leaks
GC-tuning-flags og JVisualVM-profilering

← Tilbage til Java Academy