JVM Architecture (Java Virtual Machine)

The Java Virtual Machine (JVM) Architecture defines how Java code is loaded, verified, executed, and managed in memory. It consists of three core components:

1. Class Loader Subsystem
2. Runtime Data Areas (Memory Structure)
3. Execution Engine (Interpreter + JIT + GC)

This architecture ensures Java’s platform independence, automatic memory management, and high performance.

1. Class Loader Subsystem

The Class Loader is responsible for loading Java classes into the JVM.

It loads .class (bytecode) files dynamically at runtime.

Key Responsibilities

• Loading classes into memory
• Verifying bytecode security
• Preparing memory for class variables
• Resolving references (links classes together)

Types of Class Loaders

1. Bootstrap ClassLoader
   • Loads core Java classes (java.lang, java.util, etc.)
   • Part of native JVM code
   • No Java object representation
2. Extension (Platform) ClassLoader
   • Loads classes from JDK extensions
   • Example: jre/lib/ext/
3. Application ClassLoader
   • Loads application-level classes
   • Loads everything from the project’s classpath

Class Loading Steps

1. Loading – Reads .class file
2. Linking
   • Verification → Ensures bytecode safety
   • Preparation → Allocates memory for static fields
   • Resolution → Replaces symbolic references
3. Initialization
   • Executes static blocks
   • Initializes static variables

2. JVM Runtime Data Areas (Memory Structure)

JVM divides memory into different runtime areas where methods, objects, references, and instructions are stored.

JVM Memory Structure

1. Method Area / MetaSpace (Shared)

Stores class-level information:

• Class metadata
• Static variables
• Method & constructor definitions
• Constant Pool

MetaSpace (JDK 8+) grows dynamically → reduces OutOfMemory errors.

2. Heap Area (Shared)

Stores:

• Objects
• Arrays
• Instance variables

Heap is divided into:

• Young Generation (Eden + Survivor S0/S1)
• Old Generation
• Metaspace (class metadata)

Managed by Garbage Collector.

3. JVM Stack (Per Thread)

Each thread has its own stack.

Stores:

• Method call frames
• Local variables
• Reference variables
• Return values

Follows LIFO (Last In First Out).

4. PC Register (Per Thread)

Stores:

• Address of the current instruction being executed

  Every Java thread has its own PC register.

5. Native Method Stack

Used for:

• Executing native code (C/C++ via JNI)
• OS-level operations

3. Execution Engine (How JVM Executes Code)

The Execution Engine is responsible for executing the loaded bytecode.

Components of Execution Engine

1. Interpreter

• Executes bytecode line-by-line
• Slower, but starts immediately
• Used for non-frequent code paths

2. JIT Compiler (Just-In-Time)

• Converts repeatedly executed bytecode → native machine code
• Improves overall performance
• Works with a HotSpot Profiler to find frequently executed methods (hotspots)

Output: Faster execution on the CPU.

3. Garbage Collector (GC)

Automatically cleans unused objects from Heap.

Uses algorithms like:

• Mark & Sweep
• G1 GC
• ZGC
• Shenandoah

Improves memory efficiency and reduces leaks.

4. Native Method Interface (JNI)

Allows Java to interact with:

• C/C++ libraries
• OS-level functions

Complete JVM Architecture (Summary Diagram)

             +-------------------------------+
             |        Class Loader            |
             +-------------------------------+
                | Loading | Linking | Init
                v
+-----------------------------------------------------+
|            JVM Runtime Data Areas                   |
|                                                     |
|  +------------+   +-------------------------------+ |
|  | Method     |   | Heap                         | |
|  | Area       |   | - Objects                    | |
|  +------------+   | - Arrays                     | |
|                   +-------------------------------+ |
|  +------------+   +-------------------------------+ |
|  | JVM Stack  |   | PC Register                  | |
|  +------------+   +-------------------------------+ |
|  +------------+                                     |
|  | Native     |                                     |
|  | Stack      |                                     |
|  +------------+                                     |
+-----------------------------------------------------+
                |
                v
       +-----------------------+
       |    Execution Engine   |
       | Interpreter           |
       | JIT Compiler          |
       | Garbage Collector     |
       +-----------------------+
                |
                v
              CPU / OS

Why JVM Architecture Matters

Understanding JVM internals helps in:

• Writing optimized, high-performance code
• Fixing memory leaks
• Understanding GC behaviour
• Improving multithreading & concurrency
• Performance tuning large applications