All 15 Garbage Collection questions
More in Garbage Collection
How does the -XX:+HeapDumpOnOutOfMemoryError flag combined with the Eclipse Memory Analyzer's 'Leak Suspects' report help quickly triage a production OutOfMemoryError, and what's the typical first thing to check in the resulting analysis? How would you use jstat to monitor GC activity and heap generation sizes for a running JVM process in real time, without needing a full profiling tool? What is the difference between a stop-the-world (STW) GC pause and a concurrent GC phase, and why can't garbage collection be made entirely concurrent with zero pauses? How do the different modern garbage collectors (G1, ZGC, Shenandoah) differ in their approach to minimizing GC pause times, and when would you choose one over the default? How does the JVM's tri-color marking algorithm (used by concurrent garbage collectors like G1) work to identify reachable objects while application threads continue running concurrently, and what problem does a write barrier solve in this context? What is escape analysis, and how does it enable the JIT compiler to perform stack allocation or scalar replacement for objects that don't actually need heap allocation, reducing GC pressure? How would you determine whether an application is spending an excessive amount of time in garbage collection (GC overhead) relative to actual application work, and what JVM flags or tools help measure and diagnose this? How does Metaspace (replacing PermGen since Java 8) store class metadata, and what specific configuration and failure modes differ from the old PermGen model?
Advertisement
Java › Garbage Collection

How would you diagnose a memory leak in a Java application (where memory usage grows unboundedly despite garbage collection running) using heap dump analysis, and what common patterns cause 'leaks' in a garbage-collected language?

Advanced

Answer

Despite automatic garbage collection, a Java application CAN still leak memory if objects remain unintentionally strongly reachable (via a reference chain the developer didn't intend to keep alive) -- common culprits include: an ever-growing static collection (like a cache implemented as a plain HashMap with no eviction policy), listener/observer registrations that are never unregistered (the 'lapsed listener' problem), ThreadLocal values not cleaned up in a pooled-thread environment (where the thread, and therefore its ThreadLocal storage, outlives the logical task that set the value), or classloader leaks in a plugin/hot-reload scenario -- diagnosing requires capturing a heap dump (via jmap, or automatically triggered on OutOfMemoryError via -XX:+HeapDumpOnOutOfMemoryError) and analyzing it with a tool like Eclipse MAT or VisualVM, specifically looking at the dominator tree and 'retained size' to identify which object(s) are unexpectedly keeping large portions of the heap alive, then tracing the GC root reference chain keeping them reachable.
# Capture a heap dump from a running JVM
jmap -dump:live,format=b,file=heapdump.hprof <pid>

# Automatically capture a heap dump on OutOfMemoryError
java -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=/tmp/heapdump.hprof -jar app.jar

# Then analyze heapdump.hprof with Eclipse Memory Analyzer (MAT),
# looking specifically at the 'Leak Suspects' report and dominator tree
Real-world example A team investigating steadily climbing memory usage in a long-running service captures a heap dump and, using Eclipse MAT's dominator tree view, discovers an unbounded static Map being used as an ad-hoc cache with entries added on every request but never evicted, tracing the specific code path responsible and adding a proper eviction policy (or switching to a bounded cache implementation) to resolve the leak.

Common follow-ups: Why can a memory leak still occur in a garbage-collected language despite the GC running correctly and doing exactly what it's designed to do?;What's the specific danger of ThreadLocal usage combined with a thread pool that reuses threads across many logical tasks?

Diagnostics & Performance;Concurrency & Threads
All 15 Garbage Collection questions