1. 什么是 Java 堆（Heap）？#

💡 核心特征：

• 线程共享：所有线程共享同一个堆内存空间，在 JVM 启动时创建。
• 主要作用：主要用于保存 对象实例、数组 等。几乎所有的对象实例和数组都在这里分配内存。
• 异常机制：堆是垃圾回收（GC）管理的主要区域。当堆内存不足且无法继续扩展时，JVM 会抛出 OutOfMemoryError: Java heap space 异常。

2. 堆的内存组成划分#

Java 堆在结构上主要划分为：年轻代（Young Generation） 和 老年代（Old Generation）（默认空间大小比例为 1 : 2）：

3. JDK 1.7 与 JDK 1.8 的核心区别（永久代 vs 元空间）#

1. 什么是虚拟机栈（JVM Stacks）？#

💡 核心概念：

• 线程私有：每个线程在运行时所需要的内存空间，称为虚拟机栈。生命周期与线程相同。
• 栈帧（Frame）：每个栈由多个栈帧组成。每个方法被调用时都会创建一个栈帧，对应着该方法调用所占用的内存（存储参数、局部变量、返回地址等）。
• 先进后出（LIFO）：方法调用即“压栈（Push）”，方法执行完毕即“出栈（Pop）”。
• 活动栈帧：每个线程在任意时刻只能有一个活动栈帧，对应着当前正在执行的那个方法（即位于栈顶的栈帧）。

栈帧的“先进后出（LIFO）”与执行顺序关系#

• 核心规律：
  • 最先调用的方法最先入栈（在栈底），但最后执行完（最后出栈）。
  • 最后调用的方法最后入栈（在栈顶），但最先执行完（最先出栈）。
• 为什么活动栈帧永远是栈顶？
  • JVM 的程序计数器（PC 寄存器）和执行引擎在任意时刻只针对栈顶栈帧执行字节码指令。
  • 栈下方的其他栈帧处于挂起/等待状态，完整保存着自己的局部变量和现场数据，等待上层方法执行完毕并返回。

1
public class StackDemo {
2
    public static void main(String[] args) {
3
        System.out.println("1. main 开始");
4
        methodA();
5
        System.out.println("5. main 结束");
6
    }
7

8
    public static void methodA() {
9
        System.out.println("2. methodA 开始");
10
        methodB();
11
        System.out.println("4. methodA 恢复执行并结束");
12
    }
13

14
    public static void methodB() {
15
        System.out.println("3. methodB 正在执行（当前处于栈顶活动栈帧）");
16
    }
17
}

栈帧压栈与出栈时序图解：

1
【1. 调用 main()】      【2. main 调 A()】       【3. A 调 B()】
2
                                               ┌─────────────┐ <─ 当前活动栈帧（正在执行 B）
3
                                               │  methodB 帧 │
4
                        ┌─────────────┐        ├─────────────┤
5
                        │  methodA 帧 │        │  methodA 帧 │ (挂起等待 B 返回)
6
┌─────────────┐         ├─────────────┤        ├─────────────┤
7
│   main 帧   │         │   main 帧   │        │   main 帧   │ (挂起等待 A 返回)
8
└─────────────┘         └─────────────┘        └─────────────┘
9
 main 最先入栈(栈底)        A 随后入栈             B 最后入栈(栈顶)
10
──────────────────────────────────────────────────────────────────
11
【4. B 执行完毕返回】    【5. A 执行完毕返回】    【6. main 执行完毕】
12

13
┌─────────────┐ <─ 重新成为栈顶(恢复执行A)
14
│  methodA 帧 │
15
├─────────────┤         ┌─────────────┐ <─ 重新成为栈顶(恢复执行main)
16
│   main 帧   │         │   main 帧   │        [ 栈完全清空，线程结束 ]
17
└─────────────┘         └─────────────┘
18
 B 最先出栈(弹栈释放)       A 第二个出栈            main 最后出栈

---

2. 虚拟机栈常见面试题#

Q2：栈内存分配越大越好吗？#

未必。

• JVM 默认每个线程的栈内存大小通常为 1024K（可通过 -Xss 参数调整）。
• 栈内存设得过大会导致可创建的并发线程数变少。
• 例如：物理总内存为 512M，每个栈分配 1024K，理论上最多支持约 512 个线程并发；若将栈内存改为 2048K，则能支持的并发线程数直接减半（约 256 个）。

---

1
// 1. 线程安全（未逃逸）
2
public static void m1() {
3
    StringBuilder sb = new StringBuilder();
4
    sb.append(1);
5
    sb.append(2);
6
    System.out.println(sb.toString());
7
}
8

9
// 2. 线程不安全（入参导致对象逃逸）
10
public static void m2(StringBuilder sb) {
11
    sb.append(3);
12
    sb.append(4);
13
    System.out.println(sb.toString());
14
}
15

