JVM 内存结构

Java 虚拟机的内存空间分为 5 个部分：

程序计数器
Java 虚拟机栈
本地方法栈
堆
方法区

jvm-memory-structure

JDK 1.8 同 JDK 1.7 比，最大的差别就是：元数据区取代了永久代。元空间的本质和永久代类似，都是对 JVM 规范中方法区的实现。不过元空间与永久代之间最大的区别在于：元数据空间并不在虚拟机中，而是使用本地内存。

零基础可以先这样理解：

JVM 内存结构就是 Java 程序运行时“数据放在哪里”的规则。

如果不知道这些区域的职责，遇到 StackOverflowError、OutOfMemoryError、频繁 GC、类加载过多、直接内存溢出时，就只能盲目加内存。理解 JVM 内存结构后，才能判断问题发生在栈、堆、方法区还是堆外内存。

整体工作原理图

mermaid

flowchart TD
    A["Java 源码"] --> B["编译成 .class 字节码"]
    B --> C["类加载器加载类"]
    C --> D["方法区 / 元空间\n类信息、常量、方法元数据"]
    E["线程启动"] --> F["程序计数器\n记录当前字节码位置"]
    E --> G["虚拟机栈\n一个方法一个栈帧"]
    G --> H["局部变量表\n操作数栈\n动态链接\n返回地址"]
    I["new 对象"] --> J["堆\n对象实例、数组"]
    K["NIO / DirectByteBuffer"] --> L["直接内存\n堆外内存"]
    J --> M["垃圾收集器回收无引用对象"]
    D --> M

这张图要重点记住两条线：

类信息进入方法区或元空间，对象实例进入堆。
每个线程都有自己的程序计数器和虚拟机栈，线程之间不共享栈帧。

为什么要分这么多区域

如果 JVM 只有一块大内存，所有数据都混在一起，会出现三个问题：

方法调用的临时变量和对象实例生命周期不同，混放会增加回收难度。
多线程执行时，每个线程需要保存自己的执行位置和调用栈，必须隔离。
类信息、对象、Native 内存的来源和回收方式不同，需要不同管理策略。

所以 JVM 把内存分成线程私有区和线程共享区：

区域	是否线程私有	主要存什么	常见问题
程序计数器	是	当前线程执行到哪条字节码	几乎不会 OOM
虚拟机栈	是	方法调用栈帧、局部变量	递归过深导致 StackOverflowError
本地方法栈	是	Native 方法调用信息	Native 调用栈溢出
堆	否	对象实例、数组	Java heap space OOM、频繁 GC
方法区 / 元空间	否	类元数据、常量、方法信息	Metaspace OOM
直接内存	否	NIO 堆外缓冲区	Direct buffer memory OOM

对象和方法调用的运行流程

mermaid

sequenceDiagram
    participant T as 线程
    participant S as 虚拟机栈
    participant H as 堆
    participant M as 方法区/元空间

    T->>M: 找到类信息和方法元数据
    T->>S: 调用 main 方法，创建 main 栈帧
    T->>H: 执行 new，分配对象实例
    T->>S: 对象引用保存到局部变量表
    T->>S: 调用其他方法，继续压入新栈帧
    S-->>T: 方法返回，栈帧出栈
    H-->>H: 对象无引用后等待 GC 回收

注意：局部变量表里通常存的是对象引用，不是完整对象。完整对象一般在堆中，栈帧只是拿着“地址”去访问它。

如果不了解内存结构会怎样

现象	错误理解	正确分析方向
递归调用几万次崩溃	以为堆不够	多半是虚拟机栈深度不够
对象太多导致 OOM	只加线程栈大小	应检查堆大小、对象引用、内存泄漏
动态生成类太多	只看 heap dump	需要检查 Metaspace 和类加载器泄漏
NIO 服务 OOM	只看 `-Xmx`	还要看直接内存 `MaxDirectMemorySize`
Full GC 很频繁	只怀疑代码慢	要看老年代占用、对象晋升、引用链

可运行 Demo：观察堆溢出

下面代码持续创建对象并保存引用，对象不会被 GC 回收，最终会触发堆 OOM。

java

import java.util.ArrayList;
import java.util.List;

public class HeapOomDemo {
    public static void main(String[] args) {
        List<byte[]> list = new ArrayList<>();
        while (true) {
            list.add(new byte[1024 * 1024]);
        }
    }
}

运行：

bash

javac HeapOomDemo.java
java -Xms32m -Xmx32m HeapOomDemo

