100道HotSpot JVM面试题及答案

一、JVM和HotSpot基础（1-20）

1. 什么是HotSpot？为什么叫HotSpot？

答案：
HotSpot是Oracle JDK和OpenJDK默认的Java虚拟机实现。其名称源自其核心技术——热点代码探测（HotSpot Detection）。HotSpot通过运行时分析识别频繁执行的代码（热点代码），然后对这些代码进行深度优化（如JIT编译），从而提升执行效率。

2. HotSpot VM有哪些主要的组成部分？

答案：
主要组件包括：

1. 类加载器子系统：负责加载类文件
2. 运行时数据区：内存区域，包括堆、方法区、栈等
3. 执行引擎：解释器、JIT编译器
4. 垃圾收集系统：管理内存回收
5. 本地方法接口：调用本地方法
6. 运行时监控和诊断工具

3. 解释一下JVM、JRE和JDK的区别

答案：

· JDK：Java开发工具包，包含JRE和开发工具（javac、javadoc、jdb等）
· JRE：Java运行时环境，包含JVM和核心类库
· JVM：Java虚拟机，负责执行字节码

4. HotSpot VM有哪两种不同的启动器？

答案：

· java启动器：用于启动Java应用程序
· javac启动器：用于编译Java源代码为字节码
  实际上，javac本身也是一个Java应用程序，但通常"启动器"指的是java命令。

5. 什么是JIT编译器？HotSpot中JIT编译器有哪些？

答案：
JIT（Just-In-Time）编译器在运行时将热点字节码编译为本地机器代码，以提高执行效率。HotSpot中有两种JIT编译器：

1. C1编译器（客户端编译器）：优化少，编译快，适合客户端应用
2. C2编译器（服务器端编译器）：深度优化，编译慢，适合服务器应用

6. 解释HotSpot的混合模式、解释模式和编译模式

答案：

· 混合模式：默认模式，解释器和JIT编译器协同工作
· 解释模式：只使用解释器执行字节码（-Xint）
· 编译模式：只使用JIT编译器（-Xcomp），启动时将所有字节码编译成本地代码

7. 什么是热点代码？HotSpot如何探测热点代码？

答案：
热点代码是频繁执行的代码段。HotSpot通过两种计数器探测：

1. 方法调用计数器：统计方法被调用的次数
2. 回边计数器：统计循环体执行的次数
   当计数器超过阈值（Client模式1500次，Server模式10000次），触发JIT编译。

8. 说出几个HotSpot VM的命令行参数（至少三个）

答案：

```bash
# 内存相关
-Xmx2g        # 最大堆内存2GB
-Xms512m      # 初始堆内存512MB

# GC相关
-XX:+PrintGCDetails    # 打印GC详情
-XX:+UseG1GC           # 使用G1垃圾收集器

# 调试相关
-XX:+HeapDumpOnOutOfMemoryError  # OOM时生成堆转储
```

9. HotSpot VM有哪些主要版本区别？

答案：

· Java 8：引入Metaspace取代PermGen，G1成为官方GC
· Java 11：引入ZGC，移除Java EE模块
· Java 17：引入Sealed Classes，强化ZGC和Shenandoah
· Java 21：引入虚拟线程，分代ZGC

10. 什么是JVM的默认堆大小？如何修改？

答案：
默认堆大小取决于物理内存和JVM版本：

· 物理内存 < 192MB：最大堆为物理内存的50%
· 物理内存 > 1GB：最大堆为物理内存的25%
· 不超过1GB

修改方法：

```bash
java -Xms512m -Xmx2g MyApp  # 初始512MB，最大2GB
```

11. 什么是逃逸分析？HotSpot如何进行逃逸分析？

答案：
逃逸分析是分析对象作用域的技术，判断对象是否可能逃逸出方法或线程。HotSpot使用逃逸分析进行优化：

