1. Generating Heap Dumps

Programmatic Heap Dump Generation

// HeapDumpGenerator.java import com.sun.management.HotSpotDiagnosticMXBean; import javax.management.MBeanServer; import java.lang.management.ManagementFactory; import java.io.File; import java.io.IOException; import java.lang.reflect.Method; import java.text.SimpleDateFormat; import java.util.Date; public class HeapDumpGenerator { private static final String HOTSPOT_BEAN_NAME = "com.sun.management:type=HotSpotDiagnostic"; private static volatile HotSpotDiagnosticMXBean hotspotMBean; public static void generateHeapDump(String fileName, boolean live) { try { if (hotspotMBean == null) { synchronized (HeapDumpGenerator.class) { if (hotspotMBean == null) { hotspotMBean = getHotSpotDiagnosticMXBean(); } } } File file = new File(fileName); if (file.exists()) { file.delete(); } hotspotMBean.dumpHeap(fileName, live); System.out.println("Heap dump generated: " + fileName); } catch (IOException e) { throw new RuntimeException("Failed to generate heap dump: " + fileName, e); } } private static HotSpotDiagnosticMXBean getHotSpotDiagnosticMXBean() { try { MBeanServer server = ManagementFactory.getPlatformMBeanServer(); HotSpotDiagnosticMXBean bean = ManagementFactory.newPlatformMXBeanProxy( server, HOTSPOT_BEAN_NAME, HotSpotDiagnosticMXBean.class); return bean; } catch (IOException e) { throw new RuntimeException("Failed to get HotSpot Diagnostic MXBean", e); } } public static String generateHeapDumpWithTimestamp(boolean live) { String timestamp = new SimpleDateFormat("yyyyMMdd-HHmmss").format(new Date()); String fileName = "heapdump-" + timestamp + (live ? "-live" : "") + ".hprof"; generateHeapDump(fileName, live); return fileName; } // Alternative method using JMX public static void triggerHeapDumpViaJMX() { try { String name = ManagementFactory.getRuntimeMXBean().getName(); String pid = name.split("@")[0]; // Using jmap equivalent via JMX MBeanServer mbs = ManagementFactory.getPlatformMBeanServer(); ObjectName on = new ObjectName("com.sun.management:type=DiagnosticCommand"); String operation = "gcClassHistogram"; Object[] params = new Object[] { new String[] { "-all" } }; String[] signature = new String[] { String[].class.getName() }; Object result = mbs.invoke(on, operation, params, signature); System.out.println("GC Class Histogram:\n" + result); } catch (Exception e) { e.printStackTrace(); } } }

JVM Options for Heap Dump Generation

// JVMOptionsExamples.java public class JVMOptionsExamples { /* Common JVM options for heap dump analysis: -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=./heapdumps/ -XX:+PrintGCDetails -XX:+PrintGCTimeStamps -Xloggc:./logs/gc.log -XX:+UseG1GC -Xmx512m -Xms256m For continuous monitoring: -XX:+HeapDumpBeforeFullGC -XX:+HeapDumpAfterFullGC For specific events: -XX:OnOutOfMemoryError="jmap -dump:format=b,file=heapdump.hprof %p" */ }

2. Memory Leak Examples

Common Memory Leak Patterns