如果看到 java.lang.OutOfMemoryError: Java heap space，说明堆中对象太多且仍然被引用。这里不是栈的问题，也不是方法区的问题。

可运行 Demo：观察栈溢出

java

public class StackOverflowDemo {
    public static void main(String[] args) {
        call(1);
    }

    private static void call(int depth) {
        System.out.println(depth);
        call(depth + 1);
    }
}

运行：

bash

javac StackOverflowDemo.java
java -Xss256k StackOverflowDemo

递归每调用一次，虚拟机栈就多压入一个栈帧。栈空间不够时会出现 StackOverflowError。这能帮助你区分：堆溢出是对象太多，栈溢出是方法调用层级太深。

程序计数器（PC 寄存器）

程序计数器的定义

程序计数器是一块较小的内存空间，是当前线程正在执行的那条字节码指令的地址。若当前线程正在执行的是一个本地方法，那么此时程序计数器为Undefined。

程序计数器的作用

字节码解释器通过改变程序计数器来依次读取指令，从而实现代码的流程控制。
在多线程情况下，程序计数器记录的是当前线程执行的位置，从而当线程切换回来时，就知道上次线程执行到哪了。

程序计数器的特点

是一块较小的内存空间。
线程私有，每条线程都有自己的程序计数器。
生命周期：随着线程的创建而创建，随着线程的结束而销毁。
是唯一一个不会出现 OutOfMemoryError 的内存区域。

Java 虚拟机栈（Java 栈）

Java 虚拟机栈的定义

Java 虚拟机栈是描述 Java 方法运行过程的内存模型。

Java 虚拟机栈会为每一个即将运行的 Java 方法创建一块叫做“栈帧”的区域，用于存放该方法运行过程中的一些信息，如：

局部变量表
操作数栈
动态链接
方法出口信息
......

jvm-stack

压栈出栈过程

当方法运行过程中需要创建局部变量时，就将局部变量的值存入栈帧中的局部变量表中。

Java 虚拟机栈的栈顶的栈帧是当前正在执行的活动栈，也就是当前正在执行的方法，PC 寄存器也会指向这个地址。只有这个活动的栈帧的本地变量可以被操作数栈使用，当在这个栈帧中调用另一个方法，与之对应的栈帧又会被创建，新创建的栈帧压入栈顶，变为当前的活动栈帧。

方法结束后，当前栈帧被移出，栈帧的返回值变成新的活动栈帧中操作数栈的一个操作数。如果没有返回值，那么新的活动栈帧中操作数栈的操作数没有变化。

由于 Java 虚拟机栈是与线程对应的，数据不是线程共享的（也就是线程私有的)，因此不用关心数据一致性问题，也不会存在同步锁的问题。

局部变量表

定义为一个数字数组，主要用于存储方法参数、定义在方法体内部的局部变量，数据类型包括各类基本数据类型，对象引用，以及 return address 类型。

局部变量表容量大小是在编译期确定下来的。最基本的存储单元是 slot，32 位占用一个 slot，64 位类型（long 和 double）占用两个 slot。

对于 slot 的理解：

JVM 虚拟机会为局部变量表中的每个 slot 都分配一个访问索引，通过这个索引即可成功访问到局部变量表中指定的局部变量值。
如果当前帧是由构造方法或者实例方法创建的，那么该对象引用 this，会存放在 index 为 0 的 slot 处，其余的参数表顺序继续排列。
栈帧中的局部变量表中的槽位是可以重复的，如果一个局部变量过了其作用域，那么其作用域之后申明的新的局部变量就有可能会复用过期局部变量的槽位，从而达到节省资源的目的。

在栈帧中，与性能调优关系最密切的部分，就是局部变量表，方法执行时，虚拟机使用局部变量表完成方法的传递局部变量表中的变量也是重要的垃圾回收根节点，只要被局部变量表中直接或间接引用的对象都不会被回收。

操作数栈

栈顶缓存技术：由于操作数是存储在内存中，频繁的进行内存读写操作影响执行速度，将栈顶元素全部缓存到物理 CPU 的寄存器中，以此降低对内存的读写次数，提升执行引擎的执行效率。
每一个操作数栈会拥有一个明确的栈深度，用于存储数值，最大深度在编译期就定义好。32bit 类型占用一个栈单位深度，64bit 类型占用两个栈单位深度操作数栈。
并非采用访问索引方式进行数据访问，而是只能通过标准的入栈、出栈操作完成一次数据访问。

方法的调用

