Java Memory Management

Java Memory Management is a crucial aspect of the Java Runtime Environment (JRE) that handles memory allocation and deallocation automatically through garbage collection.

1. Java Memory Structure

JVM Memory Areas

Java Memory Structure: ┌─────────────────────────────────────────────────────────────┐ │ JVM Memory │ ├─────────────────────────────────────────────────────────────┤ │ ┌─────────────┐ ┌─────────────┐ ┌─────────────────────┐ │ │ │ Method │ │ Heap │ │ Stack │ │ │ │ Area │ │ │ │ │ │ │ ├─────────────┤ ├─────────────┤ ├─────────────────────┤ │ │ │ Class │ │ Young Gen │ │ Thread 1 Stack │ │ │ │ Structures │ │ ┌─────┐ │ │ ┌─────────────────┐ │ │ │ │ Runtime │ │ │Eden │ │ │ │ Stack Frames │ │ │ │ │ Constant │ │ └─────┘ │ │ │ Local Variables │ │ │ │ │ Pool │ │ ┌─────┐ │ │ │ Operand Stack │ │ │ │ │ │ │ │S0/S1│ │ │ │ Reference to │ │ │ │ └─────────────┘ │ └─────┘ │ │ │ Heap Objects │ │ │ │ │ │ │ └─────────────────┘ │ │ │ ┌─────────────┐ │ Old Gen │ │ Thread 2 Stack │ │ │ │ Native │ │ │ │ ┌─────────────────┐ │ │ │ │ Method │ │ │ │ │ Stack Frames │ │ │ │ │ Stack │ │ │ │ │ ... │ │ │ │ └─────────────┘ └─────────────┘ └─────────────────────┘ │ └─────────────────────────────────────────────────────────────┘

2. Detailed Memory Areas

Heap Memory

