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).
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 int read/write) are atomic; others require synchronized or volatile.
Ordering: Compiler/JVM may reorder instructions; volatile and synchronized provide 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