Java Memory & Execution Model - Overview
The Java Memory & Execution Model defines how Java programs are loaded, executed, and managed inside the Java Virtual Machine (JVM). It also specifies how memory is allocated, accessed, and shared, which is crucial for thread safety and performance.
Two key components:
- JVM (Java Virtual Machine) – Executes Java bytecode.
- JMM (Java Memory Model) – Defines rules for memory visibility, ordering, and atomicity in multithreaded Java programs.
Java Execution Flow
Java execution is typically divided into four stages:
- Source Code (
.java)- Written by the developer.
- Compilation (
javac)- Converts source code into bytecode (
.class).
- Converts source code into bytecode (
- Class Loading (JVM)
- ClassLoader loads classes into method area.
- Execution (JVM Runtime)
- Interpreter or JIT compiler executes bytecode.
- Runtime data areas (stack, heap, method area) are used during execution.
JVM Memory Areas
The JVM divides memory into several regions:
| Memory Area | Purpose | Notes |
|---|---|---|
| Heap | Stores objects & class instances | Garbage-collected, shared among threads |
| Stack | Stores local variables, method calls | Thread-specific, LIFO |
| Method Area (PermGen/Metaspace) | Stores class metadata & static variables | Shared, loaded by ClassLoader |
| PC Register | Stores address of current instruction | Thread-private |
| Native Method Stack | Stores native method calls | Optional, thread-private |
Stack vs Heap
| Feature | Stack | Heap |
|---|---|---|
| Storage | Local variables, method frames | Objects & arrays |
| Lifetime | Automatic, when method exits | Until GC collects |
| Access | Fast, thread-local | Slower, shared |
| Allocation | LIFO | Dynamic |
Java Memory Model (JMM)
The JMM defines how threads interact via memory:
- Shared Variables: Heap objects are shared among threads.
- Thread-Local Variables: Stack variables are private to threads.
- Visibility: Changes made by one thread may not be immediately visible to others unless proper synchronization is used.
- Atomicity: Some operations (like
intread/write) are atomic; others requiresynchronizedorvolatile. - Ordering: Compiler/JVM may reorder instructions;
volatileandsynchronizedprovide happens-before guarantees.
Key JMM Concepts
- Volatile
- Ensures visibility across threads.
- Prevents instruction reordering.
- Synchronized
- Ensures atomicity and mutual exclusion.
- Establishes a happens-before relationship.
- Final Fields
- Immutable fields are safely published once the constructor finishes.
- Happens-Before
- A rule defining memory visibility between actions in different threads.
Execution & Memory Summary
- JVM executes bytecode using stack frames and heap objects.
- Heap stores objects; stack stores execution frames.
- JMM ensures thread-safe access and predictable behavior in concurrent programs.
- Garbage Collection automatically manages memory in the heap.
Advantages
- Platform-independent execution
- Automatic memory management
- Safe multi-threaded memory access
- High runtime performance
- Reduced memory corruption and leaks
Real-World Applications
- Enterprise applications (ERP, banking systems)
- Backend servers & APIs
- Android & mobile apps
- Cloud-based microservices
- High-performance computing systems