1. 栈上分配：未逃逸的对象可在栈上分配
2. 标量替换：将对象拆分为基本类型字段
3. 锁消除：消除不可能存在竞争的锁

12. 什么是TLAB？为什么需要TLAB？

答案：
TLAB（Thread Local Allocation Buffer）是每个线程在堆中独占的内存区域，用于加速对象分配。
优点：

· 避免多线程竞争堆内存
· 提高分配效率
· 减少同步开销

13. 解释HotSpot的即时编译优化技术

答案：

1. 方法内联：将小方法调用替换为方法体
2. 公共子表达式消除：重复表达式只计算一次
3. 循环展开：减少循环开销
4. 逃逸分析：如上所述
5. 锁粗化/消除：优化锁操作

14. 什么是偏向锁？它的工作原理是什么？

答案：
偏向锁是HotSpot的锁优化技术，假设锁总是由同一线程获得。
工作流程：

1. 第一个获取锁的线程将对象头标记为偏向
2. 同一线程再次获取锁时无需同步操作
3. 其他线程竞争时，撤销偏向锁升级为轻量级锁

15. 解释HotSpot的代码缓存（Code Cache）

答案：
Code Cache是HotSpot存储JIT编译后本地代码的内存区域。
配置参数：

```bash
-XX:InitialCodeCacheSize=10m    # 初始大小
-XX:ReservedCodeCacheSize=240m   # 最大大小
-XX:+PrintCodeCache              # 打印使用情况
```

16. 什么是分层编译？它的优势是什么？

答案：
分层编译结合了解释器和不同级别的JIT编译器，Java 7引入，分为5个级别：

· 第0层：解释执行
· 第1层：简单的C1编译
· 第2层：有限的C1编译
· 第3层：完全的C1编译
· 第4层：C2编译

优势：平衡启动速度和长期运行性能。

17. 什么是OSR（On-Stack Replacement）？

答案：
OSR允许在方法执行过程中替换解释执行的代码为JIT编译的代码，特别适用于长时间运行的方法（如热点循环）。

18. HotSpot如何实现方法调用？

答案：
方法调用方式：

1. 静态绑定：非虚方法（static、private、final、构造函数）
2. 动态绑定：虚方法（普通实例方法）
   · 虚方法表（vtable）机制
   · 接口方法表（itable）机制

19. 解释HotSpot的常量池

答案：
HotSpot有两种常量池：

1. Class文件常量池：存储字面量和符号引用
2. 运行时常量池：Class文件常量池的运行时表示，可动态添加（如String.intern()）

20. 什么是JVM指令集架构？

答案：
HotSpot基于栈的指令集架构：

· 操作数栈：存储计算中间结果
· 局部变量表：存储参数和局部变量
· 字节码指令：如iload、istore、iadd等

二、内存管理（21-40）

21. HotSpot VM的内存区域是如何划分的？

答案：

```
运行时数据区：
├── 线程私有
│   ├── 程序计数器
│   ├── Java虚拟机栈
│   └── 本地方法栈
└── 线程共享
    ├── 堆
    └── 方法区/元空间
```

22. 什么是堆？堆中如何分代？

答案：
堆是存放对象实例的内存区域。分代基于弱分代假设：

```
堆内存：
├── 新生代 (Young Generation)
│   ├── Eden区 (80%)
│   ├── Survivor0区 (10%)
│   └── Survivor1区 (10%)
└── 老年代 (Old Generation)
```

23. 什么是方法区？Java 8之后有什么变化？

答案：
方法区存储类信息、常量、静态变量等。
Java 8变化：

· 之前：永久代（PermGen），在堆中，固定大小
· 之后：元空间（Metaspace），使用本地内存，自动扩展

24. 什么是虚拟机栈？栈帧包含哪些部分？

答案：
虚拟机栈是线程私有的，存储方法调用的栈帧。每个栈帧包含：

