MindMap Gallery Mind Map: Java Memory Management

Mind Map: Java Memory Management

Java Memory Management is crucial for optimizing application performance. It comprises several key areas 1. Java Memory Areas: Includes the Heap, Stack, Method Area, Program Counter Register, and Native Method Stack, each serving distinct purposes for object storage, method execution, and metadata handling. 2. Object Lifetime & Allocation Flow: Details how objects are allocated in the Heap, promoted through generations, and handled differently based on their size. 3. Garbage Collection (GC) Mechanism: Explains how GC reclaims memory, identifies unreachable objects, and describes various collection types like Minor, Major, and Full GC. 4. GC Implementations: Discusses different strategies, including Serial, Parallel, and CMS, highlighting their performance implications. Understanding these components enhances the efficiency of Java applications and minimizes memory-related issues.

Edited at 2026-03-25 15:27:27

WSA0NEFs

Recent works View more works>>

Mind Map: Java Memory Management

WSA0NEFs

Recent works View more works>>

Recommended to you
Outline

Java内存管理导图
- 5
WSNG3jTL
Java Memory Management Diagram
- 12
WSA0NEFs

Java Memory Management

Java Memory Areas (JVM Runtime Data Areas)

Heap

Purpose: stores objects and arrays (shared across threads)

Structure

Young Generation

Eden

Survivor (S0, S1)

Old (Tenured) Generation

(Optional) Humongous/Region-based layout in G1

Characteristics

Main area managed by Garbage Collection (GC)

Size typically controlled by `-Xms`, `-Xmx`

Stack (Java Virtual Machine Stack)

Purpose: stores per-thread call frames (not shared)

Contains (per frame)

Local variables (primitives, object references)

Operand stack

Return info / constant pool reference

Characteristics

Allocated/freed on method call/return (LIFO)

Errors: `StackOverflowError`, `OutOfMemoryError: unable to create new native thread`

Method Area (a.k.a. Metaspace / formerly PermGen)

Purpose: class-level metadata

Stores

Class metadata (fields, methods, inheritance info)

Runtime constant pool

Static variables

JIT-compiled code metadata (implementation-dependent)

Characteristics

In HotSpot (Java 8+): Metaspace uses native memory

Tuning: `-XX:MaxMetaspaceSize`

Program Counter (PC) Register

Purpose: per-thread pointer to current bytecode instruction

Characteristics

Very small, thread-private

Supports correct resumption after context switches

Native Method Stack

Purpose: supports JNI/native calls

Characteristics

Similar to JVM stack but for native frames

Object Lifetime & Allocation Flow

Allocation (typical)

New objects allocated in Eden (Heap)

References placed on Stack locals/fields

Promotion

Surviving objects copied between Survivor spaces

After aging threshold / space pressure → promoted to Old generation

Large objects

May be allocated directly into Old generation (collector/setting dependent)

Garbage Collection (GC) Mechanism

What GC does

Automatically reclaims heap memory by removing unreachable objects

May also compact memory to reduce fragmentation

Reachability (how “garbage” is identified)

GC Roots (starting points)

Thread stacks (local variables)

Static references in Method Area

JNI references (Native Method Stack)

JVM internal references (e.g., class loaders)

Traversal

Mark reachable objects from roots

Unmarked objects are eligible for collection

Collection Types

Minor GC (Young GC)

Focus: Young generation (Eden + Survivors)

Usually frequent and fast (copying/evacuation)

Major GC / Old GC

Focus: Old generation (often involves compaction)

Less frequent, typically more expensive

Full GC

Collects: Young + Old + (sometimes) Metaspace/class unloading

Typically the most disruptive

Common Algorithms

Mark-Sweep

Mark reachable, sweep unreachable

Issue: fragmentation

Mark-Compact

Mark reachable, then compact to eliminate fragmentation

Higher pause cost but better locality

Copying (Evacuation)

Copy live objects to a new space, reclaim the rest

Efficient for young gen with many dead objects

Generational Hypothesis (why generations exist)

Most objects die young

Separating young/old reduces GC cost by focusing frequent work on young

GC Implementations (High Level)

Serial GC

Single-threaded GC, simpler, longer pauses

Parallel GC

Multi-threaded young/old collection, throughput-oriented

CMS (deprecated/removed in newer versions)

Concurrent marking/sweeping to reduce pauses, fragmentation risk

G1 GC

Region-based heap, tries to meet pause-time goals (`-XX:MaxGCPauseMillis`)

Mixed collections (young + selected old regions)

ZGC / Shenandoah

Low-pause collectors with concurrent compaction (large heaps friendly)

Stop-The-World (STW) Pauses

Meaning: application threads paused for certain GC phases

Affected by

Heap size, allocation rate, live data size

Collector choice and tuning

Object graph complexity and reference patterns

Key Practical Notes

Memory leaks in Java

Typically “unintentional object retention” (references kept reachable)

Common sources: caches, static collections, listeners, ThreadLocals

Finalization/clean-up

Prefer `try-with-resources` / `AutoCloseable` over finalizers

Cleaners/phantom references for special cases

Observability & Diagnostics (examples)

GC logs: `-Xlog:gc*` (JDK 9+)

Heap dump on OOM: `-XX:+HeapDumpOnOutOfMemoryError`

Tools: JFR, jcmd, VisualVM, JMC