16
// 3. 线程不安全（返回值导致对象逃逸）
17
public static StringBuilder m3() {
18
    StringBuilder sb = new StringBuilder();
19
    sb.append(5);
20
    sb.append(6);
21
    return sb;
22
}
23

24
// 4. 主函数演示
25
public static void main(String[] args) {
26
    StringBuilder sb = new StringBuilder();
27
    sb.append(1);
28
    sb.append(2);
29
    new Thread(() -> {
30
        m2(sb); // 将主线程的 sb 传给子线程，导致多线程共享堆中同一个对象
31
    }).start();
32
}

4. 虚拟机栈的内存溢出问题（StackOverflowError）#

💡 什么情况下会导致栈内存溢出？

1. 栈帧过多导致栈内存溢出：
   • 典型场景：递归调用没有正确的退出条件（死递归），或者调用层次过深。
   • 示例代码：

     1
     public static void m4() {
     2
         m4(); // 无限递归压栈，导致栈深度耗尽
     3
     }

   • 抛出异常：java.lang.StackOverflowError。
2. 栈帧过大导致栈内存溢出：
   • 单个方法内部声明了极多的局部变量，导致单个栈帧体积超出栈限制。

5. 虚拟机栈核心总结#

📌 虚拟机栈面试 6 问速记：

1. 什么是虚拟机栈？ 每个线程运行时所需的内存，称为虚拟机栈。先进后出（LIFO），由多个栈帧组成（每次方法调用分配一个栈帧），活动栈帧永远是位于栈顶的那一个。
2. 垃圾回收是否涉及栈内存？ 不涉及。GC 只针对堆内存，栈帧在方法执行完毕后自动出栈释放。
3. 栈内存分配越大越好吗？ 未必。默认 1024K（-Xss），栈内存越大，可并发创建的线程总数越少。
4. 方法内的局部变量是否线程安全？
   • 未逃离方法作用范围：线程安全（栈帧线程私有）；
   • 逃离方法作用范围（入参传入或 return 导出）：需考虑线程安全。
5. 对象与引用的存储位置关系？ 对象实体在堆（Heap），引用变量随作用域决定（局部变量在栈的局部变量表，成员/静态变量在堆中）。
6. 什么情况下会导致栈内存溢出？ 栈帧过多（死递归、调用链太长）或单个栈帧过大，抛出 java.lang.StackOverflowError。

1. 什么是方法区？#

💡 核心概念：

• 线程共享：各个线程共享的内存区域。
• 生命周期：虚拟机启动时创建，关闭虚拟机时释放。
• 存储内容：主要存储 类的信息（Class 元数据）、类加载器（ClassLoader）、运行时常量池 等。
• 物理位置：
  • JDK 1.7 及之前：由 永久代（PermGen） 实现，属于 JVM 进程管理的内存（逻辑上属于堆）。
  • JDK 1.8 及之后：移除了永久代，改用 元空间（Metaspace） 实现，存储在 本地直接物理内存（Native Memory） 中。
• 异常情况：如果方法区域中的内存无法满足分配请求，则会抛出 java.lang.OutOfMemoryError: Metaspace。

2. 方法区与堆（Heap）的核心区别（重点对比）#

💡 通俗比喻：方法区是“图纸档案室”，堆是“实体加工厂”。

• 方法区：记录类的结构图纸（类名、修饰符、字段定义、方法字节码指令等）。
• 堆：存放根据图纸创建出来的具体对象实体（new Object()）和数组。

3. 元空间内存溢出实战（Metaspace OOM 演示）#

本地内存指的是系统本地的物理内存。以下代码通过 ClassWriter 动态生成大量类字节码并加载，演示元空间内存溢出：

1
/**
2
 * 演示元空间内存溢出 java.lang.OutOfMemoryError: Metaspace
3
 * JVM 启动参数: -XX:MaxMetaspaceSize=8m
4
 */
5
public class MetaspaceDemo extends ClassLoader { // ClassLoader 可以用来加载类的二进制字节码
6
    public static void main(String[] args) {
7
        MetaspaceDemo test = new MetaspaceDemo();
8
        for (int i = 0; i < 10000; i++) {
9
            // ClassWriter 作用是生成类的二进制字节码
10
            ClassWriter cw = new ClassWriter(0);
11
            // 访问修饰符, public, 类名, 包名, 父类, 接口
12
            cw.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, "Class" + i, null, "java/lang/Object", null);
13
            // 返回 byte[] 二进制字节码
14
            byte[] code = cw.toByteArray();
15
            // 执行类的加载，生成 Class 对象并存入元空间
16
            test.defineClass("Class" + i, code, 0, code.length);
17
        }
18
    }
19
}

💡 实验结论：

• 设置 VM 参数 -XX:MaxMetaspaceSize=8m，加载 10,000 个动态类时，元空间因被大量 Class 元数据占满而报错：java.lang.OutOfMemoryError: Metaspace。
• 如果去除该 VM 参数限制，由于本地物理内存足够大，则不会报错。