1. 局部变量表：方法参数和局部变量
2. 操作数栈：计算中间结果
3. 动态链接：指向运行时常量池的引用
4. 方法返回地址：方法退出后的执行位置

25. 什么是本地方法栈？

答案：
本地方法栈与虚拟机栈类似，但为本地方法（Native Method）服务。某些JVM实现（如HotSpot）将虚拟机栈和本地方法栈合二为一。

26. 什么是程序计数器？为什么需要它？

答案：
程序计数器存储当前线程执行的字节码指令地址。
作用：

· 线程切换后恢复执行位置
· 分支、循环、异常处理的控制
· 每个线程独立，不会发生OOM

27. 什么是直接内存？它属于JVM内存吗？

答案：
直接内存（Direct Memory）是通过NIO的DirectByteBuffer分配的内存，位于堆外。
特点：

· 不属于JVM运行时数据区
· 不受GC管理（但引用对象受GC管理）
· 可减少内存拷贝，提高I/O性能

28. 对象在堆中是如何分配的？

答案：
分配流程：

1. 优先在TLAB分配
2. TLAB不足则在Eden区分配
3. 大对象直接进入老年代（-XX:PretenureSizeThreshold）
4. 空间不足时触发GC

29. 什么是卡表（Card Table）？

答案：
卡表是一种记忆集实现，记录老年代到新生代的跨代引用。
工作原理：

· 将老年代划分为512字节的卡片
· 写屏障标记被修改的卡片为脏
· Minor GC时只扫描脏卡片

30. 什么是写屏障？

答案：
写屏障是在对象引用写入时插入的代码片段。
作用：

1. 维护卡表状态
2. 实现增量更新或原始快照（SATB）
3. 支持并发标记

31. 什么是安全点？什么是安全区域？

答案：

· 安全点：特定位置（方法调用、循环跳转等），线程执行到此可安全暂停进行GC
· 安全区域：代码区域，引用关系不会变化，线程在此区域内可随时GC

32. 什么是OOP-Klass模型？

答案：
OOP-Klass是HotSpot的对象表示模型：

· OOP：普通对象指针，存储对象实例数据
· Klass：Java类的C++对等体，存储类元数据

33. 对象在内存中的布局是怎样的？

答案：
对象内存布局：

```
对象头 (Header)
├── Mark Word (8字节)
│   ├── 哈希码
│   ├── GC分代年龄
│   ├── 锁状态标志
│   └── 线程持有锁
├── Klass Pointer (4/8字节)
└── 数组长度 (如果是数组，4字节)
实例数据 (Instance Data)
对齐填充 (Padding)
```

34. 什么是压缩指针？

答案：
压缩指针是HotSpot的内存优化技术，在64位JVM中将64位指针压缩为32位。
条件：堆大小< 32GB
优势：减少内存占用，提高缓存命中率
启用：-XX:+UseCompressedOops（默认开启）

35. 什么是大对象？如何处理大对象？

答案：
大对象是需要大量连续内存的对象。
处理方式：

1. 直接进入老年代：-XX:PretenureSizeThreshold=4m
2. G1收集器中分配到Humongous区域
3. 避免频繁创建，考虑对象池

36. 长期存活的对象会进入老年代吗？

答案：
是的，通过年龄计数器：

1. 对象在Survivor区每经历一次Minor GC，年龄加1
2. 达到阈值（默认15）进入老年代
3. 可配置：-XX:MaxTenuringThreshold=15

37. 什么是动态年龄判定？

答案：
HotSpot并不严格要求年龄达到MaxTenuringThreshold才晋升，如果Survivor空间中相同年龄所有对象大小的总和大于Survivor空间的一半，年龄≥该年龄的对象可以直接进入老年代。

38. 什么是空间分配担保？

答案：
空间分配担保是Minor GC前的检查机制：

1. 检查老年代最大可用连续空间 > 新生代所有对象总空间
2. 如果成立，Minor GC安全
3. 否则检查是否允许担保失败（HandlePromotionFailure）
4. 检查老年代最大可用连续空间 > 历次晋升到老年代对象的平均大小

