Java Memory Leaks: Detection, Heap Dumps & Eclipse MAT Analysis

# 1. Find the JVM process id
jps -lv

# 2. Print heap summary — look for rising old-gen occupancy
jcmd <pid> GC.heap_info

# 3. Class histogram — shows live object counts and bytes per class
# Run this 3-5 minutes apart and diff the outputs
jcmd <pid> GC.class_histogram | head -30

# 4. Trigger a GC and then print histogram (removes short-lived objects first)
jcmd <pid> GC.run
jcmd <pid> GC.class_histogram | head -30

# 5. Watch heap usage over time with jstat (1-second intervals, 60 readings)
jstat -gcutil <pid> 1000 60
# Columns: S0 S1 E(den) O(ld) M(etaspace) YGC YGCT FGC FGCT GCT

# Option 1: jmap — live process dump (safe for production; brief STW on large heaps)
jmap -dump:format=b,file=heap.hprof <pid>

# Option 2: jcmd (preferred — same result, more features)
jcmd <pid> GC.heap_dump /tmp/heap.hprof

# Option 3: Automatic on OOM — add to JVM flags at startup
java -XX:+HeapDumpOnOutOfMemoryError \
     -XX:HeapDumpPath=/var/dumps/ \
     -jar app.jar

# Enable GC logging (add to startup flags)
java -Xlog:gc*:file=/var/log/app/gc.log:time,uptime,level,tags:filecount=5,filesize=20m \
     -jar app.jar

# G1GC log — look at heap occupancy after GC (the "after" value climbing across cycles)
[2.345s][info][gc] GC(12) Pause Full (Ergonomics)
[2.347s][info][gc,heap] GC(12)   Old regions: 820->790   # ← old-gen barely drops
[2.347s][info][gc] GC(12) Pause Full (Ergonomics) 3278M->3260M(4096M) 2.131ms

# Leak confirmed: old-gen does not recover meaningfully after full GC
# Same pattern 10 minutes later:
[620s][info][gc] GC(89) Pause Full (Ergonomics) 3950M->3900M(4096M) 4.892ms
# Heap before and after are both much higher → objects are accumulating

# Download and run MAT (headless mode for CI/large heaps)
./ParseHeapDump.sh heap.hprof org.eclipse.mat.api:suspects org.eclipse.mat.api:overview

# The above generates an HTML report with the Leak Suspects analysis

// ❌ LEAK: static cache grows forever, entries never removed
public class UserCache {
    private static final Map<Long, User> CACHE = new HashMap<>();

    public static void put(Long id, User user) {
        CACHE.put(id, user);          // no eviction — leak
    }
}

// ✅ FIX: bounded cache with automatic eviction (Caffeine)
public class UserCache {
    private static final Cache<Long, User> CACHE = Caffeine.newBuilder()
            .maximumSize(10_000)
            .expireAfterWrite(10, TimeUnit.MINUTES)
            .build();

    public static void put(Long id, User user) {
        CACHE.put(id, user);          // evicts oldest when full
    }
}

// ❌ LEAK: ThreadLocal set in request but never removed
// Thread returns to pool carrying the old value
public class RequestContext {
    private static final ThreadLocal<String> TENANT = new ThreadLocal<>();

    public static void set(String tenantId) {
        TENANT.set(tenantId);
    }

    public static String get() {
        return TENANT.get();
    }
}

// ✅ FIX: always remove in a finally block (or use a Filter/Interceptor)
public class RequestFilter implements Filter {
    @Override
    public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain)
            throws IOException, ServletException {
        try {
            RequestContext.set(req.getParameter("X-Tenant-Id"));
            chain.doFilter(req, res);
        } finally {
            RequestContext.remove();     // critical — prevents leak in thread pools
        }
    }
}

// ❌ LEAK: listener registered but never removed
public class EventService {
    private final List<EventListener> listeners = new ArrayList<>();

    public void register(EventListener listener) {
        listeners.add(listener);         // strong reference, never cleared
    }
}

// ✅ FIX: store weak references so listeners can be GCd when no longer used
public class EventService {
    private final List<WeakReference<EventListener>> listeners = new CopyOnWriteArrayList<>();

    public void register(EventListener listener) {
        listeners.add(new WeakReference<>(listener));
    }

    public void dispatch(Event event) {
        listeners.removeIf(ref -> {
            EventListener l = ref.get();
            if (l == null) return true;  // GCd — prune
            l.onEvent(event);
            return false;
        });
    }
}