静态链接：当一个字节码文件被装载进 JVM 内部时，如果被调用的目标方法在编译期可知，且运行时期间保持不变，这种情况下降调用方的符号引用转为直接引用的过程称为静态链接。
动态链接：如果被调用的方法无法在编译期被确定下来，只能在运行期将调用的方法的符号引用转为直接引用，这种引用转换过程具备动态性，因此被称为动态链接。
方法绑定
- 早期绑定：被调用的目标方法如果在编译期可知，且运行期保持不变。
- 晚期绑定：被调用的方法在编译期无法被确定，只能够在程序运行期根据实际的类型绑定相关的方法。
非虚方法：如果方法在编译期就确定了具体的调用版本，则这个版本在运行时是不可变的，这样的方法称为非虚方法静态方法。私有方法，final 方法，实例构造器，父类方法都是非虚方法，除了这些以外都是虚方法。
虚方法表：面向对象的编程中，会很频繁的使用动态分配，如果每次动态分配的过程都要重新在类的方法元数据中搜索合适的目标的话，就可能影响到执行效率，因此为了提高性能，JVM 采用在类的方法区建立一个虚方法表，使用索引表来代替查找。
- 每个类都有一个虚方法表，表中存放着各个方法的实际入口。
- 虚方法表会在类加载的链接阶段被创建，并开始初始化，类的变量初始值准备完成之后，JVM 会把该类的方法也初始化完毕。
方法重写的本质
- 找到操作数栈顶的第一个元素所执行的对象的实际类型，记做 C。如果在类型 C 中找到与常量池中描述符和简单名称都相符的方法，则进行访问权限校验。
- 如果通过则返回这个方法的直接引用，查找过程结束；如果不通过，则返回 java.lang.IllegalAccessError 异常。
- 否则，按照继承关系从下往上依次对 C 的各个父类进行上一步的搜索和验证过程。
- 如果始终没有找到合适的方法，则抛出 java.lang.AbstractMethodError 异常。

Java 中任何一个普通方法都具备虚函数的特征（运行期确认，具备晚期绑定的特点），C++ 中则使用关键字 virtual 来显式定义。如果在 Java 程序中，不希望某个方法拥有虚函数的特征，则可以使用关键字 final 来标记这个方法。

Java 虚拟机栈的特点

运行速度特别快，仅仅次于 PC 寄存器。
局部变量表随着栈帧的创建而创建，它的大小在编译时确定，创建时只需分配事先规定的大小即可。在方法运行过程中，局部变量表的大小不会发生改变。
Java 虚拟机栈会出现两种异常：StackOverFlowError 和 OutOfMemoryError。
- StackOverFlowError 若 Java 虚拟机栈的大小不允许动态扩展，那么当线程请求栈的深度超过当前 Java 虚拟机栈的最大深度时，抛出 StackOverFlowError 异常。
- OutOfMemoryError 若允许动态扩展，那么当线程请求栈时内存用完了，无法再动态扩展时，抛出 OutOfMemoryError 异常。
HotSpot VM是不支持动态拓展的,只能通过-Xss设置容量
Java 虚拟机栈也是线程私有，随着线程创建而创建，随着线程的结束而销毁。
出现 StackOverFlowError 时，内存空间可能还有很多。

常见的运行时异常有：

NullPointerException - 空指针引用异常
ClassCastException - 类型强制转换异
IllegalArgumentException - 传递非法参数异常
ArithmeticException - 算术运算异常
ArrayStoreException - 向数组中存放与声明类型不兼容对象异常
IndexOutOfBoundsException - 下标越界异常
NegativeArraySizeException - 创建一个大小为负数的数组错误异常
NumberFormatException - 数字格式异常
SecurityException - 安全异常
UnsupportedOperationException - 不支持的操作异常

本地方法栈（C 栈）

本地方法栈的定义

本地方法栈是为 JVM 运行 Native 方法准备的空间，由于很多 Native 方法都是用 C 语言实现的，所以它通常又叫 C 栈。它与 Java 虚拟机栈实现的功能类似，只不过本地方法栈是描述本地方法运行过程的内存模型。

栈帧变化过程

本地方法被执行时，在本地方法栈也会创建一块栈帧，用于存放该方法的局部变量表、操作数栈、动态链接、方法出口信息等。

方法执行结束后，相应的栈帧也会出栈，并释放内存空间。也会抛出 StackOverFlowError 和 OutOfMemoryError 异常。

如果 Java 虚拟机本身不支持 Native 方法，或是本身不依赖于传统栈，那么可以不提供本地方法栈。如果支持本地方法栈，那么这个栈一般会在线程创建的时候按线程分配。

