Java Virtual Machine (JVM) Stack Area
Last Updated : 03 Jun, 2025
The Java Virtual Machine is responsible for running Java applications, and it manages various memory areas, one of which is the Stack Area. In this article, we are going to discuss about JVM Stack Area in depth.
JVM Stack Area
In Java, each thread has its own stack called the Run-Time Stack, created when the thread starts. This stack holds the data for method execution within that thread. The memory for a Java Virtual Machine stack does not need to be contiguous. JVM implementations can allocate and manage stack memory dynamically, depending on the platform.
Components of a Stack Frame
The main components of a stack frame are listed below:
- Method call information: Stores details about the method being executed.
- Local variables: Stores local variables defined within the method.
- Method parameters: Stores parameters passed to the method.
- Return address: Tracks where to return once the method completes.
After all method calls are completed, the stack is emptied and destroyed by the JVM. The stack data is thread-specific, ensuring thread safety for local variables. Each entry in the stack is called a Stack Frame or Activation Record.
How the JVM Stack Works?
When a method is called, a new stack frame is created and pushed onto the thread's JVM stack, this stack frame contains all the information needed for the method execution. The JVM executes the method's code, using the local variables and parameters stored in the stack frame. Once the method execution is complete, the stack frame is popped off the stack, and control returns to the calling method.
Note: This process will repeat for every method call, including recursive and nested calls.
Example: Here, the example demonstrates how the stack actually works.
Java // Java Program to Demonstrate the working of stack import java.io.*; class Geeks { public static int add(int a, int b) { return a + b; } public static void main (String[] args) { int ans = add(5, 5); System.out.println("Answer: " + ans); } } Explanation:
- When main method is called, the stack frame for the main is created.
- Inside the main, the add method is called with the parameters, now the new stack frame for the add is created.
- The add method executes using the provided parameters
- After the add method returns, its stack frame is popped off and control returns to main.
The image below demonstrates the stack area of JVM:
Stack Frame Structure
The stack frame basically consists of three parts. The three parts are
- Local Variable Array
- Operand Stack
- Frame Data
When JVM invokes a Java method, first it checks the class data to determine the number of words (size of the local variable array and operand stack, which is measured in words for each individual method) required by the method in the local variables array and operand stack. It creates a stack frame of the proper size for invoked method and pushes it onto the Java stack.
1. Local Variable Array (LVA)
- The local variables part of the stack frame is organized as a zero-based array of words.
- It contains all parameters and local variables of the method.
- Each slot or entry in the array is of 4 Bytes.
- Values of type int, float, and reference occupy 1 entry or slot in the array i.e. 4 bytes.
- Values of double and long occupy 2 consecutive entries in the array i.e. 8 bytes total.
- Byte, short, and char values will be converted to int type before storing and occupy 1 slot i.e. 4 Bytes.
- But the way of storing Boolean values is varied from JVM to JVM. But most of the JVM gives 1 slot for Boolean values in the local variable array.
- The parameters are placed into the local variable array first, in the order in which they are declared.
Example: Let us consider a class Example having a method bike() then the local variable array will be as shown in the below diagram:
// Class Declaration
class Example
{
public void bike(int i, long l, float f, double d, Object o, byte b)
{
}
}
2. Operand Stack (OS)
- The JVM uses an operand stack as a workspace for temporary calculations.
- Unlike the local variable array, which you access using an index, the operand stack works with special instructions. These instructions can push values onto the stack, pop values off, and perform operations using those values.
Example: Here is how a JVM will use this below code that would subtract two local variables that contain two ints and store the int result in a third local variable:
So, here first two instructions iload_0 and iload_1 will push the values in the operand stack from a local variable array. And instruction isub will subtract these two values and store the result back to the operand stack and after istore_2 the result will pop out from the operand stack and will store into a local variable array at position 2.
3. Frame Data (FD)
- It contains all symbolic references (constant pool resolution) and normal method returns related to that particular method.
- It also contains a reference to the Exception table which provides the corresponding catch block information in the case of exceptions.