39. 什么是内存泄漏？在Java中如何避免？

答案：
内存泄漏是对象不再使用但无法被GC回收。
常见原因：

· 静态集合类持有对象引用
· 监听器未注销
· 数据库连接、文件流未关闭
· 内部类持有外部类引用

避免方法：

1. 及时释放引用
2. 使用弱引用（WeakReference）
3. 使用try-with-resources
4. 定期分析内存使用

40. 如何设置元空间大小？

答案：

```bash
# 初始大小
-XX:MetaspaceSize=64m
# 最大大小（默认无限制）
-XX:MaxMetaspaceSize=256m
# 发生OOM时打印类加载信息
-XX:+TraceClassLoading
-XX:+TraceClassUnloading
```

三、垃圾回收（41-70）

41. 什么是GC？为什么需要GC？

答案：
GC是自动内存管理机制，回收不再使用的对象。
必要性：

· 避免内存泄漏
· 减少手动内存管理复杂性
· 提高开发效率
· 防止野指针

42. 如何判断对象是否可以被回收？

答案：
可达性分析算法：

1. 以GC Roots为起点
2. 向下搜索引用链
3. 不可达对象标记为可回收
4. 两次标记后回收（第一次标记、筛选）

43. 什么是GC Roots？哪些对象可以作为GC Roots？

答案：
GC Roots包括：

1. 虚拟机栈中引用的对象
2. 方法区中静态属性引用的对象
3. 方法区中常量引用的对象
4. 本地方法栈中JNI引用的对象
5. JVM内部引用（基本类型对应的Class对象等）
6. 被同步锁持有的对象
7. JVM内部JMXBean、JVMTI回调等

44. 对象有哪几种引用类型？

答案：

1. 强引用：最常见的引用，不会被GC回收
2. 软引用：内存不足时被回收，SoftReference
3. 弱引用：只要GC就会回收，WeakReference
4. 虚引用：最弱的引用，用于对象回收跟踪，PhantomReference

45. 什么是Finalize方法？有什么问题？

答案：
Finalize是Object的protected方法，对象被回收前调用。
问题：

1. 执行不确定性
2. 性能开销大
3. 可能导致对象"复活"
4. Java 9标记为废弃

46. HotSpot中有哪些垃圾收集器？

答案：

```
新生代收集器：
- Serial
- ParNew
- Parallel Scavenge

老年代收集器：
- Serial Old
- Parallel Old
- CMS

整堆收集器：
- G1 (JDK 7u4+)
- ZGC (JDK 11+)
- Shenandoah (JDK 12+)
```

47. 什么是Stop-The-World？为什么会发生？

答案：
STW是GC过程中暂停所有应用线程的现象。
原因：

1. 需要一致性的内存快照
2. 防止对象引用关系变化
3. 确保可达性分析准确性

48. 什么是Minor GC？什么是Full GC？

答案：

· Minor GC：新生代GC，频繁，速度快
· Major GC：老年代GC，通常伴随Minor GC
· Full GC：整堆GC（新生代+老年代+元空间等），慢，STW时间长

49. 描述Serial收集器

答案：

· 特点：单线程，复制算法，STW
· 适用场景：客户端应用，单核服务器
· 参数：-XX:+UseSerialGC

50. 描述ParNew收集器

答案：

· 特点：Serial的多线程版本，复制算法，STW
· 适用场景：多核服务器，配合CMS使用
· 参数：-XX:+UseParNewGC

51. 描述Parallel Scavenge收集器

答案：

· 特点：吞吐量优先，自适应策略，复制算法
· 目标：可控制的吞吐量（运行用户代码时间/总时间）
· 参数：-XX:+UseParallelGC，-XX:MaxGCPauseMillis，-XX:GCTimeRatio

