Heap & Stack

🔍 What Is It?

Stack Memory:

• →One stack per thread
• →Stores: method call frames, local variables (primitives and object references), return addresses
• →LIFO (Last In, First Out) — method frames pushed on call, popped on return
• →Fixed size (default: 512KB–1MB per thread, configurable with -Xss)
• →Automatic management — no GC needed, memory freed when method returns
• →Fast: simple pointer increment/decrement
• →StackOverflowError when too deep (usually infinite recursion)

Heap Memory:

• →One heap shared by all threads
• →Stores: all objects (new Foo()), arrays, String pool (part of heap)
• →Managed by Garbage Collector
• →Configurable size: -Xms (initial), -Xmx (maximum)
• →Generational structure:

- Young Generation (Eden + Survivor spaces): new objects allocated here

- Old Generation (Tenured): long-lived objects promoted here

- Minor GC: cleans young generation (fast, frequent)

- Major/Full GC: cleans old generation (slow, rare)

Metaspace (Java 8+, was PermGen):

• →Stores class metadata, method bytecode, static variables
• →Native memory (not part of heap)
• →Grows dynamically (no fixed size by default)

Code Cache:

• →Stores JIT-compiled native code
• →Fixed size, configurable with -XX:ReservedCodeCacheSize

🎯 Why Do We Need It?

Understanding Heap vs Stack is essential for:

• →Diagnosing OutOfMemoryError — is it heap (too many objects) or stack (too deep recursion)?
• →Understanding GC — only heap objects are garbage collected
• →Memory leak analysis — objects on heap that are never GC'd
• →Thread safety — stack variables are thread-private (safe); heap objects are shared (need synchronization)
• →Performance tuning — large heaps need tuning; deep stacks need -Xss adjustment

🏗️ What Happens in Real Projects?

In production:

• →OOM: Java heap space — increase -Xmx or find memory leak with heap dump
• →OOM: Metaspace — classloader leak, increase -XX:MaxMetaspaceSize
• →StackOverflowError — infinite recursion, increase -Xss or fix the recursion
• →High GC pause — too many short-lived objects, tune young generation size

⚙️ How It Works

Object Allocation:

void processOrder(Long orderId) {
    // Stack: frame for processOrder
    // Stack: orderId reference (Long object is on heap)
    
    Order order = new Order(orderId);  // Order object on HEAP
    // Stack: 'order' variable (reference to heap object)
    
    int total = calculateTotal(order); // Stack: new frame for calculateTotal
    // Stack: 'total' int value
    
    // When processOrder returns:
    // Stack frame popped — 'order' reference gone
    // Order object on heap becomes eligible for GC (if no other references)
}

Escape Analysis (JIT optimization):

The JIT compiler can detect that some objects never "escape" the method — they are not returned, stored in fields, or passed to other threads. These objects may be allocated on the stack instead of the heap, eliminating GC pressure. This is transparent to developers but explains why Java's performance is better than naive analysis suggests.

💻 Example

Memory Allocation in Practice — How to diagnose and fix memory issues in production Java.

public class MemoryDemo {
    // Static field: in Metaspace (class-level, not per-instance)
    private static final String APP_NAME = "MyApp";
    
    // Instance field: on Heap (part of each MemoryDemo object)
    private String name;
    private int count;  // int value stored directly in the object on heap
    
    public void demonstrateMemory() {
        // Local primitive: on Stack
        int localInt = 42;
        
        // Local reference: on Stack; object it points to: on Heap
        String localString = new String("hello");
        
        // String literal: in String Pool (part of Heap)
        String pooled = "hello";  // may reuse existing pool entry
        
        // Array: on Heap (arrays are objects)
        int[] numbers = new int[100];  // array object on heap
        // numbers variable (reference) on stack
        
        // After this method returns:
        // localInt, localString (reference), numbers (reference) popped from stack
        // The String object and int[] array become GC-eligible (if no other refs)
        // APP_NAME stays in Metaspace forever (class-level)
    }
}

🤔 Common Confusions

🚨 Common Production Issues

✅ Best Practices

🏛️ Architect's Note

💬 Frequently Asked Questions

🎯 Key Takeaways

🔗 Related Topics

🎯 Practice this topic in interviews

↗ Where this topic fits