Java 运行时内存（JVM 内存模型）是 JVM 管理内存的核心规范，HotSpot 作为主流 JVM 实现，将运行时内存划分为线程私有区域和线程共享区域，此外还有直接内存（非 JVM 规范定义，但实际开发中高频关联）。理解运行时内存是排查内存泄漏、OOM 异常、优化 GC 性能的基础。

一、整体架构（HotSpot JVM）

JVM 运行时内存严格遵循《Java 虚拟机规范》，核心分为 5 个区域（前 3 个线程私有，后 2 个线程共享），外加直接内存（堆外内存）：

内存区域

归属

核心作用

是否发生 GC

是否抛出 OOM

程序计数器

线程私有

记录当前线程执行的字节码指令地址

否（无回收必要）

否（唯一不会 OOM 的区域）

虚拟机栈

线程私有

存储方法执行的栈帧（局部变量、操作数等）

否（栈帧随方法结束销毁）

是（栈扩容时）

本地方法栈

线程私有

支持 Native 方法（C/C++ 实现）的执行

否

是

堆

线程共享

存储所有对象实例和数组，GC 核心区域

是（核心回收区域）

是（最常见 OOM）

方法区（元空间）

线程共享

存储类信息、常量池、静态变量等

是（元空间有回收）

是

直接内存（堆外）

非规范定义

NIO 直接内存操作，绕过堆内存限制

否（手动释放）

是

二、线程私有区域（每个线程独立分配，随线程销毁释放）

1. 程序计数器（Program Counter Register）

核心定义

计数器：本质是一块很小的内存空间，相当于线程的执行进度条，记录当前线程正在执行的字节码指令的地址（偏移量）；多线程适配：CPU 切换线程时，程序计数器会记录每个线程的执行位置，切换回线程时能恢复到正确的执行点；Native 方法适配：若线程执行的是 Native 方法，程序计数器值为 undefined（因为 Native 方法由 C/C++ 执行，无字节码地址）。

关键特性

线程私有：每个线程有独立的程序计数器，互不干扰；无 GC 回收：计数器仅记录地址，无内存分配 / 释放，无需 GC；无 OOM：内存空间固定且极小，JVM 不会为其分配更多内存，因此永远不会抛出 OutOfMemoryError。

2. 虚拟机栈（Java Virtual Machine Stacks）

核心定义

方法执行栈：每个方法被调用时，JVM 会创建一个栈帧（Stack Frame）并压入虚拟机栈；方法执行完毕，栈帧弹出并销毁；线程私有：每个线程有独立的虚拟机栈，栈的生命周期与线程一致；栈深度限制：虚拟机栈有固定的最大深度，超过则抛出 StackOverflowError。

栈帧结构（方法执行的最小单元）

栈帧包含 4 个核心部分，按顺序布局

栈帧（Stack Frame）├── 局部变量表（Local Variable Table）├── 操作数栈（Operand Stack）├── 动态链接（Dynamic Linking）└── 方法返回地址（Return Address）

（1）局部变量表

存储内容：方法的局部变量（基本类型 byte/short/int/long/float/double/char/boolean、引用类型 reference、返回值地址 returnAddress）；槽位（Slot）：局部变量表以槽位为单位，每个槽位占 4 字节；long/double 占 2 个槽位，其余类型占 1 个；特性：编译期确定大小（方法的 Code 属性中记录局部变量表的槽位数），运行时不可变。

（2）操作数栈

作用：方法执行过程中临时存储计算结果，作为指令的操作数；示例：执行 int a = 1 + 2 时，先将 1、2 压入操作数栈，执行加法指令弹出两个数，计算结果 3 压回栈，再存入局部变量表。

（3）动态链接

作用：将栈帧中的符号引用（如方法名、类名）解析为直接引用（内存地址）；特性：懒加载（仅在方法调用时解析），避免初始化时解析所有引用的开销。

（4）方法返回地址

作用：记录方法执行完毕后，返回调用方的字节码地址；两种返回方式：正常返回：执行 return 指令，返回地址来自操作数栈；异常返回：未捕获异常，返回地址来自异常处理器表。