52. 描述Serial Old收集器

答案：

· 特点：Serial的老年代版本，标记-整理算法
· 适用场景：客户端应用，CMS后备方案

53. 描述Parallel Old收集器

答案：

· 特点：Parallel Scavenge的老年代版本，标记-整理算法
· 参数：-XX:+UseParallelOldGC

54. 描述CMS收集器

答案：
工作阶段：

1. 初始标记：STW，标记GC Roots直接关联对象
2. 并发标记：与用户线程并发，标记所有可达对象
3. 重新标记：STW，修正并发标记期间的变动
4. 并发清除：与用户线程并发，清除垃圾

优点：低停顿
缺点：CPU敏感，浮动垃圾，内存碎片

55. 什么是浮动垃圾？

答案：
浮动垃圾是在并发标记或并发清除阶段产生的垃圾，只能等到下次GC回收。

56. 描述G1收集器

答案：
特点：

· 分Region收集，优先回收价值最大Region
· 可预测的停顿时间模型
· 标记-整理算法

工作阶段：

1. 初始标记：STW
2. 并发标记：与用户线程并发
3. 最终标记：STW
4. 筛选回收：STW，选择部分Region回收

57. 什么是Remembered Set？

答案：
RSet记录Region之间的引用关系，避免全堆扫描。
结构：

· 每个Region都有一个RSet
· 记录其他Region指向本Region的引用
· 使用卡表实现

58. 什么是SATB？

答案：
SATB（Snapshot At The Beginning）是G1的并发标记算法。
原理：

1. 标记开始时创建对象图快照
2. 并发标记期间新创建的对象都视为存活
3. 确保标记完整性

59. 描述ZGC收集器

答案：
特点：

· 亚毫秒级停顿
· 支持TB级堆
· 并发标记、转移、重定位

核心技术：

1. 染色指针：将元数据存储在指针中
2. 读屏障：访问对象时执行额外操作
3. 内存多重映射：虚拟地址到物理地址的映射

60. 描述Shenandoah收集器

答案：
特点：

· 低停顿，与堆大小无关
· 并发整理
· 支持大堆

核心技术：

1. 转发指针：对象移动时不更新所有引用
2. 读/写屏障：支持并发操作
3. Brooks指针：对象头中的转发指针

61. 什么是垃圾收集算法？

答案：
基本算法：

1. 标记-清除：产生碎片
2. 复制：空间利用率低
3. 标记-整理：适合老年代
4. 分代收集：结合多种算法

62. 解释标记-清除算法

答案：
过程：

1. 标记所有需要回收的对象
2. 统一回收标记的对象
   缺点：效率问题，内存碎片

63. 解释复制算法

答案：
过程：

1. 内存分为两块，每次使用一块
2. 存活对象复制到另一块
3. 清理已使用块
   优点：无碎片
   缺点：内存利用率50%

64. 解释标记-整理算法

答案：
过程：

1. 标记所有需要回收的对象
2. 存活对象向一端移动
3. 清理边界外内存
   适用：老年代

65. 什么是增量更新？什么是原始快照？

答案：
CMS和G1处理并发标记时对象引用变化的技术：

· 增量更新：记录被更新的引用，重新标记时再扫描
· 原始快照：记录标记开始时的快照，按快照标记

66. 什么是引用计数法？为什么HotSpot不使用？

答案：
引用计数法：对象被引用时计数+1，引用失效时-1，计数为0时回收。
不使用的理由：

1. 循环引用问题
2. 计数器占用空间
3. 更新计数器开销大

67. 如何选择垃圾收集器？

答案：
选择策略：

1. 单核/客户端：Serial
2. 多核/注重吞吐：Parallel Scavenge + Parallel Old
3. 低延迟：CMS/G1/ZGC/Shenandoah
4. 超大堆：G1/ZGC

68. 什么是GC调优？基本原则是什么？

答案：
GC调优是优化GC参数以达到性能目标。
原则：