// MemoryLeakExamples.java import java.util.*; import java.util.concurrent.ConcurrentHashMap; public class MemoryLeakExamples { // Example 1: Static collections causing memory leaks private static final Map<String, Object> STATIC_CACHE = new HashMap<>(); private static final List<byte[]> STATIC_DATA = new ArrayList<>(); public static void addToStaticCache(String key, Object value) { STATIC_CACHE.put(key, value); } public static void loadLargeData() { for (int i = 0; i < 1000; i++) { STATIC_DATA.add(new byte[1024 * 1024]); // 1MB each } } // Example 2: Unclosed resources public static class ResourceHolder { private byte[] data = new byte[1024 * 1024]; // 1MB public void close() { // Simulate resource cleanup data = null; } } private static final List<ResourceHolder> LEAKING_RESOURCES = new ArrayList<>(); public static void createLeakingResources() { for (int i = 0; i < 100; i++) { ResourceHolder holder = new ResourceHolder(); LEAKING_RESOURCES.add(holder); // Forgot to call holder.close() } } // Example 3: Listeners and callbacks public static class EventManager { private final List<Runnable> listeners = new ArrayList<>(); public void addListener(Runnable listener) { listeners.add(listener); } // Missing removeListener method } // Example 4: ThreadLocal misuse private static final ThreadLocal<byte[]> THREAD_LOCAL_DATA = ThreadLocal.withInitial(() -> new byte[1024 * 1024]); // 1MB per thread public static void useThreadLocal() { byte[] data = THREAD_LOCAL_DATA.get(); // Data remains until thread dies or ThreadLocal is cleared } // Example 5: String intern misuse public static void internAllStrings() { List<String> internedStrings = new ArrayList<>(); for (int i = 0; i < 10000; i++) { String str = new String("String_" + i); internedStrings.add(str.intern()); // Goes to PermGen/Metaspace } } } // Example 6: Classloader leak public class ClassloaderLeakExample { private static final Map<String, Class<?>> CLASS_CACHE = new ConcurrentHashMap<>(); public static class LeakingClassloader extends ClassLoader { public Class<?> defineAndCacheClass(String name, byte[] bytecode) { Class<?> clazz = defineClass(name, bytecode, 0, bytecode.length); CLASS_CACHE.put(name, clazz); return clazz; } } } // Example 7: Cache without eviction public class InfiniteCache<K, V> { private final Map<K, V> cache = new HashMap<>(); public void put(K key, V value) { cache.put(key, value); // No eviction policy - grows indefinitely } public V get(K key) { return cache.get(key); } }

3. Memory Analysis Utilities

// MemoryAnalysisUtils.java import java.lang.management.*; import java.util.*; public class MemoryAnalysisUtils { public static void printMemoryStats() { MemoryMXBean memoryMXBean = ManagementFactory.getMemoryMXBean(); MemoryUsage heapUsage = memoryMXBean.getHeapMemoryUsage(); MemoryUsage nonHeapUsage = memoryMXBean.getNonHeapMemoryUsage(); System.out.println("=== Heap Memory Usage ==="); System.out.printf("Init: %,d bytes%n", heapUsage.getInit()); System.out.printf("Used: %,d bytes%n", heapUsage.getUsed()); System.out.printf("Committed: %,d bytes%n", heapUsage.getCommitted()); System.out.printf("Max: %,d bytes%n", heapUsage.getMax()); System.out.println("=== Non-Heap Memory Usage ==="); System.out.printf("Init: %,d bytes%n", nonHeapUsage.getInit()); System.out.printf("Used: %,d bytes%n", nonHeapUsage.getUsed()); System.out.printf("Committed: %,d bytes%n", nonHeapUsage.getCommitted()); System.out.printf("Max: %,d bytes%n", nonHeapUsage.getMax()); // Print garbage collector information List<GarbageCollectorMXBean> gcBeans = ManagementFactory.getGarbageCollectorMXBeans(); for (GarbageCollectorMXBean gcBean : gcBeans) { System.out.printf("GC: %s - Collections: %,d, Time: %,d ms%n", gcBean.getName(), gcBean.getCollectionCount(), gcBean.getCollectionTime()); } } public static void printClassLoadingStats() { ClassLoadingMXBean classLoadingMXBean = ManagementFactory.getClassLoadingMXBean(); System.out.println("=== Class Loading Stats ==="); System.out.printf("Loaded: %,d classes%n", classLoadingMXBean.getLoadedClassCount()); System.out.printf("Total Loaded: %,d classes%n", classLoadingMXBean.getTotalLoadedClassCount()); System.out.printf("Unloaded: %,d classes%n", classLoadingMXBean.getUnloadedClassCount()); } public static void printThreadStats() { ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean(); System.out.println("=== Thread Stats ==="); System.out.printf("Thread Count: %d%n", threadMXBean.getThreadCount()); System.out.printf("Peak Thread Count: %d%n", threadMXBean.getPeakThreadCount()); System.out.printf("Total Started Threads: %d%n", threadMXBean.getTotalStartedThreadCount()); // Print thread details long[] threadIds = threadMXBean.getAllThreadIds(); for (long threadId : threadIds) { ThreadInfo threadInfo = threadMXBean.getThreadInfo(threadId); if (threadInfo != null) { System.out.printf("Thread: %s - State: %s%n", threadInfo.getThreadName(), threadInfo.getThreadState()); } } } public static void forceGarbageCollection() { System.gc(); System.out.println("Garbage collection requested"); } public static void createMemoryPressure() { System.out.println("Creating memory pressure..."); List<byte[]> memoryHog = new ArrayList<>(); try { for (int i = 0; i < 100; i++) { memoryHog.add(new byte[1024 * 1024]); // 1MB chunks Thread.sleep(10); } } catch (OutOfMemoryError e) { System.out.println("OutOfMemoryError triggered!"); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } finally { memoryHog.clear(); forceGarbageCollection(); } } }