堆

堆的定义

堆是用来存放对象的内存空间，几乎所有的对象都存储在堆中。

堆的特点

线程共享，整个 Java 虚拟机只有一个堆，所有的线程都访问同一个堆。而程序计数器、Java 虚拟机栈、本地方法栈都是一个线程对应一个。
在虚拟机启动时创建。
是垃圾回收的主要场所。
堆可分为新生代（Eden 区：From Survivor，To Survivor）、老年代。
Java 虚拟机规范规定，堆可以处于物理上不连续的内存空间中，但在逻辑上它应该被视为连续的。
关于 Survivor s0，s1 区: 复制之后有交换，谁空谁是 to。

不同的区域存放不同生命周期的对象，这样可以根据不同的区域使用不同的垃圾回收算法，更具有针对性。

堆的大小既可以固定也可以扩展，但对于主流的虚拟机，堆的大小是可扩展的，因此当线程请求分配内存，但堆已满，且内存已无法再扩展时，就抛出 OutOfMemoryError 异常。

Java 堆所使用的内存不需要保证是连续的。而由于堆是被所有线程共享的，所以对它的访问需要注意同步问题，方法和对应的属性都需要保证一致性。

新生代与老年代

老年代比新生代生命周期长。
新生代与老年代空间默认比例 1:2：JVM 调参数，XX:NewRatio=2，表示新生代占 1，老年代占 2，新生代占整个堆的 1/3。
HotSpot 中，Eden 空间和另外两个 Survivor 空间缺省所占的比例是：8:1:1。
几乎所有的 Java 对象都是在 Eden 区被 new 出来的，Eden 放不了的大对象，就直接进入老年代了。

对象分配过程

new 的对象先放在 Eden 区，大小有限制
如果创建新对象时，Eden 空间填满了，就会触发 Minor GC，将 Eden 不再被其他对象引用的对象进行销毁，再加载新的对象放到 Eden 区，特别注意的是 Survivor 区满了是不会触发 Minor GC 的，而是 Eden 空间填满了，Minor GC 才顺便清理 Survivor 区
将 Eden 中剩余的对象移到 Survivor0 区
再次触发垃圾回收，此时上次 Survivor 下来的，放在 Survivor0 区的，如果没有回收，就会放到 Survivor1 区
再次经历垃圾回收，又会将幸存者重新放回 Survivor0 区，依次类推
默认是 15 次的循环，超过 15 次，则会将幸存者区幸存下来的转去老年区 jvm 参数设置次数 : -XX:MaxTenuringThreshold=N 进行设置
频繁在新生区收集，很少在养老区收集，几乎不在永久区/元空间搜集

Full GC /Major GC 触发条件

显示调用System.gc()，老年代的空间不够，方法区的空间不够等都会触发 Full GC，同时对新生代和老年代回收，FUll GC 的 STW 的时间最长，应该要避免
在出现 Major GC 之前，会先触发 Minor GC，如果老年代的空间还是不够就会触发 Major GC，STW 的时间长于 Minor GC

STW是在垃圾回收算法执行过程中,将jvm内存冻结,停顿的一种状态,在STW状态下,所有的线程都是停止运行的->垃圾回收线程除外

逃逸分析

对象主要在堆中分配，但这句话不是绝对的。HotSpot JIT 在编译热点代码时，会做逃逸分析：判断一个新对象的引用会不会逃出当前方法或当前线程。

如果 JIT 证明对象不会逃逸，就可能做以下优化：

优化	含义
标量替换	把对象字段拆成几个局部变量或寄存器值
分配消除	不再创建完整堆对象
锁消除	对不可能被其他线程访问的对象，去掉无意义同步

所以“对象不真正分配到堆上”更准确的理解是：JIT 可能让这个对象不再以完整对象形态存在，而不是业务代码能强制把对象放到 Java 栈上。

java

public static StringBuffer createStringBuffer(String s1, String s2) {

    StringBuffer s = new StringBuffer();

    s.append(s1);

    s.append(s2);

    return s;
}

s 是一个方法内部变量，上边的代码中直接将 s 返回，这个 StringBuffer 的对象有可能被其他方法所改变，导致它的作用域就不只是在方法内部，即使它是一个局部变量，但还是逃逸到了方法外部，称为方法逃逸。

还有可能被外部线程访问到，譬如赋值给类变量或可以在其他线程中访问的实例变量，称为线程逃逸。