1. 优先让JVM自适应调整
2. 先分析，后调优
3. 一次只调整一个参数
4. 关注主要矛盾（吞吐vs延迟）

69. 什么是并发失败？

答案：
并发失败是CMS在并发标记/清除期间，应用线程需要分配对象，但老年代空间不足，导致"Concurrent Mode Failure"，触发Serial Old进行Full GC。

70. 什么是晋升失败？

答案：
晋升失败是Minor GC时，Survivor空间不足或年龄达到阈值，但老年代空间不足，导致对象无法晋升，触发Full GC。

四、类加载（71-85）

71. 什么是类加载？类加载的过程是什么？

答案：
类加载是将类的字节码加载到内存并转换为运行时数据结构的过程。
过程：

1. 加载：查找并加载字节码
2. 验证：确保字节码正确性
3. 准备：为静态变量分配内存并设零值
4. 解析：将符号引用转为直接引用
5. 初始化：执行类构造器<clinit>()方法

72. 什么是类加载器？有哪些类加载器？

答案：
类加载器负责加载类。
层级结构：

```
启动类加载器 (Bootstrap ClassLoader)
   ↓
扩展类加载器 (Extension ClassLoader)
   ↓
应用程序类加载器 (Application ClassLoader)
   ↓
自定义类加载器 (Custom ClassLoader)
```

73. 什么是双亲委派模型？

答案：
双亲委派模型是类加载器的工作机制：

1. 收到加载请求时，先委派给父加载器
2. 父加载器无法完成时，自己尝试加载
   优点：
3. 避免重复加载
4. 保证核心类库安全
5. 确保类的一致性

74. 如何打破双亲委派模型？

答案：
打破方式：

1. 重写ClassLoader.loadClass()方法
2. 使用线程上下文类加载器
3. OSGi、Tomcat等容器技术
   示例：

```java
protected Class<?> loadClass(String name, boolean resolve) 
    throws ClassNotFoundException {
    // 先自己尝试加载
    Class<?> c = findClass(name);
    if (c != null) return c;
    // 失败后再委派给父加载器
    return super.loadClass(name, resolve);
}
```

75. 什么是SPI？为什么SPI会打破双亲委派？

答案：
SPI（Service Provider Interface）是服务提供者接口。
打破原因：

· 接口由启动类加载器加载
· 实现类由应用类加载器加载
· 需要线程上下文类加载器加载实现类

76. 什么是类的主动引用和被动引用？

答案：

· 主动引用（触发初始化）：
  1. new、getstatic、putstatic、invokestatic
  2. 反射调用
  3. 初始化子类（父类未初始化）
  4. JVM启动的主类
· 被动引用（不触发初始化）：
  1. 通过子类引用父类静态字段
  2. 通过数组定义引用类
  3. 引用常量（编译期存入常量池）

77. 什么是类加载器的命名空间？

答案：
命名空间由类加载器及其加载的类组成。
特点：

1. 不同类加载器加载的同一个类是不同的
2. 子加载器可访问父加载器加载的类
3. 父加载器不能访问子加载器加载的类

78. 如何自定义类加载器？

答案：

```java
public class MyClassLoader extends ClassLoader {
    private String classPath;
    
    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        try {
            byte[] data = loadClassData(name);
            return defineClass(name, data, 0, data.length);
        } catch (Exception e) {
            throw new ClassNotFoundException(name, e);
        }
    }
    
    private byte[] loadClassData(String name) throws IOException {
        // 从自定义路径加载字节码
        String path = classPath + name.replace('.', '/') + ".class";
        try (InputStream is = new FileInputStream(path);
             ByteArrayOutputStream baos = new ByteArrayOutputStream()) {
            byte[] buffer = new byte[1024];
            int len;
            while ((len = is.read(buffer)) != -1) {
                baos.write(buffer, 0, len);
            }
            return baos.toByteArray();
        }
    }
}
```

