TL;DR: Different apps need different GCs. Start with G1, go ZGC/Shenandoah for ultra-low pauses, use Parallel for throughput, Serial for tiny heaps, and Epsilon for benchmarks. ⚖️ Why care? ⚡ Latency-sensitive APIs? Try ZGC (and Shenandoah if your distro ships it). 🚀 Batch/ETL? Parallel GC often wins on throughput. 🧩 Small container / single core? Serial GC is fine. 🧪 Baseline perf? Epsilon = alloc-only, zero GC. 🧠 Modern defaults: G1 balances pause time & throughput. Generational modes for ZGC/Shenandoah are now mainstream. Pro tips: 📈 Measure before tuning: -Xlog:gc*, watch P95/P99 pauses & old-gen growth. 🧰 Start with defaults, then adjust pause targets (G1) or heap size (ZGC). Curious which GC fits your workload? I summarized the what/when/why in the full post—check it out and share your context (heap size, SLA, traffic)! 👇 #Java #JVM #GarbageCollection #G1 #ZGC #Shenandoah #Performance #LowLatency #Throughput #Java25 #DevOps Certify: https://www.udemy.com/course/ocp-oracle-certified-professional-java-developer-prep/?referralCode=54114F9AD41F127CB99A

1. ♻🧠 JAVA GARBAGE
COLLECTORS — THE
OPTIONS, IN PLAIN ENGLISH
@vvauban 20251021

2. ⏲ TL;DR
Java has multiple GCs with different trade-offs:
● G1 is the default general-purpose GC. inside.java
● ZGC & Shenandoah focus on super-low pauses (concurrent, region-based).
Generational modes are now mainstream in recent JDKs. openjdk.org
● Parallel maximizes throughput with longer pauses.
● Serial is simple/small, OK for tiny apps.
● Epsilon does no collection (use for testing/special cases). openjdk.org
Pick based on latency vs throughput vs heap size (and your JDK vendor).

3. 🤔 HOW JAVA MEMORY & GC WORKS (QUICK VIEW)
▪ Objects start in Young Gen (Eden ➜ Survivor S0/S1).
Survivors eventually promote to Old Gen.
▪ Minor GC collects young space; Major/Old GC handles
old space; some GCs also compact to avoid
fragmentation.
▪ Metaspace holds class metadata (replaced PermGen
since Java 8).

4. 🗑 THE COLLECTORS
(WHAT, WHEN, WHY)

5. 🤏 Serial GC
▪ Single-threaded, stops the world.
▪ Good for small heaps, single-CPU or very
small container footprints.

6. 🔀 Parallel GC (Throughput)
▪ Multi-threaded stop-the-world collector for max
throughput.
▪ Accept longer pauses to keep overall work
high—common for batch jobs.

7. 🧹 CMS (Concurrent Mark-Sweep)
▪ Legacy low-pause GC (removed in modern JDKs).
Prefer G1 or low-latency GCs today.

8. 1⃣ G1 (Garbage-First)
Default GC since Java 9; balances latency & throughput on
multi-core, large heaps. inside.java
▪ Region-based, does concurrent marking and
copy/compaction to limit fragmentation.
▪ Tuning target: max pause time goal.

9. 0⃣ ZGC
▪ Ultra-low pause (≲10ms) with concurrent mark, relocate,
and compact; scales to very large heaps.
▪ Generational ZGC is the default ZGC mode in recent JDKs
(non-generational is deprecated/removed).
Use -XX:+UseZGC. openjdk.org
▪ Minimal tuning: enable it, size the heap, go.

10. 🌲 Shenandoah
▪ Low-pause concurrent GC with concurrent compaction; great for
predictable latencies.
▪ Generational Shenandoah became a product feature in JDK 25
(not just experimental). Default mode remains single-gen unless
configured. openjdk.org
▪ Note: Oracle JDK does not ship Shenandoah;
use vendors like Red Hat/Temurin/Corretto/Azul
if you need it. wiki.openjdk.org

11. ❌ Epsilon (No-Op)
▪ Alloc-only GC — performs no reclamation; JVM exits
when heap is exhausted.
▪ Useful for performance baselining, short-lived apps, or
GC-free experiments. It stays experimental on purpose.
openjdk.org

12. 󰤇 HOW TO CHOOSE (RULE OF THUMB)
▪ “I want sane defaults” → Start with G1. inside.java
▪ “I need ultra-low pause times” (APIs, trading, real-timey flows)
→ Try ZGC; consider Shenandoah if your vendor ships it.
openjdk.org+1
▪ “I maximize throughput on batch jobs” → Parallel GC.
▪ “Tiny container or single core” → Serial GC can be fine.
▪ “I’m benchmarking GC impact” → Epsilon (carefully).

13. ☝ PRACTICAL TIPS
▪ Measure first: enable GC logs (-Xlog:gc*)
and track pause P95/P99, allocation rate,
survivor promotions, old-gen growth.
▪ Start with defaults, then tune pause targets
(G1) or just heap sizing (ZGC/Shenandoah).
▪ Match vendor & version to the GC features
you need (e.g., Shenandoah availability).
wiki.openjdk.org

14. What do you use in prod—G1, ZGC, Shenandoah,
or Parallel? Why? Drop your context (heap size, SLA,
traffic) in the comments 👇
#Java #JVM #Performance #GarbageCollection #ZGC
#Shenandoah #G1 #Java25 #LowLatency #DevOps