Heap vs Stack: How Java Manages What to Remember or Forget

When we run a program, the operating system allocates memory so that this application can store data and retrieve it for as long as necessary. Unlike C or C++, in which the programmer has the freedom to allocate memory and manage pointers "by hand", in Java the JVM (Java Virtual Machine) manages volatile storage, abstracting this complexity for us in two allocation systems, the Heap and the Stack.

The difference between them lies in the purpose of storage and the need (or not) to share that data with multiple processes.

The JVM uses the Stack for short-term data and follows a LIFO (Last In First Out) structure. The Stack is a memory area used to manage the execution of methods, store local variables and method calls in an organized way in frames. Each thread in the JVM has its own stack.

The Heap is a global memory area shared between all threads, where objects and variables are allocated that need to have a useful life beyond the scope of the method that created them.

Memory on the Heap is managed by the Garbage Collector, which removes unreferenced objects to free up space, being used for long-term data.

Let's use a practical example.

When a primitive variable is created in the scope of a method, it must be available for use while the method is executed. This way, it is Stack who will store this variable, as it is responsible for the life cycle of data that has a unique and specific use in the program.

However, when a method creates an instance, this object can be used in other parts of the program, and not just where it was declared. This clearly happens when we create an object that represents a record in the database. In our program, this same instance can be consulted, edited and removed throughout an execution. This way, Heap will take care of storing the object.

To illustrate this point, I will use a simple example that author Hanumant Deshmukh describes in his guide "OCP Java SE 17/21 Programmer Exam Fundamentals". This book, by the way, is wonderful, as it manages to be very didactic in explaining quite complex processes. I highly recommend it if you, like me, are looking for the Oracle Certified Professional (OCP) certification. The author uses an instance of String for teaching purposes, but I'm going to use a custom object here just to avoid the risk of violating copyright (:S)

public class Main {
    public static void main(String[] args) {
        HeapObj heapObject = newObject();
        int counter = 0;

        while (counter++ < 10){
            print(heapObject.getName());
        }
    }

    public static HeapObj newObject(){
        return new HeapObj("Happy instance");
    }

    public static void print(String text){
        System.out.println(text);
    }
}

In the example, the Main class calls three methods: the main one, one that creates the instance of the HeapObj object, and another that just prints text.

If we took a photo when all the methods have already been called, the Stack and Heap would look like this:

In other words:

1. At startup:

Stack: main frame (contains args, heapObject, counter).
Heap: Empty.

2. After newObject:

Stack: main frame (contains args, heapObject reference, counter).
Heap: A HeapObj object with the string "Happy instance".

3. During the Loop:

Stack: main frame (contains args, heapObject reference, counter), multiple print frames that are stacked and unstacked.
Heap: The same HeapObj object and the string "Happy instance".

4. After the loop:

Stack: main frame (contains args, heapObject reference).
Heap: The same HeapObj object and the string "Happy instance".

5. At the end of the program:

Stack: empty.
Heap: empty.

The above is the detailed content of Heap vs Stack: How Java Manages What to Remember or Forget. For more information, please follow other related articles on the PHP Chinese website!