79. 什么是热部署？如何实现？

答案：
热部署是不重启应用更新类。
实现方式：

1. 每个版本使用新的类加载器
2. 旧类加载器及其加载的类等待GC
3. 注意静态变量、单例等状态保持

80. 什么是字节码增强技术？

答案：
字节码增强是在类加载时修改字节码。
技术：

1. Java Agent：premain/agentmain方法
2. ASM/Javassist：字节码操作库
3. AspectJ：面向切面编程
   应用：性能监控、APM、AOP、Mock测试

81. 什么是字节码指令？分类有哪些？

答案：
字节码指令是JVM执行的指令。
分类：

1. 加载和存储
2. 算术运算
3. 类型转换
4. 对象创建与操作
5. 操作数栈管理
6. 控制转移
7. 方法调用与返回
8. 异常处理
9. 同步

82. 什么是invokedynamic指令？

答案：
invokedynamic是Java 7引入的指令，支持动态语言特性。
特点：

1. 第一次调用时动态链接
2. 后续调用使用缓存
3. Lambda表达式、方法引用的实现基础

83. 什么是方法句柄？

答案：
方法句柄（MethodHandle）是Java 7引入，提供对方法的直接引用。
特点：

1. 比反射性能更好
2. 类型安全
3. 支持尾调用优化

84. 什么是动态代理？如何实现？

答案：
动态代理是在运行时生成代理类。
实现方式：

1. JDK动态代理：基于接口，使用Proxy和InvocationHandler
2. CGLIB动态代理：基于继承，使用MethodInterceptor
3. ByteBuddy/Javassist：字节码生成

85. 什么是Lambda表达式实现原理？

答案：
Lambda表达式通过invokedynamic指令实现：

1. 生成实现函数式接口的类
2. 创建方法句柄
3. 动态调用目标方法

五、执行引擎（86-95）

86. 什么是解释器？什么是JIT编译器？

答案：

· 解释器：逐条解释执行字节码，启动快，执行慢
· JIT编译器：将热点代码编译为本地代码，启动慢，执行快

87. 什么是C1和C2编译器？

答案：

· C1编译器（客户端编译器）：
  · 简单优化
  · 编译快
  · 适合客户端应用
· C2编译器（服务器端编译器）：
  · 深度优化
  · 编译慢
  · 适合服务器应用

88. 什么是分层编译？

答案：
分层编译结合解释器和不同级别JIT编译器。
5个层级：

1. 第0层：解释执行
2. 第1层：简单的C1编译
3. 第2层：有限的C1编译
4. 第3层：完全的C1编译
5. 第4层：C2编译

89. 什么是去优化？

答案：
去优化是将已编译的代码退回到解释状态。
触发条件：

1. 假设失效（如类加载、方法调用目标变化）
2. 优化导致错误
3. 调试需要

90. 什么是方法内联？

答案：
方法内联是将方法调用替换为方法体。
优点：

1. 减少方法调用开销
2. 为其他优化创造条件
3. 提高缓存局部性
   条件：方法体小，非虚方法等

91. 什么是公共子表达式消除？

答案：
公共子表达式消除是优化重复计算的表达式。
示例：

```java
// 优化前
int a = b + c;
int d = b + c;
// 优化后
int tmp = b + c;
int a = tmp;
int d = tmp;
```

92. 什么是数组边界检查消除？

答案：
数组边界检查消除是编译器在确定不会越界时消除检查。
条件：

1. 循环内访问数组
2. 索引变量范围可分析
3. 不会发生越界

93. 什么是锁消除？

答案：
锁消除是基于逃逸分析的优化，消除不可能存在竞争的锁。
示例：

```java
public String concat(String s1, String s2) {
    StringBuffer sb = new StringBuffer();
    sb.append(s1);
    sb.append(s2);
    return sb.toString();  // StringBuffer同步锁可消除
}
```

