JVM.GC.Explain the different garbage collection algorithms used by the JVM (e.g., Serial, Parallel, CMS, G1).

Garbage Collection Algorithms in the JVM

The JVM provides multiple Garbage Collection (GC) algorithms to efficiently manage heap memory by reclaiming space from objects that are no longer needed.


1️⃣ Serial Garbage Collector

Algorithm

  • Uses a single thread for both minor and major garbage collection.
  • Stops the world (pauses all application threads) during GC.
  • Uses a copying algorithm in the Young Generation (objects moved from Eden to Survivor spaces).
  • Uses Mark-Sweep-Compact in the Old Generation.

Best For

✔ Single-threaded applications.
✔ Small applications (e.g., desktop apps).

Drawbacks

❌ Long GC pauses (not suitable for multi-threaded applications).

Enable With

-XX:+UseSerialGC

2️⃣ Parallel Garbage Collector (Throughput GC)

Algorithm

  • Uses multiple threads to speed up garbage collection.
  • Still stops the world during GC, but performs GC in parallel.
  • Uses copying collection for Young Generation and Mark-Sweep-Compact for Old Generation.

Best For

✔ Multi-threaded applications that prioritize throughput over low-latency.
✔ Applications running on multi-core machines.

Drawbacks

❌ Still has full GC pauses, which may not be ideal for low-latency applications.

Enable With

-XX:+UseParallelGC

3️⃣ Concurrent Mark-Sweep (CMS) Garbage Collector

Algorithm

  • Reduces GC pause times by performing most work concurrently with application threads.
  • Uses a Mark-Sweep algorithm for the Old Generation (no compacting step).
  • Phases:
    1. Initial Mark – Identifies root references (Stop-the-world pause).
    2. Concurrent Mark – Finds reachable objects concurrently.
    3. Remark – Handles objects missed in concurrent marking (Stop-the-world pause).
    4. Concurrent Sweep – Frees unreachable objects concurrently.

Best For

✔ Low-latency applications (e.g., financial systems, real-time applications).

Drawbacks

❌ Can cause fragmentation (no compaction step).
❌ Uses more CPU than other collectors.

Enable With

-XX:+UseConcMarkSweepGC

Deprecated from Java 9 and removed in Java 14. Use G1GC or ZGC instead.

4️⃣ Garbage First (G1) Garbage Collector

Algorithm

  • Divides heap into regions (instead of separate generations).
  • Uses a priority-based approach (focuses on regions with most garbage).
  • Performs mostly concurrent collection with shorter pauses.
  • Includes compaction step (avoids fragmentation).

Phases:

  1. Young GC – Collects Eden and Survivor spaces.
  2. Mixed GC – Collects both Young and Old generations.
  3. Full GC (rare) – Stops the world if necessary.

Best For

✔ Large heap applications (e.g., microservices, enterprise applications).
Balanced performance (good throughput with low GC pause times).

Drawbacks

❌ Slightly higher CPU overhead than Parallel GC.

Enable With

-XX:+UseG1GC

Default GC since Java 9.

5️⃣ Z Garbage Collector (ZGC)

Algorithm

  • Ultra-low latency collector.
  • Performs most of the GC work concurrently (without stopping the application).
  • Only short Stop-the-world pauses (few milliseconds).
  • Uses region-based allocation similar to G1 but focuses on concurrent compaction.

Best For

✔ Applications that require very low latency (sub-10ms GC pauses).
✔ Large heaps (supports up to 16TB of heap).

Drawbacks

❌ Higher CPU overhead compared to G1.
Not ideal for small heaps (<4GB).

Enable With

-XX:+UseZGC

Available since Java 11, stable from Java 15.


6️⃣ Shenandoah Garbage Collector

Algorithm

  • Another low-latency GC, like ZGC.
  • Performs concurrent compaction, preventing fragmentation.
  • Pause times are independent of heap size.

Best For

✔ Real-time systems where consistent low pause times are critical.

Drawbacks

❌ High CPU usage.
❌ Not the best for throughput-focused applications.

Enable With

-XX:+UseShenandoahGC

Introduced in Java 12, stable in Java 15.


7️⃣ Epsilon Garbage Collector (No GC)

Algorithm

  • Does nothing (no garbage collection).
  • Objects keep accumulating until memory runs out.

Best For

✔ Performance testing and benchmarking.
✔ Environments where manual memory management is used.

Drawbacks

Will run out of memory if objects are not explicitly managed.

Enable With

-XX:+UseEpsilonGC

Introduced in Java 11.


Comparison Table of GC Algorithms

GC TypeAlgorithmPause TimeBest ForEnable With
Serial GCSingle-threaded, Stop-the-worldHighSmall applications-XX:+UseSerialGC
Parallel GCMulti-threaded Stop-the-worldHighHigh throughput-XX:+UseParallelGC
CMS GCConcurrent Mark-SweepLowLow-latency apps (deprecated)-XX:+UseConcMarkSweepGC
G1 GCRegion-based, concurrentMediumLarge apps with balanced performance-XX:+UseG1GC
ZGCFully concurrent, region-basedVery LowLarge heaps, low-latency apps-XX:+UseZGC
Shenandoah GCConcurrent compactionVery LowReal-time, consistent low pauses-XX:+UseShenandoahGC
Epsilon GCNo garbage collectionNoneTesting, benchmarking-XX:+UseEpsilonGC

Conclusion

  • Serial GC – Simple, good for small applications.
  • Parallel GC – High throughput, good for batch processing.
  • CMS GC – Low-latency, deprecated (use G1 instead).
  • G1 GC – Balanced, default since Java 9.
  • ZGC – Ultra-low-latency, great for large heaps.
  • Shenandoah GC – Low-latency, alternative to ZGC.
  • Epsilon GC – No GC, for testing purposes.

For modern applications, G1GC is the default choice, while ZGC and Shenandoah are best for low-latency systems. 🚀

This entry was posted in Без рубрики. Bookmark the permalink.