在 JDK 7、JDK 8 常见 HotSpot Server VM 中，逃逸分析是非常重要的默认 JIT 优化能力。可以用 -XX:-DoEscapeAnalysis 做实验对比关闭效果，但生产代码不能依赖某次分配一定被优化。

详细原理、流程图、可运行 Demo、面试回答见：JIT逃逸分析。

TLAB

TLAB 的全称是 Thread Local Allocation Buffer，中文常叫线程本地分配缓冲区。

最重要的结论：TLAB 属于堆，而且属于新生代 Eden 区的一部分。它不是 Java 虚拟机栈，也不是一个新的运行时数据区。

mermaid

flowchart TD
    A["Java 堆"] --> B["新生代"]
    A --> C["老年代"]
    B --> D["Eden 区"]
    B --> E["Survivor 区"]
    D --> F["线程 A 的 TLAB"]
    D --> G["线程 B 的 TLAB"]
    D --> H["Eden 公共分配区域"]

为什么需要 TLAB？因为堆是线程共享的。多个线程同时 new 对象时，如果都去竞争 Eden 里的同一个全局分配指针，就需要 CAS、失败重试或其他同步机制来保证分配指针不会乱。对象分配虽然很快，但在高并发场景下，全局竞争仍然会产生额外成本。

TLAB 的做法是：JVM 先从 Eden 区里给每个线程划出一小块私有区域。线程创建小对象时，优先在自己的 TLAB 里分配，只需要移动自己 TLAB 里的分配指针，通常不需要和其他线程竞争。

mermaid

flowchart TD
    A["线程执行 new"] --> B{"当前 TLAB 空间是否足够"}
    B -- "足够" --> C["在自己的 TLAB 中快速分配"]
    B -- "不足" --> D{"是否还能申请新 TLAB"}
    D -- "可以" --> E["从 Eden 重新划分 TLAB"]
    D -- "不可以或对象太大" --> F["走 Eden 慢路径分配"]
    F --> G{"Eden 是否还有空间"}
    G -- "有" --> H["在 Eden 公共区域分配"]
    G -- "没有" --> I["可能触发 Minor GC"]

TLAB 要和逃逸分析区分开：

概念	是否属于堆	是否真实创建对象	解决什么问题
Eden 普通分配	是	是	普通新对象分配
TLAB 分配	是，属于 Eden	是	减少多线程分配竞争
逃逸分析后的分配消除	不一定进入堆	可能不创建完整对象	减少短命对象堆分配和 GC 压力

所以，对象如果分配在 TLAB 中，本质上仍然是在堆里，仍然受 GC 管理。Minor GC 回收 Eden 时，也会处理 TLAB 中已经分配出来的对象。TLAB 只是让“堆内分配”更快，不代表对象进入了栈。

并不是所有对象都能在 TLAB 中分配成功。常见情况包括：

情况	结果
对象很小且 TLAB 空间足够	直接在当前线程 TLAB 分配
TLAB 空间不足	申请新 TLAB 或走慢路径
对象太大	可能绕过 TLAB，在 Eden 公共区域或老年代分配
Eden 空间不足	可能触发 Minor GC

常见参数：

参数	说明
`-XX:+UseTLAB`	开启 TLAB，常见 HotSpot 默认开启
`-XX:-UseTLAB`	关闭 TLAB，用于实验对比
`-XX:TLABSize`	设置 TLAB 大小，生产一般不建议随意手动指定

面试可以这样回答：TLAB 是 Eden 区中为每个线程预留的一小块线程私有分配区域，属于堆，不属于栈。对象分配在 TLAB 中仍然是真实堆对象，仍然会被 GC 管理。TLAB 的作用是减少多线程在 Eden 分配对象时的竞争；逃逸分析则是 JIT 优化，可能让某些不逃逸对象不真正创建完整堆对象。

四种引用方式

强引用：创建一个对象并把这个对象赋给一个引用变量，普通 new 出来对象的变量引用都是强引用，有引用变量指向时永远不会被垃圾回收，jvm 即使抛出 OOM，可以将引用赋值为 null，那么它所指向的对象就会被垃圾回收。
软引用：如果一个对象具有软引用，内存空间足够，垃圾回收器就不会回收它，如果内存空间不足了，就会回收这些对象的内存。只要垃圾回收器没有回收它，该对象就可以被程序使用。
弱引用：非必需对象，当 JVM 进行垃圾回收时，无论内存是否充足，都会回收被弱引用关联的对象。
虚引用：虚引用并不会决定对象的生命周期，如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收器回收。

