MindMap Gallery Java Memory Management Diagram

Java Memory Management Diagram

Discover the intricate world of Java Memory Management, a vital aspect of efficient application performance. This overview covers essential memory divisions including the heap, stack, method area, PC register, and native method stack, highlighting their purposes and characteristics. Explore the object lifecycle from creation to promotion and reachability, along with garbage collection mechanisms that ensure efficient memory use. Key concepts like Stop-The-World pauses, minor and major GC, and various algorithms such as Mark-Sweep and Copying are discussed. Finally, familiarize yourself with common JVM garbage collectors and best practices for resource cleanup. Understanding these elements is crucial for optimizing Java applications.

Edited at 2026-03-25 13:44:50

WSA0NEFs

Recent works View more works>>

Java Memory Management Diagram

WSA0NEFs

Recent works View more works>>

Recommended to you
Outline

Java内存管理导图
- 5
WSNG3jTL
Mind Map: Java Memory Management
- 9
WSA0NEFs

Java Memory Management Diagram

Memory Divisions (Runtime Data Areas)

Heap

Purpose: Stores objects and arrays (shared across threads)

Characteristics

Managed by Garbage Collector (GC)

Typically the largest memory area

Subject to fragmentation and compaction (depending on GC)

Common Structure (HotSpot)

Young Generation

Eden Space

Survivor Spaces (S0/S1)

Old (Tenured) Generation

(Optional) Large/Object Humongous Regions (GC-dependent, e.g., G1)

Stack (Java Virtual Machine Stack)

Purpose: Stores per-thread call frames for method execution

Contents of a Stack Frame

Local variables (primitives, object references)

Operand stack (intermediate computations)

Return address / bookkeeping

Characteristics

Thread-private (no sharing)

LIFO allocation/deallocation (fast)

Errors: StackOverflowError (deep recursion/large frames)

Method Area

Purpose: Stores class-level metadata

Contains

Class structure (fields, methods, modifiers)

Runtime constant pool

Method bytecode / metadata

Static variables (class variables)

Implementations

HotSpot: Metaspace (native memory) in modern JVMs

Earlier: PermGen (deprecated/removed)

PC Register

Purpose: Per-thread pointer to current bytecode instruction (or native execution state)

Characteristics: Small, thread-private

Native Method Stack

Purpose: Supports JNI/native calls (C/C++)

Characteristics: Per-thread, similar to JVM stack in behavior

JVM memory is split into shared heap for objects plus per-thread execution areas and class metadata storage.

Object Lifecycle & Reference Flow

Creation

new allocates object memory on heap (typically in Eden)

Reference stored in stack local variables or in heap fields

Promotion (Aging)

Surviving objects move between Survivor spaces

After thresholds, promoted to Old generation

Reachability (What keeps objects alive)

GC roots

Thread stacks (locals)

Static references (method area)

JNI references (native)

Reachability graph determines live vs. garbage

Garbage Collection Mechanisms

Key Concepts

Stop-The-World (STW) pauses: some phases halt application threads

Minor GC vs. Major/Full GC

Minor GC: Young generation collection (frequent, usually short)

Major/Old GC: Old generation collection (less frequent, heavier)

Full GC: Typically whole-heap + metaspace/class unloading (implementation-dependent)

Throughput vs. Latency trade-offs

Common Algorithms

Mark-Sweep

Marks reachable objects, sweeps unreachable ones

Can cause fragmentation

Mark-Compact

Marks then compacts to reduce fragmentation

More pause cost, better locality

Copying (Young Gen typical)

Copies live objects to Survivor/Old, clears source region

Efficient when most objects die young

Generational Hypothesis

Most objects are short-lived

Split heap into generations to optimize collections

Major GC Triggers (Typical)

Old generation occupancy pressure / allocation failure

Metaspace pressure (class loading) and potential class unloading cycles

Explicit calls (System.gc()) (may be ignored/controlled by flags)

Finalization & Cleanup (Important Notes)

finalize() is deprecated; unpredictable and expensive

Prefer try-with-resources / Cleaner / explicit close for resources

Common JVM Garbage Collectors (High Level)

Serial GC

Single-threaded GC, simple; best for small heaps

Parallel GC (Throughput GC)

Multi-threaded young/old collection; aims for throughput

G1 GC

Heap split into regions; incremental, targets pause times

Concurrent marking; evacuation to reduce fragmentation

ZGC / Shenandoah (Low-Latency)

Mostly concurrent; very short pauses

Designed for large heaps and low pause targets

Collector choice is mainly a balance between simplicity, throughput, and pause-time goals.

Typical Error/Issue Map

OutOfMemoryError: Java heap space

Heap exhausted, leaks, high allocation rate

OutOfMemoryError: Metaspace

Excessive class loading, classloader leaks

StackOverflowError

Deep recursion, large local allocations

GC Overhead Limit Exceeded

GC spending too much time reclaiming too little memory

Practical Tuning & Observability (Essentials)

Key Levers

Heap sizing: -Xms, -Xmx

GC selection: -XX:+UseG1GC / ZGC / etc.

Metaspace sizing: -XX:MaxMetaspaceSize

Monitoring/Diagnostics

GC logs (unified logging): -Xlog:gc*

JFR (Java Flight Recorder)

jcmd, jmap, jstack for runtime inspection