public class HeapMemoryExample { private static List<String> staticList = new ArrayList<>(); // Class/Heap private instanceList = new ArrayList<>(); // Instance/Heap public void demonstrateHeapMemory() { // All these objects are allocated in Heap String str = new String("Hello World"); // Heap List<Integer> numbers = new ArrayList<>(); // Heap int[] array = new int[1000]; // Heap // Object references are in stack, objects themselves in heap Object obj = new Object(); // ref in stack, object in heap } }

Stack Memory

public class StackMemoryExample { public static void main(String[] args) { // main stack frame int localVar = 10; // Stored in stack String reference = "Hello"; // reference in stack, object in heap/string pool methodOne(localVar); // New stack frame created } public static void methodOne(int param) { // New stack frame int localVar = 20; // Stored in this method's stack frame Object obj = new Object(); // reference in stack, object in heap methodTwo(); // Another stack frame } // Stack frame destroyed when method returns public static void methodTwo() { // Each method call creates a new stack frame with: // - Local variables // - Method parameters // - Return address // - Operand stack } }

Method Area

public class MethodAreaExample { // Class-level data stored in Method Area private static final String CLASS_CONSTANT = "CONSTANT_VALUE"; private static int staticCounter = 0; // Class metadata, method code, constant pool, field data // are all stored in Method Area }

3. Garbage Collection

How Garbage Collection Works

public class GarbageCollectionExample { public static void main(String[] args) { demonstrateGC(); System.gc(); // Suggest JVM to run GC (not guaranteed) Runtime.getRuntime().gc(); // Alternative way } public static void demonstrateGC() { // Object becomes eligible for GC when no references point to it Object obj1 = new Object(); // Object created Object obj2 = new Object(); obj1 = obj2; // Original obj1 object becomes unreachable // The object that was referenced by obj1 is now eligible for GC obj2 = null; // Now both original objects are unreachable // Method local objects become eligible after method execution createTemporaryObjects(); } public static void createTemporaryObjects() { for(int i = 0; i < 1000; i++) { String temp = new String("Temp " + i); // Each temp becomes eligible for GC after loop iteration } // All temp objects are eligible for GC after method returns } }

Object Lifecycle and GC Eligibility

public class ObjectLifecycle { private static List<Object> staticList = new ArrayList<>(); public static void main(String[] args) { // Case 1: Nullifying reference Object obj1 = new Object(); obj1 = null; // Eligible for GC // Case 2: Reassigning reference Object obj2 = new Object(); Object obj3 = new Object(); obj2 = obj3; // Original obj2 object eligible for GC // Case 3: Isolated islands Object island1 = new Object(); Object island2 = new Object(); island1 = island2; island2 = island1; // Both objects reference each other but no external references // Eligible for GC (island of isolation) // Case 4: Method local objects createShortLivedObjects(); // Case 5: Static references - objects stay in memory staticList.add(new Object()); // Will not be GC'd while staticList exists } public static void createShortLivedObjects() { Object shortLived = new Object(); // shortLived becomes eligible for GC after method returns } }

4. Generational Garbage Collection

Heap Generations

public class GenerationalGCExample { public static void main(String[] args) { demonstrateObjectAging(); } public static void demonstrateObjectAging() { // Young Generation (Eden + Survivor Spaces) List<Object> youngObjects = new ArrayList<>(); // Most objects die young for (int i = 0; i < 10000; i++) { Object shortLived = new Object(); if (i % 100 != 0) { // Most objects become unreachable immediately youngObjects.add(shortLived); } } youngObjects.clear(); // All objects become eligible for GC // Objects that survive multiple GC cycles move to Old Generation List<Object> longLivedObjects = new ArrayList<>(); for (int i = 0; i < 10; i++) { Object longLived = new Object(); longLivedObjects.add(longLived); } // These objects will survive multiple GC cycles and eventually // be promoted to Old Generation } }

5. Memory Management Best Practices

1. Avoid Memory Leaks

public class MemoryLeakPrevention { private static final Map<Object, Object> CACHE = new HashMap<>(); private static final List<Object> STATIC_LIST = new ArrayList<>(); // ❌ Potential memory leak - objects never removed from cache public void addToCacheBad(Object key, Object value) { CACHE.put(key, value); } // ✅ Better approach - use WeakHashMap or size limits private static final Map<Object, Object> WEAK_CACHE = new WeakHashMap<>(); private static final int MAX_CACHE_SIZE = 1000; private static final Map<Object, Object> LIMITED_CACHE = new LinkedHashMap<>() { @Override protected boolean removeEldestEntry(Map.Entry eldest) { return size() > MAX_CACHE_SIZE; } }; public void addToCacheGood(Object key, Object value) { LIMITED_CACHE.put(key, value); } // ❌ Static collections holding object references public void registerObjectBad(Object obj) { STATIC_LIST.add(obj); // Object can never be GC'd } // ✅ Use weak references for listeners/callbacks private static final List<WeakReference<Object>> WEAK_LIST = new ArrayList<>(); public void registerObjectGood(Object obj) { WEAK_LIST.add(new WeakReference<>(obj)); } }

2. Efficient Object Creation

public class EfficientObjectCreation { // ❌ Inefficient - creates new object every time public String createStringBad() { return new String("constant"); // Creates new object each time } // ✅ Better - uses string pool public String createStringGood() { return "constant"; // Reuses from string pool } // ❌ Creates unnecessary temporary objects public String concatenateBad(String[] parts) { String result = ""; for (String part : parts) { result += part; // Creates new String object each iteration } return result; } // ✅ Uses StringBuilder to avoid temporary objects public String concatenateGood(String[] parts) { StringBuilder sb = new StringBuilder(); for (String part : parts) { sb.append(part); } return sb.toString(); } // Object pooling for expensive objects private static final Queue<ExpensiveObject> OBJECT_POOL = new LinkedList<>(); public ExpensiveObject getExpensiveObject() { ExpensiveObject obj = OBJECT_POOL.poll(); if (obj == null) { obj = new ExpensiveObject(); } return obj; } public void returnExpensiveObject(ExpensiveObject obj) { obj.reset(); // Reset object state OBJECT_POOL.offer(obj); } } class ExpensiveObject { private byte[] largeData = new byte[1024 * 1024]; // 1MB public void reset() { // Reset object to initial state Arrays.fill(largeData, (byte) 0); } }

3. Proper Resource Management

public class ResourceManagement { // ❌ Resource leak - stream not closed public void readFileBad(String filename) { try { FileInputStream fis = new FileInputStream(filename); // read file... // fis never closed! } catch (IOException e) { e.printStackTrace(); } } // ✅ Traditional try-finally public void readFileBetter(String filename) { FileInputStream fis = null; try { fis = new FileInputStream(filename); // read file... } catch (IOException e) { e.printStackTrace(); } finally { if (fis != null) { try { fis.close(); } catch (IOException e) { e.printStackTrace(); } } } } // ✅ Best - try-with-resources (Java 7+) public void readFileBest(String filename) { try (FileInputStream fis = new FileInputStream(filename); BufferedInputStream bis = new BufferedInputStream(fis)) { // read file... // Resources automatically closed } catch (IOException e) { e.printStackTrace(); } } // For custom resources public void useCustomResource() { try (MyResource resource = new MyResource()) { resource.doSomething(); } catch (Exception e) { e.printStackTrace(); } } } // Custom resource implementing AutoCloseable class MyResource implements AutoCloseable { public void doSomething() { System.out.println("Doing something..."); } @Override public void close() throws Exception { System.out.println("Cleaning up resources..."); // Release native resources, close connections, etc. } }

6. Monitoring and Diagnostics

Memory Monitoring Tools

public class MemoryMonitoring { public static void monitorMemory() { Runtime runtime = Runtime.getRuntime(); // Memory statistics long maxMemory = runtime.maxMemory(); // Maximum heap size long totalMemory = runtime.totalMemory(); // Current heap size long freeMemory = runtime.freeMemory(); // Free memory in heap long usedMemory = totalMemory - freeMemory; // Actually used memory System.out.println("=== Memory Statistics ==="); System.out.println("Max Memory: " + (maxMemory / (1024 * 1024)) + " MB"); System.out.println("Total Memory: " + (totalMemory / (1024 * 1024)) + " MB"); System.out.println("Free Memory: " + (freeMemory / (1024 * 1024)) + " MB"); System.out.println("Used Memory: " + (usedMemory / (1024 * 1024)) + " MB"); // Memory usage percentage double usagePercentage = (double) usedMemory / totalMemory * 100; System.out.println("Memory Usage: " + String.format("%.2f", usagePercentage) + "%"); } public static void forceGarbageCollection() { System.out.println("\nBefore GC:"); monitorMemory(); // Suggest garbage collection System.gc(); // Wait a bit for GC to complete try { Thread.sleep(1000); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } System.out.println("\nAfter GC:"); monitorMemory(); } public static void createMemoryPressure() { List<byte[]> memoryHog = new ArrayList<>(); try { // Allocate memory until we approach limits while (true) { byte[] largeArray = new byte[10 * 1024 * 1024]; // 10MB memoryHog.add(largeArray); System.out.println("Allocated: " + (memoryHog.size() * 10) + "MB"); // Check memory usage Runtime runtime = Runtime.getRuntime(); long usedMemory = runtime.totalMemory() - runtime.freeMemory(); long maxMemory = runtime.maxMemory(); if (usedMemory > maxMemory * 0.8) { System.out.println("Approaching memory limit, stopping..."); break; } Thread.sleep(100); } } catch (OutOfMemoryError e) { System.out.println("OutOfMemoryError caught!"); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } finally { memoryHog.clear(); System.gc(); } } public static void main(String[] args) { monitorMemory(); forceGarbageCollection(); // createMemoryPressure(); // Use with caution! } }

7. Common Memory Issues and Solutions

Memory Leaks

public class CommonMemoryLeaks { // 1. Static Fields Holding Object References private static final Map<String, Object> LEAKY_CACHE = new HashMap<>(); public void addToLeakyCache(String key, Object value) { LEAKY_CACHE.put(key, value); // Objects never removed } // Solution: Use soft/weak references or implement cleanup private static final Map<String, SoftReference<Object>> SAFE_CACHE = new HashMap<>(); // 2. Unclosed Resources public void leakResources() { // Connections, streams, etc. that are never closed // Solution: Use try-with-resources try (Connection conn = DriverManager.getConnection("url"); PreparedStatement stmt = conn.prepareStatement("SQL")) { // work with resources } catch (SQLException e) { e.printStackTrace(); } } // 3. Listeners and Callbacks Not Removed private List<EventListener> listeners = new ArrayList<>(); public void addListener(EventListener listener) { listeners.add(listener); } // Forgot to remove listeners - objects can't be GC'd // Solution: Always provide removeListener method public void removeListener(EventListener listener) { listeners.remove(listener); } // 4. Inner Classes Holding Outer Class References public class LeakyInnerClass { private byte[] data = new byte[1024 * 1024]; // Inner class implicitly holds reference to outer class // This prevents outer class from being GC'd if inner class is referenced } // Solution: Use static nested class when outer reference not needed public static class NonLeakyNestedClass { private byte[] data = new byte[1024 * 1024]; // No implicit reference to outer class } }

Handling Large Objects

public class LargeObjectManagement { // For very large objects, consider off-heap storage public void handleLargeData() { // ❌ Large on-heap allocation // byte[] hugeArray = new byte[500 * 1024 * 1024]; // 500MB // ✅ Consider memory-mapped files for large data try (FileChannel channel = FileChannel.open( Paths.get("largefile.dat"), StandardOpenOption.READ, StandardOpenOption.WRITE, StandardOpenOption.CREATE)) { MappedByteBuffer mappedBuffer = channel.map( FileChannel.MapMode.READ_WRITE, 0, 500 * 1024 * 1024); // Work with memory-mapped data // This uses OS virtual memory instead of Java heap } catch (IOException e) { e.printStackTrace(); } } // Lazy initialization for expensive objects private volatile ExpensiveObject expensiveInstance; public ExpensiveObject getExpensiveObject() { if (expensiveInstance == null) { synchronized (this) { if (expensiveInstance == null) { expensiveInstance = new ExpensiveObject(); } } } return expensiveInstance; } }

8. JVM Memory Options

Common JVM Memory Flags

public class JVMMemoryOptions { /* Common JVM Memory Arguments: -Xms<size> Set initial Java heap size -Xmx<size> Set maximum Java heap size -Xss<size> Set java thread stack size -XX:NewSize=<size> Set initial young generation size -XX:MaxNewSize=<size> Set maximum young generation size -XX:NewRatio=<ratio> Set ratio between young and old generation -XX:SurvivorRatio=<ratio> Set ratio between eden and survivor spaces Examples: -Xms512m -Xmx2g -Xss256k -XX:NewRatio=2 -XX:SurvivorRatio=8 Monitoring: -XX:+PrintGC -XX:+PrintGCDetails -XX:+PrintGCTimeStamps -Xlog:gc* - for Java 9+ unified logging */ public static void printRecommendedSettings() { System.out.println(""" Recommended JVM Memory Settings for Production: Server Applications: -Xms2g -Xmx2g (Start with equal min and max to avoid resizing) -Xss256k (Reduce thread stack size for more threads) -XX:+UseG1GC (Use G1 garbage collector) Memory-Intensive Applications: -Xms4g -Xmx8g (Larger heap for big data processing) -XX:NewRatio=1 (More young generation space) -XX:MaxGCPauseMillis=200 (Control GC pause times) Default GC Settings by Java Version: Java 8: Parallel GC Java 11+: G1 GC """); } }

9. Practical Memory Optimization

Real-World Optimization Example

public class MemoryOptimizedCache<K, V> { private final Map<K, SoftReference<V>> cache; private final int maxSize; private final LinkedHashMap<K, Long> accessOrder; public MemoryOptimizedCache(int maxSize) { this.maxSize = maxSize; this.cache = new HashMap<>(); this.accessOrder = new LinkedHashMap<>(16, 0.75f, true) { @Override protected boolean removeEldestEntry(Map.Entry<K, Long> eldest) { return size() > maxSize; } }; } public void put(K key, V value) { cache.put(key, new SoftReference<>(value)); accessOrder.put(key, System.currentTimeMillis()); cleanup(); } public V get(K key) { SoftReference<V> ref = cache.get(key); if (ref != null) { V value = ref.get(); if (value != null) { accessOrder.put(key, System.currentTimeMillis()); return value; } else { // Reference was cleared by GC, remove from cache cache.remove(key); accessOrder.remove(key); } } return null; } private void cleanup() { // Remove entries where soft reference was cleared cache.entrySet().removeIf(entry -> entry.getValue().get() == null); } public int size() { cleanup(); return cache.size(); } }

Summary

Key Points for Java Memory Management:

Heap vs Stack: Objects in heap, references and primitives in stack
Garbage Collection: Automatic memory reclamation, generational approach
Memory Areas: Heap, Stack, Method Area, Native Method Stack
Common Issues: Memory leaks, resource leaks, large object handling
Best Practices:

Use try-with-resources
Avoid memory leaks in caches and listeners
Properly manage object lifecycle
Monitor memory usage
Choose appropriate JVM settings

Tools for Memory Analysis:

VisualVM
JConsole
Java Mission Control
Eclipse MAT (Memory Analyzer Tool)
jstat command-line tool

Effective memory management is crucial for building scalable, high-performance Java applications. Understanding these concepts helps in writing efficient code and troubleshooting memory-related issues.