0Pricing
Java Academy · Lektion

GC-Algorithmen: Serial, G1, ZGC, Shenandoah

Vergleichen Sie die Eigenschaften von GC-Pausen und die Abwägungen beim Durchsatz moderner JVM-Garbage-Collector.

GC-Algorithmen: Serial, G1, ZGC, Shenandoah ist eine kostenlose Java Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Java Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.

Einen GC-Algorithmus auswählen

Die JVM enthält mehrere GC-Algorithmen, die jeweils für unterschiedliche Workloads optimiert sind. Die richtige Wahl hängt von der Heap-Größe, den Latenzanforderungen und den gewünschten Durchsatzzielen ab.

// 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 verwendet einen einzigen Thread für die Speicherbereinigung. Während der GC werden alle Anwendungsthreads angehalten („Stop-the-World“). Dieser Collector eignet sich nur für kleine Heaps oder Umgebungen mit einer CPU, etwa eingebettete Systeme.

// 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 verwendet mehrere Threads für Minor und Major GC. Die Stop-the-World-Pausen sind kürzer als bei Serial, aber weiterhin deutlich spürbar. Er eignet sich am besten für die Stapelverarbeitung, bei der der Durchsatz wichtiger ist als die Latenz.

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

G1 GC (Garbage-First)

G1 teilt den Heap in gleich große Regionen auf, etwa 2 KB bis 32 MB. Zuerst werden die Regionen mit dem meisten Garbage eingesammelt, wobei ein konfigurierbares Pausenziel eingehalten wird. Seit Java 9 ist G1 der Standard.

// 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-Regionstypen

G1-Regionen werden dynamisch als Eden-, Survivor-, Old- oder Humongous-Regionen zugewiesen. Humongous-Regionen sind für große Objekte vorgesehen, die mehr als 50 % der Regionsgröße belegen. Diese Flexibilität ermöglicht eine inkrementelle Speicherbereinigung.

ZGC (Z Garbage Collector)

ZGC führt den größten Teil seiner Arbeit gleichzeitig mit der Anwendung aus. Die Pausenzeiten liegen unabhängig von der Heap-Größe typischerweise unter 1 ms. Seit Java 15 ist ZGC produktionsreif.

// 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

Auch Shenandoah von Red Hat erreicht durch gleichzeitige Kompaktierung Pausen von unter einer Millisekunde. Shenandoah ist in OpenJDK-Builds verfügbar. Die Ziele ähneln denen von ZGC, die internen Algorithmen unterscheiden sich jedoch.

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

Generational ZGC (Java 21+)

Java 21 führte Generational ZGC ein. Dabei wird der Ansatz von ZGC mit kurzen Pausen mit einer generationsbasierten Speicherbereinigung kombiniert. Das reduziert den CPU-Overhead bei weiterhin minimalen Pausen.

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

Abwägung zwischen GC-Pausenzeit und Durchsatz

Kein GC-Algorithmus ist in allen Bereichen optimal. Parallel GC maximiert den Durchsatz. G1 schafft ein Gleichgewicht zwischen Durchsatz und Latenz. ZGC und Shenandoah minimieren die Pausen bei geringfügigen Einbußen beim Durchsatz.

GC-Protokollierung aktivieren

Protokollieren Sie GC-Ereignisse mit -Xlog:gc*:file=gc.log:time,uptime,level. Analysieren Sie die Protokolle mit Tools wie GCViewer oder GCEasy, um lange Pausen und Spitzen bei der Speicherzuweisung zu finden.

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

GC mit JVM-Metriken überwachen

Verwenden Sie ManagementFactory.getGarbageCollectorMXBeans(), um die Anzahl und Dauer von GCs programmgesteuert auszulesen, oder exportieren Sie diese Werte in Spring-Boot-Anwendungen über Micrometer nach Prometheus.

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

Kurzer Test

Welcher GC-Algorithmus zielt in der Produktion auf Pausenzeiten von unter einer Millisekunde?

Zusammenfassung

Serial GC eignet sich für winzige Heaps, Parallel GC für hohen Durchsatz bei der Stapelverarbeitung, G1 für ausgewogene Workloads als Standard und ZGC beziehungsweise Shenandoah für extrem niedrige Latenzen. Aktivieren Sie die GC-Protokollierung in der Produktion, um Probleme frühzeitig zu erkennen.

Häufig gestellte Fragen

Ist die Lektion „GC-Algorithmen: Serial, G1, ZGC, Shenandoah“ kostenlos?

Ja — der vollständige Text von „GC-Algorithmen: Serial, G1, ZGC, Shenandoah“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Java Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „GC-Algorithmen: Serial, G1, ZGC, Shenandoah“?

Vergleichen Sie die Eigenschaften von GC-Pausen und die Abwägungen beim Durchsatz moderner JVM-Garbage-Collector. Du übst Java Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Java Academy zu starten?

Keine Vorkenntnisse erforderlich. Java Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.

Wie lange dauert die Lektion „GC-Algorithmen: Serial, G1, ZGC, Shenandoah“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Java Academy-Lektion Code schreiben und ausführen?

Ja. Jede Java Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. JVM-Heap-Bereiche und Objektlebenszyklus
  2. GC-Algorithmen: Serial, G1, ZGC, Shenandoah
  3. Speicherlecks erkennen und beheben
  4. GC-Tuning-Flags und JVisualVM-Profiling
← Zurück zu Java Academy