4. MAT Analysis Queries and Patterns

// MATAnalysisPatterns.java public class MATAnalysisPatterns { /* Common MAT Analysis Patterns: 1. Dominator Tree Analysis: - Identify which objects retain the most memory - Look for unexpected large object retention 2. Histogram by Class: - Group objects by class and see total memory usage - Identify classes with too many instances 3. Leak Suspects Report: - MAT's automated leak detection - Shows potential memory leak suspects 4. Path to GC Roots: - Find why objects aren't being garbage collected - Exclude weak/soft/phantom references 5. OQL (Object Query Language) Examples: */ // Common OQL Queries: String[] oqlQueries = { // Find all instances of a specific class "SELECT * FROM com.example.YourClass", // Find objects retaining more than 1MB "SELECT * FROM java.lang.Object WHERE @retainedHeapSize > 1000000", // Find arrays larger than specific size "SELECT * FROM byte[] WHERE @retainedHeapSize > 1048576", // Find String objects with specific content "SELECT * FROM java.lang.String s WHERE s.toString().startsWith('ERROR')", // Find collections with many elements "SELECT * FROM java.util.ArrayList WHERE elementData.@length > 1000", // Find duplicate strings "SELECT s.toString() FROM java.lang.String s GROUP BY s.toString() HAVING COUNT(*) > 1", // Find objects by package "SELECT * FROM INSTANCEOF com.yourpackage.*" }; } // MAT Report Interpretation Guide class MATReportGuide { /* Key MAT Reports and Their Meaning: 1. Overview Report: - Total heap size - Number of objects - Biggest objects by retained size 2. Histogram: - Objects grouped by class - Shallow vs retained size - Look for unexpected large counts 3. Dominator Tree: - Objects that retain large portions of heap - Identify memory ownership hierarchy 4. Top Consumers: - Packages/classes using most memory - Helps identify problematic areas 5. Duplicate Classes: - Multiple versions of same class - Indicates classloader issues */ }

5. Automated Heap Analysis

// AutomatedHeapAnalyzer.java import java.io.*; import java.nio.file.*; import java.util.*; import java.util.concurrent.*; public class AutomatedHeapAnalyzer { private final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1); private final String outputDirectory; public AutomatedHeapAnalyzer(String outputDirectory) { this.outputDirectory = outputDirectory; createOutputDirectory(); } public void startPeriodicHeapDumps(long interval, TimeUnit unit) { scheduler.scheduleAtFixedRate(this::generateHeapDump, 0, interval, unit); } public void stop() { scheduler.shutdown(); } private void generateHeapDump() { try { String timestamp = new SimpleDateFormat("yyyyMMdd-HHmmss").format(new Date()); String fileName = outputDirectory + "/heapdump-" + timestamp + ".hprof"; HeapDumpGenerator.generateHeapDump(fileName, true); // Analyze basic metrics analyzeHeapDumpMetrics(fileName); } catch (Exception e) { System.err.println("Error generating heap dump: " + e.getMessage()); } } private void analyzeHeapDumpMetrics(String fileName) { // Basic file analysis without full MAT integration File file = new File(fileName); if (file.exists()) { System.out.printf("Heap dump created: %s (%,d bytes)%n", fileName, file.length()); } } private void createOutputDirectory() { try { Files.createDirectories(Paths.get(outputDirectory)); } catch (IOException e) { throw new RuntimeException("Failed to create output directory: " + outputDirectory, e); } } public static void monitorMemoryUsage() { Timer timer = new Timer(true); timer.scheduleAtFixedRate(new TimerTask() { @Override public void run() { MemoryMXBean memoryMXBean = ManagementFactory.getMemoryMXBean(); MemoryUsage heapUsage = memoryMXBean.getHeapMemoryUsage(); double usagePercent = (double) heapUsage.getUsed() / heapUsage.getCommitted() * 100; System.out.printf("Memory Usage: %.2f%% (%,d/%,d bytes)%n", usagePercent, heapUsage.getUsed(), heapUsage.getCommitted()); // Trigger heap dump if usage is high if (usagePercent > 80.0) { System.out.println("High memory usage detected, generating heap dump..."); HeapDumpGenerator.generateHeapDumpWithTimestamp(true); } } }, 0, 30000); // Check every 30 seconds } }