方法区

方法区的定义

Java 虚拟机规范中定义方法区是堆的一个逻辑部分。方法区存放以下信息：

已经被虚拟机加载的类信息
常量
静态变量
即时编译器编译后的代码

方法区的特点

线程共享。方法区是堆的一个逻辑部分，因此和堆一样，都是线程共享的。整个虚拟机中只有一个方法区。
永久代。方法区中的信息一般需要长期存在，而且它又是堆的逻辑分区，因此用堆的划分方法，把方法区称为“永久代”。
内存回收效率低。方法区中的信息一般需要长期存在，回收一遍之后可能只有少量信息无效。主要回收目标是：对常量池的回收；对类型的卸载。
Java 虚拟机规范对方法区的要求比较宽松。和堆一样，允许固定大小，也允许动态扩展，还允许不实现垃圾回收。

运行时常量池

方法区中存放：类信息、常量、静态变量、即时编译器编译后的代码。常量就存放在运行时常量池中。

当类被 Java 虚拟机加载后， .class 文件中的常量就存放在方法区的运行时常量池中。而且在运行期间，可以向常量池中添加新的常量。如 String 类的 intern() 方法就能在运行期间向常量池中添加字符串常量。

直接内存（堆外内存）

直接内存是除 Java 虚拟机之外的内存，但也可能被 Java 使用。

操作直接内存

在 NIO 中引入了一种基于通道和缓冲的 IO 方式。它可以通过调用本地方法直接分配 Java 虚拟机之外的内存，然后通过一个存储在堆中的DirectByteBuffer对象直接操作该内存，而无须先将外部内存中的数据复制到堆中再进行操作，从而提高了数据操作的效率。

直接内存的大小不受 Java 虚拟机控制，但既然是内存，当内存不足时就会抛出 OutOfMemoryError 异常。

直接内存与堆内存比较

直接内存申请空间耗费更高的性能
直接内存读取 IO 的性能要优于普通的堆内存
直接内存作用链：本地 IO -> 直接内存 -> 本地 IO
堆内存作用链：本地 IO -> 直接内存 -> 非直接内存 -> 直接内存 -> 本地 IO

服务器管理员在配置虚拟机参数时，会根据实际内存设置-Xmx等参数信息，但经常忽略直接内存，使得各个内存区域总和大于物理内存限制，从而导致动态扩展时出现OutOfMemoryError异常。

JDK 8/11/17/21 LTS演进

线程池

JVM 内存结构 ​

整体工作原理图 ​

为什么要分这么多区域 ​

对象和方法调用的运行流程 ​

如果不了解内存结构会怎样 ​

可运行 Demo：观察堆溢出 ​

可运行 Demo：观察栈溢出 ​

程序计数器（PC 寄存器） ​

程序计数器的定义 ​

程序计数器的作用 ​

程序计数器的特点 ​

Java 虚拟机栈（Java 栈） ​

Java 虚拟机栈的定义 ​

压栈出栈过程 ​

局部变量表 ​

操作数栈 ​

方法的调用 ​

Java 虚拟机栈的特点 ​

本地方法栈（C 栈） ​

本地方法栈的定义 ​

栈帧变化过程 ​

堆 ​

堆的定义 ​

堆的特点 ​

新生代与老年代 ​

对象分配过程 ​

Full GC /Major GC 触发条件 ​

逃逸分析 ​

TLAB ​

四种引用方式 ​

方法区 ​

方法区的定义 ​

方法区的特点 ​

运行时常量池 ​

直接内存（堆外内存） ​

操作直接内存 ​

直接内存与堆内存比较 ​

JVM 内存结构

整体工作原理图

为什么要分这么多区域

对象和方法调用的运行流程

如果不了解内存结构会怎样

可运行 Demo：观察堆溢出

可运行 Demo：观察栈溢出

程序计数器（PC 寄存器）

程序计数器的定义

程序计数器的作用

程序计数器的特点

Java 虚拟机栈（Java 栈）

Java 虚拟机栈的定义

压栈出栈过程

局部变量表

操作数栈

方法的调用

Java 虚拟机栈的特点

本地方法栈（C 栈）

本地方法栈的定义

栈帧变化过程

堆

堆的定义

堆的特点

新生代与老年代

对象分配过程

Full GC /Major GC 触发条件

逃逸分析

TLAB

四种引用方式

方法区

方法区的定义

方法区的特点

运行时常量池

直接内存（堆外内存）

操作直接内存

直接内存与堆内存比较