94. 什么是标量替换？

答案：
标量替换是将聚合量（对象）拆散为标量（基本类型）分配。
条件：

1. 对象未逃逸
2. 可拆分为独立的基本类型
   优势：减少堆分配，提高访问速度

95. 什么是循环展开？

答案：
循环展开是减少循环控制开销的优化。
示例：

```java
// 展开前
for (int i = 0; i < 100; i++) {
    sum += array[i];
}
// 展开后（4次展开）
for (int i = 0; i < 100; i += 4) {
    sum += array[i];
    sum += array[i+1];
    sum += array[i+2];
    sum += array[i+3];
}
```

六、性能调优与监控（96-100）

96. 常用的JVM性能监控工具有哪些？

答案：
命令行工具：

· jps：JVM进程状态
· jstat：JVM统计信息
· jinfo：JVM配置信息
· jmap：内存映射
· jhat：堆转储分析
· jstack：线程堆栈
· jsadebugd：服务性代理调试守护进程

图形化工具：

· JConsole
· VisualVM
· Java Mission Control
· MAT（Memory Analyzer Tool）

97. 如何查看Java进程的堆内存使用情况？

答案：

```bash
# 查看GC统计
jstat -gc <pid> 1000 10  # 每秒1次，共10次

# 查看堆内存摘要
jmap -heap <pid>

# 实时监控
jconsole <pid>
```

98. 如何导出和分析堆转储文件？

答案：

```bash
# 导出堆转储
jmap -dump:format=b,file=heap.bin <pid>

# 自动导出（OOM时）
-XX:+HeapDumpOnOutOfMemoryError
-XX:HeapDumpPath=./heap.bin

# 分析工具
jhat heap.bin  # 内置分析
mat heap.bin   # Eclipse Memory Analyzer
visualvm       # VisualVM
```

99. 如何查看线程堆栈信息？

答案：

```bash
# 查看线程堆栈
jstack <pid> > thread.txt

# 查看死锁
jstack <pid> | grep -A 10 "deadlock"

# 实时监控线程
top -H -p <pid>      # 查看线程CPU
jstack <pid> | grep <nid>  # nid为16进制线程ID
```

100. JVM性能调优的基本原则是什么？

答案：

1. 先监控，后调优：使用工具定位瓶颈
2. 先代码，后配置：优化代码优于调整参数
3. 先理解，后修改：理解参数含义再调整
4. 一次调整一个参数：便于定位效果
5. 循序渐进：小步快跑，持续优化
6. 关注主要矛盾：吞吐 vs 延迟，内存 vs CPU
7. 回归测试：每次调整后测试性能
8. 文档记录：记录调优过程和结果

---

重要补充：HotSpot调优实战参数示例

```bash
# 生产环境推荐配置（示例）
java -server \
    -Xms4g -Xmx4g \                # 堆大小固定，避免动态调整
    -XX:MetaspaceSize=256m \
    -XX:MaxMetaspaceSize=256m \
    -Xmn2g \                       # 新生代大小（堆的1/2）
    -XX:SurvivorRatio=8 \          # Eden:Survivor=8:1:1
    -XX:+UseG1GC \                 # 使用G1收集器
    -XX:MaxGCPauseMillis=200 \     # 目标停顿时间
    -XX:ParallelGCThreads=4 \      # 并行GC线程数
    -XX:ConcGCThreads=2 \          # 并发GC线程数
    -XX:+PrintGCDetails \
    -XX:+PrintGCDateStamps \
    -Xloggc:./logs/gc.log \
    -XX:+HeapDumpOnOutOfMemoryError \
    -XX:HeapDumpPath=./logs/heapdump.hprof \
    -jar myapp.jar
```

这份HotSpot面试题涵盖了JVM的核心概念、内存管理、垃圾回收、类加载、执行引擎和性能调优等方面，是准备Java高级开发和架构师面试的宝贵资料。