核心异常

（1）StackOverflowError（栈溢出）

触发场景：方法递归调用次数过多，导致虚拟机栈深度超过最大限制；示例：无限递归调用方法：public class StackOverflowDemo { public static void recursive() { recursive(); // 无限递归 } public static void main(String[] args) { recursive(); // 抛出 StackOverflowError }}调优参数：-Xss（设置栈大小，如 -Xss1m，默认 1MB 左右）。

（2）OutOfMemoryError（栈内存不足）

触发场景：虚拟机栈允许动态扩容（部分 JVM 实现），但扩容时内存不足；或创建大量线程，每个线程分配的栈内存总和超过物理内存；示例：创建 10000 个线程（每个线程栈 1MB），物理内存 8GB 时会触发 OOM：public class StackOOMDemo { public static void main(String[] args) { for (int i = 0; i < 10000; i++) { new Thread(() -> { try { Thread.sleep(Integer.MAX_VALUE); } catch (InterruptedException e) {} }).start(); } }}

3. 本地方法栈（Native Method Stacks）

核心定义

作用：为 Native 方法（用 native 修饰的方法，如 System.currentTimeMillis()）提供执行环境；与虚拟机栈的区别：虚拟机栈服务于 Java 方法，本地方法栈服务于 Native 方法；实现：HotSpot 直接将虚拟机栈和本地方法栈合并，共用同一块内存区域。

核心异常

StackOverflowError：Native 方法递归调用过深；OutOfMemoryError：本地方法栈扩容失败或创建过多线程。三、线程共享区域（所有线程共享，GC 核心操作区域）

1. 堆（Heap）—— GC 最核心的区域

核心定义

对象存储区：Java 中几乎所有对象实例、数组都分配在堆中（逃逸分析优化后，部分对象可栈上分配）；线程共享：所有线程可访问堆中的对象，需通过同步机制保证线程安全；分代管理：为优化 GC 效率，堆被划分为「新生代」和「老年代」（JDK8 后取消永久代，堆仅包含新生代 + 老年代）。

堆的分代模型（HotSpot 核心设计）

堆的默认比例：新生代占 1/3，老年代占 2/3（可通过 -XX:NewRatio 调整，如 -XX:NewRatio=2 表示老年代：新生代 = 2:1）。

堆（Heap）├── 新生代（Young Generation）：占 1/3│ ├── Eden 区：占新生代 8/10│ ├── Survivor 0 区（S0/From）：占新生代 1/10│ └── Survivor 1 区（S1/To）：占新生代 1/10└── 老年代（Old Generation）：占 2/3

（1）新生代（Young Generation）

存储对象：刚创建的对象（除大对象外）；GC 类型：Minor GC（新生代 GC），频率高、速度快（复制算法）；核心流程（复制算法）：新对象分配到 Eden 区，Eden 满时触发 Minor GC；Eden 中存活的对象复制到 S0 区，Eden 清空；下次 Minor GC 时，Eden + S0 存活对象复制到 S1 区，Eden + S0 清空；重复上述过程，对象在 S0/S1 之间复制，每次复制年龄 + 1；当对象年龄达到阈值（默认 15，-XX:MaxTenuringThreshold），进入老年代。

（2）老年代（Old Generation）

存储对象：存活时间长的对象（新生代晋升的对象）、大对象（直接分配到老年代，-XX:PretenureSizeThreshold 设置阈值）；GC 类型：Major GC/Full GC（老年代 GC），频率低、速度慢（标记 - 清除 / 标记 - 整理算法）；触发条件：老年代空间不足、Minor GC 后晋升老年代的对象超过老年代剩余空间。

堆的关键配置参数

参数

作用

默认值（HotSpot）

-Xms

堆初始大小（新生代 + 老年代）

物理内存 1/64

-Xmx

堆最大大小

物理内存 1/4

-XX:NewRatio

老年代 / 新生代比例（如 2 表示 2:1）

2

-XX:SurvivorRatio

Eden/Survivor 比例（如 8 表示 Eden:S0:S1=8:1:1）

8

-XX:MaxTenuringThreshold

对象晋升老年代的年龄阈值

15

-XX:PretenureSizeThreshold

大对象直接进入老年代的阈值

0（JDK8 默认不限制）

堆的核心异常：OutOfMemoryError: Java heap space

触发场景：创建大量对象（如循环创建大数组），堆内存不足且 GC 无法回收；示例：public class HeapOOMDemo { public static void main(String[] args) { List<byte[]> list = new ArrayList<>(); while (true) { list.add(new byte[1024 * 1024]); // 每次添加 1MB 数组 } }}解决思路：调大 -Xmx、排查内存泄漏（如静态集合未清理）、优化对象生命周期（减少大对象创建）。

2. 方法区（Method Area）—— 元空间（Metaspace）

核心定义

类信息存储区：存储已加载的类信息（类名、访问修饰符、字段 / 方法信息）、常量池、静态变量、即时编译器编译后的代码等；线程共享：所有线程可访问方法区中的类信息；永久代 vs 元空间：JDK7 及之前：方法区称为永久代（PermGen），属于堆的一部分，有固定大小限制；JDK8 及之后：取消永久代，改用元空间（Metaspace），使用本地内存（操作系统内存），默认无大小限制（受物理内存限制）。

永久代 vs 元空间（核心区别）

特性

永久代（JDK7-）

元空间（JDK8+）

内存来源

JVM 堆内存

操作系统本地内存

大小限制

固定（-XX:PermSize/-XX:MaxPermSize）

无默认限制（-XX:MetaspaceSize/-XX:MaxMetaspaceSize）

OOM 风险

高（永久代满则 OOM）

低（仅本地内存不足时 OOM）

回收机制

仅 Full GC 回收

类卸载时自动回收

元空间的核心存储内容

元空间（Metaspace）├── 类元数据（Class Metadata）：类名、字段、方法、继承关系等├── 运行时常量池（Runtime Constant Pool）：字符串常量、符号引用等├── 静态变量（Static Variables）：类的静态成员变量└── 方法字节码：类的方法字节码指令

运行时常量池（Runtime Constant Pool）

来源：编译期生成的「常量池表」（字节码 ConstantPool 属性）在类加载后进入运行时常量池；动态性：运行时可新增常量（如 String.intern()）；示例：String s = new String("abc") 会在常量池创建 "abc"，堆中创建 String 对象；s.intern() 会返回常量池中的 "abc" 引用。

元空间的关键配置参数

参数

作用

默认值

-XX:MetaspaceSize

元空间初始大小

21MB（64 位）

-XX:MaxMetaspaceSize

元空间最大大小

无限制（受物理内存限制）

-XX:MinMetaspaceFreeRatio

元空间最小空闲比例（低于则扩容）

40%

-XX:MaxMetaspaceFreeRatio

元空间最大空闲比例（高于则缩容）

70%

元空间的核心异常：OutOfMemoryError: Metaspace

触发场景：动态生成大量类（如反射、动态代理、框架（Spring/CGLIB）），元空间内存不足；示例（CGLIB 动态生成类导致元空间 OOM）：import net.sf.cglib.proxy.Enhancer;import net.sf.cglib.proxy.MethodInterceptor;public class MetaspaceOOMDemo { public static void main(String[] args) { while (true) { Enhancer enhancer = new Enhancer(); enhancer.setSuperclass(Object.class); enhancer.setCallback((MethodInterceptor) (obj, method, args1, proxy) -> proxy.invokeSuper(obj, args1)); enhancer.create(); // 动态生成类，消耗元空间 } }}解决思路：调大 -XX:MaxMetaspaceSize、减少动态类生成、排查类卸载失败（如类加载器泄漏）。四、直接内存（Direct Memory）—— 堆外内存

核心定义

非规范区域：不在 JVM 运行时数据区规范中，属于操作系统的直接内存；NIO 优化：Java NIO 的 DirectByteBuffer 用于操作直接内存，避免堆内存和本地内存之间的拷贝（减少数据复制开销）；手动管理：直接内存的分配 / 释放由 Unsafe 类控制（Unsafe.allocateMemory()/Unsafe.freeMemory()），GC 不会自动回收，需手动释放或依赖虚引用（PhantomReference）。

核心特性

内存来源：操作系统本地内存，不受 -Xmx 限制（但受物理内存限制）；分配开销：比堆内存高，但访问速度快（减少 JVM 与操作系统的内存拷贝）；回收机制：DirectByteBuffer 关联的虚引用（Cleaner）在对象被 GC 时触发直接内存释放。

直接内存的核心异常：OutOfMemoryError: Direct buffer memory

触发场景：分配大量直接内存（如 ByteBuffer.allocateDirect(1024*1024*100)），超出物理内存限制；调优参数：-XX:MaxDirectMemorySize（设置直接内存最大大小，默认等于 -Xmx）；示例：import java.nio.ByteBuffer;public class DirectMemoryOOMDemo { public static void main(String[] args) { int size = 1024 * 1024 * 100; // 100MB while (true) { ByteBuffer buffer = ByteBuffer.allocateDirect(size); // 分配直接内存 } }}五、核心机制：对象分配与回收流程

1. 对象分配流程（默认规则）

新对象优先分配到 Eden 区（逃逸分析优化后可栈上分配）；Eden 满触发 Minor GC，存活对象复制到 S0 区；下次 Minor GC，Eden + S0 存活对象复制到 S1 区，对象年龄 + 1；对象年龄达到阈值（默认 15），晋升到老年代；大对象（超过阈值）直接分配到老年代；老年代满触发 Major GC/Full GC，回收老年代对象。

2. 内存回收（GC）核心规则

回收目标：仅回收不可达对象（无任何引用指向的对象）；回收算法：新生代：复制算法（效率高，内存碎片少）；老年代：标记 - 清除 / 标记 - 整理算法（适应大对象、长存活对象）；元空间：类卸载（类加载器被回收时，其加载的类元数据被回收）；回收触发：Minor GC：Eden 区满；Major GC：老年代空间不足；Full GC：Minor GC 后晋升失败、元空间满、调用 System.gc() 等。六、常见内存问题排查

1. 堆溢出（OOM: Java heap space）

排查工具：jmap（导出堆快照 jmap -dump:format=b,file=heap.hprof <pid>）、MAT/JProfiler（分析堆快照）；排查步骤：导出堆快照；分析快照中占比最高的对象；定位对象被哪些引用持有（如静态集合、线程池）；优化对象生命周期或调大堆内存。

2. 栈溢出（StackOverflowError）

排查方向：递归调用过深、方法嵌套层级过多；解决：减少递归深度、调大 -Xss。

3. 元空间溢出（OOM: Metaspace）

排查工具：jcmd <pid> VM.metaspace（查看元空间使用情况）；排查方向：动态生成类过多、类加载器泄漏（如自定义类加载器未释放）；解决：调大 -XX:MaxMetaspaceSize、减少动态类生成、修复类加载器泄漏。

4. 直接内存溢出（OOM: Direct buffer memory）

排查工具：jconsole（查看直接内存使用）；解决：调大 -XX:MaxDirectMemorySize、手动释放直接内存（ByteBuffer.clear()）。七、总结JVM 运行时内存分为线程私有（程序计数器、虚拟机栈、本地方法栈）和线程共享（堆、元空间），外加直接内存；程序计数器是唯一不会 OOM 的区域，虚拟机栈易触发 StackOverflowError；堆是 GC 核心区域，分代管理（新生代 + 老年代）优化回收效率；元空间替代永久代，使用本地内存，避免永久代 OOM；直接内存用于 NIO 优化，需手动管理，避免堆外内存泄漏。

理解 Java 运行时内存是掌握 JVM 调优、排查内存问题的基础，尤其是堆、元空间、直接内存的 OOM 排查，是开发和面试中的核心点。