1
# 运行报错示例
2
-XX:MaxMetaspaceSize=8m -cp 'C:\JavaProjects\面试题目\jvm-demo\target\classes' com.heima.jvm.MetaspaceDemo
3
Picked up JAVA_TOOL_OPTIONS: -Dfile.encoding=UTF-8
4
Error occurred during initialization of VM
5
MaxMetaspaceSize is too small.

4. 常量池 与 运行时常量池#

5. 方法区与常量池总结#

📌 高频面试 2 问速记：

1. 能不能解释一下方法区？
   • 线程共享的内存区域，主要存储类的信息、ClassLoader、运行时常量池；
   • JVM 启动时创建，关闭时释放；
   • JDK 1.8 采用本地内存的元空间实现，空间不足抛出 OutOfMemoryError: Metaspace。
2. 介绍一下运行时常量池：
   • 常量池是 *.class 文件中的静态表，用于指令查表翻译；
   • 类加载后放入方法区的运行时常量池，将符号引用转化为物理内存真实地址。

什么是类加载器#

一般我们自己写的代码都是由应用类加载器加载的

什么是双亲委派#

对于我们自己编写的Student类，是从AppClassLoader开始加载，委托上一级即ExtClassLoader,再区委托上一级即BootStrap ClassLoder，而/jre/lib目录下没有这个Student类，所以AppClassLoader自己加载Student类

String类也是同理，从AppClassLoader向上，到达BootStrap ClassLoader, 存在于/jre/lib目录下，加载完成直接返回给子加载器

为什么要使用双亲委派机制#

总结#

1. 加载（Loading）#

• 核心 3 步：
  1. 找字节流：通过类加载器（双亲委派）获取 .class 二进制字节流；
  2. 入元空间：将静态结构解析并存入 元空间（方法区），生成 C++ 层的 InstanceKlass（存储方法字节码、虚方法表、类结构等）；
  3. 建堆入口：在 Java 堆 中创建对应的 java.lang.Class 镜像对象（作为 Java 访问入口、存放 static 静态变量）。

💡 重点辨析：元空间 Klass vs 堆 Class 对象 vs 实例（张三/李四）

• 元空间 InstanceKlass（图纸真身）：底层 C++ 结构体，存类的完整元数据与方法字节码指令。
• 堆中 Class<Person>（镜像代理）：供 Java 代码（反射/API）访问元数据的入口，static 静态变量存放在此。
• 堆中 张三 / 李四（具体实例）：存各自的属性数据（name="张三"）；对象头中的类型指针直接指向元空间的 InstanceKlass，调用方法时直接定位元空间执行指令。

类变量即static修饰的静态变量，b在准备阶段会赋默认值0,在初始化阶段才会赋值。而final修饰的c和d都是在准备阶段完成赋值，static和final修饰的引用类型，赋值也在初始化阶段完成

#1 #2 #3 #4即为符号引用，通过一层层的查找，找到#31 #32 对应的代码，就是把符号引用转换为直接引用的过程。

1
public class Application {
2

3
    public static void main(String[] args) throws InterruptedException {
4
        // System.out.println("hello world");
5

6
        // 1. 首次访问这个类的静态变量或静态方法时
7
        //System.out.println(Animal.num);
8
        // 2. 子类初始化，如果父类还没初始化，会引发父类先初始化
9
        // System.out.println(Cat.sex);
10
        // 3. 子类访问父类静态变量，只触发父类初始化
11
        // System.out.println(Cat.num);
12
    }
13

14
}
15

16
class Animal {
17
    static int num = 55;
18
    static {
19
        System.out.println("Animal 静态代码块...");
20
    }
21
}
22

23
class Cat extends Animal {
24
    static boolean sex = false;
25
    static {
26
        System.out.println("Cat 静态代码块...1");
27
    }
28

29
    static {
30
        System.out.println("Cat 静态代码块...2");
31
    }
32
}

直接访问父类静态变量时，静态代码块也会执行

1
Picked up JAVA_TOOL_OPTIONS: -Dfile.encoding=UTF-8
2
Animal 静态代码块...
3
55

子类初始化，则会先初始化起父类

1
Picked up JAVA_TOOL_OPTIONS: -Dfile.encoding=UTF-8
2
Animal 静态代码块...
3
Cat 静态代码块...1
4
Cat 静态代码块...2
5
false

通过子类访问父类的静态变量，只会初始化父类的静态代码块，不会初始化子类的

1
Picked up JAVA_TOOL_OPTIONS: -Dfile.encoding=UTF-8
2
Animal 静态代码块...
3
55

卸载即代码执行完毕之后，jvm销毁创建的class对象，相当于把类卸载了

标记清除算法#

标记整理算法#

复制算法#

总结#

1. 四种引用特性速览#

2. 引用队列（ReferenceQueue）与资源释放机制#

💡 核心辨析：不同引用配合队列释放的“资源”有何不同？