Heap vs Stack Memory

Direct Answer

The JVM heap is shared by all threads and is the logical storage for class instances and arrays. Every JVM thread has a private JVM stack made of frames for its active method calls. A frame carries local variables, an operand stack, and method-execution data; it disappears when that call completes.

Deep Dive & Architecture

Call stacks and heap objects

Suppose createOrder() constructs an Order, stores the reference in a service field, and returns. The method call has a frame containing its parameters, temporary values, and the local Order reference. That frame ends on return. The Order remains reachable through the service field, so it is not garbage just because the creating method finished.

If the method returns the reference instead, the caller receives a copy of the reference value before the callee frame disappears. If the method neither returns nor stores it, and no other path exists, the Order can become eligible for collection. Eligibility still does not mean immediate collection.

Memory areas and their common failures

A recursive traversal creates another frame for every unfinished call. With enough depth, one thread may reach its allowed stack limit and throw StackOverflowError even while plenty of heap remains. A program retaining millions of Orders can instead exhaust heap capacity and throw OutOfMemoryError even with shallow call stacks. The error points to a runtime area, while logs and traces reveal the actual cause.

Logical memory areas and runtime optimisations

If an object's identity never escapes and is unobservable, an optimizing JVM may eliminate the allocation or break it into scalar values. This does not change Java-level behaviour and is not storage an application can request. The JVM specification defines logical areas rather than one universal RAM map, so avoid fixed claims about addresses, default stack sizes, or which allocation is “always faster” without naming a runtime and measurement.

Code Example

class HeapAndStackMemory {
    record User(String name) {}

    static User createUser(String name) {
        User localReference = new User(name);
        return localReference;
    }

    public static void main(String[] args) {
        User returnedReference = createUser("Mina");
        System.out.println(returnedReference.name());
    }
}

After createUser returns, its frame is gone. The User is still reachable from returnedReference in the caller.