6. Example Application with Memory Issues

// LeakyApplication.java import java.util.*; import java.util.concurrent.*; public class LeakyApplication { private final Map<String, List<byte[]>> userSessions = new ConcurrentHashMap<>(); private final EventBus eventBus = new EventBus(); private final CacheManager cacheManager = new CacheManager(); public static void main(String[] args) throws InterruptedException { LeakyApplication app = new LeakyApplication(); // Start memory monitoring AutomatedHeapAnalyzer.monitorMemoryUsage(); // Generate initial heap dump HeapDumpGenerator.generateHeapDumpWithTimestamp(true); // Simulate application workload app.simulateWorkload(); // Generate final heap dump HeapDumpGenerator.generateHeapDumpWithTimestamp(true); } public void simulateWorkload() throws InterruptedException { ExecutorService executor = Executors.newFixedThreadPool(10); for (int i = 0; i < 1000; i++) { final int userId = i; executor.submit(() -> processUserRequest("user_" + userId)); if (i % 100 == 0) { Thread.sleep(100); MemoryAnalysisUtils.printMemoryStats(); } } executor.shutdown(); executor.awaitTermination(1, TimeUnit.MINUTES); } private void processUserRequest(String userId) { // Simulate memory leak: user sessions never cleaned up List<byte[]> sessionData = userSessions.computeIfAbsent(userId, k -> new ArrayList<>()); // Add some data to session sessionData.add(new byte[1024 * 50]); // 50KB per request // Register listener (potential leak) eventBus.register(new EventListener(userId)); // Cache data (potential leak) cacheManager.cacheUserData(userId, generateUserData()); } private byte[] generateUserData() { return new byte[1024 * 10]; // 10KB user data } // Inner classes that might cause leaks public class EventListener { private final String userId; private final byte[] contextData = new byte[1024 * 5]; // 5KB public EventListener(String userId) { this.userId = userId; } public void onEvent(String event) { // Event handling logic } } public static class EventBus { private final List<Object> listeners = new ArrayList<>(); public void register(Object listener) { listeners.add(listener); // Missing unregister method } } public static class CacheManager { private final Map<String, Object> cache = new ConcurrentHashMap<>(); public void cacheUserData(String userId, Object data) { cache.put(userId, data); // No eviction policy } } }

7. Analysis Script and Automation

// HeapAnalysisRunner.java import java.util.*; public class HeapAnalysisRunner { public static void main(String[] args) { System.out.println("=== Starting Heap Analysis Demo ==="); // Print initial memory stats MemoryAnalysisUtils.printMemoryStats(); MemoryAnalysisUtils.printClassLoadingStats(); // Create memory pressure to trigger interesting heap state System.out.println("\n=== Creating Memory Pressure ==="); MemoryAnalysisUtils.createMemoryPressure(); // Generate heap dump for analysis System.out.println("\n=== Generating Heap Dump ==="); String heapDumpFile = HeapDumpGenerator.generateHeapDumpWithTimestamp(true); // Print final stats System.out.println("\n=== Final Memory Stats ==="); MemoryAnalysisUtils.printMemoryStats(); MemoryAnalysisUtils.forceGarbageCollection(); System.out.println("\n=== Analysis Complete ==="); System.out.println("Heap dump file: " + heapDumpFile); System.out.println("Use Eclipse MAT to analyze the heap dump:"); System.out.println("1. Open " + heapDumpFile + " in MAT"); System.out.println("2. Run Leak Suspects Report"); System.out.println("3. Check Dominator Tree"); System.out.println("4. Analyze Histogram by Class"); } }

Key MAT Analysis Techniques:

1. Leak Suspects Report: MAT's automated leak detection
2. Dominator Tree: Identify objects retaining the most memory
3. Histogram: Group objects by class and analyze memory usage
4. Path to GC Roots: Find why objects aren't being garbage collected
5. OQL Queries: Custom queries for specific analysis needs
6. Compare Heap Dumps: Identify changes between two heap dumps

Best Practices:

1. Always take heap dumps with live=true for accurate analysis
2. Take multiple heap dumps over time to identify trends
3. Use appropriate JVM flags for automatic heap dump generation
4. Analyze both shallow and retained heap sizes
5. Look for unexpected object retention and large object arrays

This comprehensive approach will help you effectively identify and resolve memory issues in your Java applications using Eclipse MAT.