Master JVM Memory Structure: A Deep Dive into Java’s Runtime Architecture

Understanding the Java Virtual Machine (JVM) is essential for writing robust Java code and succeeding in technical interviews, so this series begins with a detailed look at JVM memory structure.

Why Study the JVM?

Developers often wonder how to size heap memory, why OutOfMemoryError occurs, how JVM tuning works, how garbage collection is performed, and what happens when a String object is created. Answering these questions starts with mastering the JVM’s internal components.

JVM Memory Structure Overview

The JVM divides runtime memory into five distinct areas, as illustrated below:

The five regions are:

Heap – the largest, shared among threads, stores all object instances.

Method Area – stores class metadata, constants, static variables, and JIT‑compiled code; also shared.

JVM Stacks – thread‑private stacks that hold stack frames for Java method execution.

Native Method Stacks – thread‑private stacks used when native (JNI) methods are invoked.

Program Counter (PC) Register – a small, thread‑private counter indicating the current bytecode instruction.

Heap, method area, and PC differ in size: the heap is typically the largest, while the PC occupies minimal memory.

Heap (Garbage‑Collected Heap)

The heap is the primary area for object allocation and the main target of garbage collection. It is divided into generations: the young generation (Eden, Survivor S0, Survivor S1) and the old generation. When the heap cannot expand further, an OutOfMemoryError is thrown.

Method Area

The method area, logically part of the heap, holds loaded class definitions, constant pools, static fields, and JIT‑compiled code. Like the heap, it is shared and can trigger OutOfMemoryError if it cannot grow.

Program Counter Register

Each thread has its own PC register, which records the address of the next bytecode to execute. It is the only JVM area that never throws OutOfMemoryError. For native methods the PC is undefined.

JVM Stacks

JVM stacks are thread‑private and consist of stack frames. A stack frame contains a local variable table, an operand stack, a reference to the runtime constant pool for dynamic linking, and the return address. The local variable table stores method parameters and local variables (including primitive types, object references, and return addresses). The operand stack operates in a LIFO manner, supporting bytecode execution.

If a thread’s stack depth exceeds the JVM limit, a StackOverflowError occurs; if the stack cannot be expanded due to insufficient memory, an OutOfMemoryError is thrown.

Native Method Stacks

Native method stacks serve the same purpose for native (JNI) methods as JVM stacks do for Java methods, and they can also raise StackOverflowError or OutOfMemoryError.

Summary

By grasping the layout and responsibilities of the JVM’s five memory regions—heap, method area, program counter, JVM stacks, and native method stacks—developers can better diagnose memory‑related errors, tune performance, and understand the underlying mechanics of Java execution.