What is the difference between heap and stack memory?

In Java, memory management is crucial for application performance and stability. The Java Virtual Machine (JVM) primarily divides memory into two main regions for program execution: Stack Memory and Heap Memory. Understanding the distinctions between these two is fundamental for any Java developer.

Stack Memory

Stack memory is a temporary memory region used by the JVM to store method-specific data during program execution. It operates on a Last-In, First-Out (LIFO) principle, meaning the last item pushed onto the stack is the first one to be popped off. Each thread in a Java application has its own private stack.

It primarily stores local variables (primitive types like int, boolean, float, char, etc.), method call parameters, and references to objects that reside in the Heap. When a method is invoked, a new stack frame is created and pushed onto the stack. When the method completes, its stack frame is automatically popped off, and all data within it is deallocated.

• Allocation: Automatically managed by the JVM.
• Lifetime: Tied to the method's execution; data is deallocated when the method finishes.
• Size: Relatively small and fixed, leading to StackOverflowError if too many method calls (e.g., deep recursion) occur without returning.
• Access: Very fast due to its LIFO structure and CPU register direct access.
• Contents: Primitive local variables, method call information, references to heap objects.

Heap Memory

Heap memory is a dynamic memory region used to store all objects created by a Java application, regardless of where they were created. It is shared among all threads in the application. Unlike stack memory, the heap does not operate on a LIFO principle and objects can be accessed in any order.

Objects are allocated in the heap using the new keyword. Their lifetime is not tied to any specific method call; they persist as long as there are active references pointing to them. When an object is no longer referenced by any part of the program, it becomes eligible for garbage collection, which is an automatic process that reclaims memory from unused objects.

• Allocation: Explicitly managed by the programmer (via new keyword) and then automatically managed by the JVM's Garbage Collector.
• Lifetime: Objects reside in the heap until they are no longer referenced and are garbage collected.
• Size: Much larger and flexible than stack memory, can be configured. Running out of heap space results in OutOfMemoryError.
• Access: Slower than stack memory due to dynamic allocation and potential fragmentation.
• Contents: All Java objects (including instance variables), arrays.

Key Differences Summarized

Example Code Illustration

Consider the following Java code snippet to visualize how variables and objects are stored:

public class MemoryExample {
    public static void main(String[] args) {
        int x = 10; // x is a primitive local variable, stored in Stack

        String name = "Java"; // "Java" is a String object in Heap,
                              // name is a reference in Stack pointing to it

        MyObject obj = new MyObject(25); // new MyObject(25) is an object in Heap,
                                        // obj is a reference in Stack pointing to it

        anotherMethod(x, obj); // x and obj's reference are passed onto the Stack
    }

    public static void anotherMethod(int a, MyObject o) {
        // a and o are local variables for this method, stored in Stack
        boolean flag = true; // flag is a primitive local variable, stored in Stack
        // ...
    }
}

class MyObject {
    int value; // value is an instance variable, part of the MyObject object in Heap

    public MyObject(int v) {
        this.value = v;
    }
}

In this example, x, name (the reference), obj (the reference), a, o, and flag are all stored in Stack Memory. The actual String object "Java" and the MyObject instance (which contains value) are stored in Heap Memory.