JVM Memory Architecture: Heap, Stack, Metaspace & Memory Leaks

When a Java application runs, the JVM organizes system RAM into distinct memory spaces defined by the Java Virtual Machine Specification. Mastering JVM memory management enables you to prevent OutOfMemoryError, diagnose memory leaks, and tune high-scale production systems.

1. The Five JVM Run-Time Data Areas

2. Deep Dive: Heap Memory Architecture

Heap memory is divided into generational spaces based on the Weak Generational Hypothesis (the observation that most objects die very shortly after creation):

• Young Generation:
  • Eden Space: Where newly created objects are first instantiated via new.
  • Survivor Spaces (S0 & S1 / From & To): Objects that survive minor garbage collection cycles are moved between S0 and S1, incrementing their age counter.
• Old (Tenured) Generation: Objects that survive multiple GC cycles (default threshold: 15 cycles) are promoted to Tenured generation for long-term storage.

3. Stack Memory & Stack Frame Anatomy

Each active thread has its own Stack. Every time a method is invoked, the JVM pushes a new Stack Frame containing:

1. Local Variable Array: Holds parameters and local variables.
2. Operand Stack: Working memory where CPU arithmetic operations are staged.
3. Frame Data: Holds reference to the Run-Time Constant Pool and exception handling dispatchers.

StackOverflowError vs OutOfMemoryError in Action

Case A: StackOverflowError (Infinite Recursion)

public class StackOverflowDemo {
    public static void recursiveBomb(int count) {
        // Pushes stack frames continuously without base condition
        recursiveBomb(count + 1);
    }

    public static void main(String[] args) {
        // Throws: Exception in thread "main" java.lang.StackOverflowError
        recursiveBomb(1);
    }
}

Case B: OutOfMemoryError: Java heap space

import java.util.ArrayList;
import java.util.List;

public class HeapOOMDemo {
    public static void main(String[] args) {
        List memoryLeakList = new ArrayList<>();
        // Rapidly fills the Heap with 10MB byte arrays
        while (true) {
            memoryLeakList.add(new byte[10 * 1024 * 1024]);
        }
        // Throws: java.lang.OutOfMemoryError: Java heap space
    }
}

Crucial JVM Memory Tuning Command-Line Flags