一、JVM基础架构与内存模型
1.1 JVM整体架构概览
Java虚拟机(JVM)是Java程序运行的基石，它由以下几个核心子系统组成：
| 子系统 | 功能描述 | 类比解释 |
|---|---|---|
| 类加载子系统 | 负责加载.class文件到内存 | 像图书馆管理员，负责把书(类)从书架(磁盘)拿到阅读区(内存) |
| 运行时数据区 | 程序运行时的内存区域 | 相当于图书馆的不同功能区(阅览区、储物柜等) |
| 执行引擎 | 解释/编译字节码并执行 | 像翻译官，把Java字节码翻译成机器码 |
| 本地方法接口 | 调用本地方法库 | 像外语翻译，调用非Java编写的功能 |
| 垃圾回收系统 | 自动内存管理 | 像清洁工，回收不再使用的内存空间 |
1.2 运行时数据区详解
JVM内存主要分为以下几个区域：
public class MemoryStructure {
static int staticVar = 1; // 方法区(类静态变量)
int instanceVar = 2; // 堆内存(实例变量)
public void method() {
int localVar = 3; // 栈帧中的局部变量表
Object obj = new Object(); // obj引用在栈，对象实例在堆
MemoryStructure mem = new MemoryStructure();
}
}
1.2.1 程序计数器(PC Register)
- 线程私有，记录当前线程执行的字节码行号
- 唯一不会发生OOM的区域
1.2.2 Java虚拟机栈(VM Stack)
栈用于存储局部变量和方法调用的信息。可以把栈想象成一个 “千层饼”，每一层代表一个方法的调用，当方法调用结束后，该层就会被移除。
- 线程私有，存储栈帧(Stack Frame)
- 栈帧包含：局部变量表、操作数栈、动态链接、方法返回地址
public class StackExample {
public static void main(String[] args) {
int a = 1; // 局部变量表slot 0
int b = 2; // 局部变量表slot 1
int c = add(a, b); // 创建新的栈帧
}
public static int add(int x, int y) {
int sum = x + y; // 新栈帧的局部变量表
return sum;
}
}
在上述代码中，main 方法和 add 方法的局部变量（如 a、b、x、y）以及方法调用信息都存放在栈中。
1.2.3 本地方法栈(Native Method Stack)
- 为本地方法服务，类似虚拟机栈
- HotSpot中将虚拟机栈和本地方法栈合二为一
1.2.4 堆内存(Heap)
堆是 JVM 中最大的一块内存区域，用于存储对象实例。可以把堆想象成一个大仓库，所有的对象都存放在这里。
- 线程共享，存放对象实例
- GC主要工作区域
- 可分为新生代(Eden, Survivor)、老年代
// 创建一个对象，存放在堆中
public class HeapExample {
public static void main(String[] args) {
// 创建一个Person对象，存放在堆中
Person person = new Person();
}
}
class Person {
private String name;
private int age;
// 构造方法
public Person() {
this.name = "John";
this.age = 30;
}
}
在上述代码中，new Person() 创建的 Person 对象实例就存放在堆中。
1.2.5 方法区(Method Area)
方法区用于存储类的信息、常量、静态变量等。可以把方法区想象成一个 “知识库”，存储着类的各种知识和规则。
- 存储类信息、常量、静态变量等
- JDK8后由元空间(Metaspace)实现，使用本地内存
public class MethodAreaExample {
// 静态变量，存放在方法区
public static final String MESSAGE = "Hello, World!";
public static void main(String[] args) {
System.out.println(MESSAGE);
}
}
在上述代码中，MESSAGE 静态常量存放在方法区。
1.3 内存区域对比
| 内存区域 | 线程共享 | 是否GC | 可能异常 | 配置参数 |
|---|---|---|---|---|
| 程序计数器 | 私有 | 否 | 无 | 无 |
| 虚拟机栈 | 私有 | 否 | StackOverflowError/OutOfMemoryError | -Xss |
| 本地方法栈 | 私有 | 否 | StackOverflowError/OutOfMemoryError | 同虚拟机栈 |
| 堆内存 | 共享 | 是 | OutOfMemoryError | -Xms, -Xmx, -Xmn |
| 方法区 | 共享 | 是 | OutOfMemoryError | -XX:MetaspaceSize |
二、类加载机制与字节码执行
2.1 类加载过程
类加载的过程包括加载、连接（验证、准备、解析）和初始化。可以把类加载的过程想象成一场演出的筹备过程，加载就像是邀请演员（类），连接就像是安排演员的服装、道具等，初始化就像是演员正式登台表演。
类加载分为以下五个阶段：
| 阶段 | 功能描述 | 通俗解读 |
|---|---|---|
| 加载 | 通过类的全限定名获取类的二进制字节流，并将其转换为方法区中的运行时数据结构，在堆中创建对应的 Class 对象 | 邀请演员到演出场地 |
| 验证 | 确保字节码文件的正确性和安全性 | 检查演员的身份和资质 |
| 准备 | 为类的静态变量分配内存并设置初始值 | 为演员准备服装和道具 |
| 解析 | 将符号引用转换为直接引用 | 确定演员在舞台上的具体位置 |
| 初始化 | 执行类的静态代码块和静态变量的赋值操作 | 演员正式登台表演 |
public class ClassLoadExample {
static {
System.out.println("静态代码块执行"); // 初始化阶段执行
}
public static int value = 123; // 准备阶段赋0，初始化阶段赋123
public static void main(String[] args) {
System.out.println(ClassLoadExample.value);
}
}
2.2 类加载器体系
Java 中有三种主要的类加载器：启动类加载器（Bootstrap ClassLoader）、扩展类加载器（Extension ClassLoader）和应用程序类加载器（Application ClassLoader），它们之间形成了一种父子关系，称为双亲委派模型。可以把类加载器的层次结构想象成一个公司的组织架构，启动类加载器是公司的高层领导，扩展类加载器是中层领导，应用程序类加载器是基层员工。
| 类加载器 | 加载路径 | 父加载器 | 说明 |
|---|---|---|---|
| Bootstrap | JRE/lib | 无 | 加载核心Java类 |
| Extension | JRE/lib/ext | Bootstrap | 加载扩展类 |
| Application | CLASSPATH | Extension | 加载应用类 |
| Custom | 自定义 | Application | 用户自定义类加载器 |
public class ClassLoaderDemo {
public static void main(String[] args) {
// 查看类加载器层次
ClassLoader loader = ClassLoaderDemo.class.getClassLoader();
System.out.println("当前类加载器: " + loader);
System.out.println("父类加载器: " + loader.getParent());
System.out.println("祖父类加载器: " + loader.getParent().getParent());
// 核心类由Bootstrap加载器加载
System.out.println("String类的加载器: " + String.class.getClassLoader());
}
}
2.3 字节码执行引擎
JVM执行字节码的核心组件：
- 解释执行：逐条解释字节码并执行
- 即时编译(JIT)：将热点代码编译为本地机器码
- 自适应优化：根据运行情况动态优化
public class BytecodeExample {
public int calculate() {
int a = 1;
int b = 2;
int c = (a + b) * 10;
return c;
}
// 对应的字节码(使用javap -c查看):
/*
Code:
0: iconst_1 // 将int型1推送至栈顶
1: istore_1 // 将栈顶int型数值存入局部变量1(a)
2: iconst_2 // 将int型2推送至栈顶
3: istore_2 // 将栈顶int型数值存入局部变量2(b)
4: iload_1 // 将局部变量1(a)推送至栈顶
5: iload_2 // 将局部变量2(b)推送至栈顶
6: iadd // 栈顶两int型数值相加并将结果压入栈顶
7: bipush 10 // 将10推送至栈顶
9: imul // 栈顶两int型数值相乘并将结果压入栈顶
10: istore_3 // 将栈顶int型数值存入局部变量3(c)
11: iload_3 // 将局部变量3(c)推送至栈顶
12: ireturn // 返回栈顶int型数值
*/
}
三、垃圾回收机制与算法
垃圾回收（GC）是 JVM 自动管理内存的一种机制，它会自动回收不再使用的对象所占用的内存。可以把垃圾回收想象成一个清洁工，定期清理房间（内存）中的垃圾（不再使用的对象）。
3.1 对象存活判定
3.1.1 引用计数法
给对象添加引用计数器，简单但有循环引用问题：
public class ReferenceCounting {
Object instance = null;
public static void main(String[] args) {
ReferenceCounting objA = new ReferenceCounting();
ReferenceCounting objB = new ReferenceCounting();
objA.instance = objB; // objA引用objB
objB.instance = objA; // objB引用objA
objA = null; // 引用计数不为0，无法回收
objB = null;
}
}
3.1.2 可达性分析算法
通过GC Roots对象作为起点，向下搜索引用链：
public class ReachabilityAnalysis {
public static void main(String[] args) {
// GC Roots包括:
// 1. 虚拟机栈中引用的对象
Object stackRef = new Object();
// 2. 方法区中类静态属性引用的对象
static Object staticRef = new Object();
// 3. 方法区中常量引用的对象
final Object constRef = new Object();
// 4. 本地方法栈中JNI引用的对象
}
}
3.2 垃圾回收算法
| 算法名称 | 算法原理 | 优点 | 缺点 | 通俗解读 |
|---|---|---|---|---|
| 标记 - 清除算法（Mark - Sweep） | 先标记出所有需要回收的对象，然后统一回收这些对象 | 实现简单 | 会产生大量内存碎片 | 先把房间里的垃圾标记出来，然后一次性清理掉，但会留下很多空隙 |
| 标记 - 整理算法（Mark - Compact） | 先标记出所有需要回收的对象，然后将存活的对象向一端移动，最后清理掉边界以外的内存 | 不会产生内存碎片 | 效率较低 | 先把房间里的垃圾标记出来，然后把有用的东西挪到一边，再清理掉垃圾 |
| 复制算法（Copying） | 将内存分为两块，每次只使用其中一块，当这一块内存用完后，将存活的对象复制到另一块内存中，然后清理掉原来的内存 | 效率高，不会产生内存碎片 | 内存利用率低 | 把房间分成两半，每次只使用一半，用完后把有用的东西搬到另一半，然后清理原来的一半 |
| 分代收集算法（Generational Collection） | 根据对象的存活周期将内存分为不同的代，不同的代采用不同的垃圾回收算法 | 综合了多种算法的优点 | 实现复杂 | 把房间按照物品的使用频率分成不同的区域，不同区域采用不同的清理方式 |
3.2.1 标记-清除算法
- 标记所有需要回收的对象
- 统一回收被标记对象
问题：内存碎片化
3.2.2 复制算法
将内存分为两块，每次使用一块，存活对象复制到另一块：
// 新生代Eden区和Survivor区使用复制算法
public class CopyAlgorithm {
public static void main(String[] args) {
byte[] obj1 = new byte[2 * 1024 * 1024]; // 分配在Eden区
byte[] obj2 = new byte[2 * 1024 * 1024];
byte[] obj3 = new byte[2 * 1024 * 1024];
// 当Eden区满时，触发Minor GC
// 存活对象复制到Survivor区
}
}
3.2.3 标记-整理算法
标记过程与标记-清除相同，但后续让存活对象向一端移动：
// 老年代通常使用标记-整理算法
public class MarkCompact {
public static void main(String[] args) {
List<Object> oldGen = new ArrayList<>();
for (int i = 0; i < 100; i++) {
oldGen.add(new Object()); // 模拟老年代对象
}
// Full GC时，标记存活对象并整理内存
}
}
3.2.4 分代收集算法
组合多种算法，针对不同代使用不同策略：
| 内存区域 | 特点 | 使用算法 | GC类型 |
|---|---|---|---|
| 新生代 | 对象生命周期短 | 复制算法 | Minor GC |
| 老年代 | 对象生命周期长 | 标记-清除/整理 | Full GC |
3.3 垃圾收集器对比
| 收集器 | 作用区域 | 算法 | 特点 | 适用场景 |
|---|---|---|---|---|
| Serial | 新生代 | 复制 | 单线程 | 客户端模式 |
| ParNew | 新生代 | 复制 | 多线程 | 配合CMS使用 |
| Parallel Scavenge | 新生代 | 复制 | 吞吐量优先 | 后台运算 |
| Serial Old | 老年代 | 标记-整理 | 单线程 | 客户端模式 |
| Parallel Old | 老年代 | 标记-整理 | 多线程 | 吞吐量优先 |
| CMS | 老年代 | 标记-清除 | 低延迟 | Web应用 |
| G1 | 全堆 | 标记-整理+分区 | 平衡型 | 大堆内存 |
| ZGC | 全堆 | 着色指针 | 超低延迟 | 超大堆 |
四、JVM性能监控与调优
4.1 常用监控工具
4.1.1 命令行工具
| 工具 | 作用 | 示例 |
|---|---|---|
| jps | 查看Java进程 | jps -l |
| jstat | 监控统计信息 | jstat -gcutil pid 1000 5 |
| jinfo | 查看/修改参数 | jinfo -flags pid |
| jmap | 内存分析 | jmap -heap pid |
| jstack | 线程分析 | jstack -l pid > thread.log |
4.1.2 可视化工具
- JConsole：基础监控
- VisualVM：功能全面
- MAT：内存分析
- JProfiler：商业性能分析
4.2 常见性能问题与调优
4.2.1 内存泄漏示例
public class MemoryLeak {
static List<Object> list = new ArrayList<>();
public static void main(String[] args) {
for (int i = 0; i < 1000; i++) {
Object obj = new Object();
list.add(obj); // 对象被静态集合引用，无法回收
obj = null; // 无效操作
}
}
}
解决方案：
- 使用WeakReference
- 及时清理集合
- 避免长生命周期对象引用短生命周期对象
4.2.2 CPU占用过高排查
top -Hp pid找出高CPU线程jstack pid查看线程堆栈- 转换线程ID为16进制对应查找
public class HighCPU {
public static void main(String[] args) {
new Thread(() -> {
while (true) { // 死循环导致CPU飙升
// 业务逻辑
}
}, "high-cpu-thread").start();
}
}
4.2.3 锁竞争优化
public class LockOptimization {
// 不优化的锁使用
public synchronized void unoptimizedMethod() {
// 长时间操作
}
// 优化方案1：减小锁粒度
private final Object lock = new Object();
public void optimizedMethod1() {
synchronized(lock) { // 使用专门锁对象
// 关键操作
}
// 非同步操作
}
// 优化方案2：读写分离
private final ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
public void optimizedMethod2() {
rwLock.readLock().lock(); // 读锁可并发
try {
// 读操作
} finally {
rwLock.readLock().unlock();
}
}
}
4.3 JVM参数调优
4.3.1 堆内存设置
# 初始堆大小(推荐与最大堆相同)
-Xms4g
# 最大堆大小(不超过物理内存80%)
-Xmx4g
# 新生代大小
-Xmn1g
# 元空间大小(默认不限制)
-XX:MetaspaceSize=256m
4.3.2 GC相关参数
# 使用G1收集器
-XX:+UseG1GC
# 目标停顿时间
-XX:MaxGCPauseMillis=200
# 并行GC线程数
-XX:ParallelGCThreads=4
# CMS收集器参数
-XX:+UseConcMarkSweepGC
-XX:CMSInitiatingOccupancyFraction=75
4.3.3 内存溢出时自动Dump
-XX:+HeapDumpOnOutOfMemoryError
-XX:HeapDumpPath=/path/to/dump.hprof
五、高级主题与实战案例
5.1 逃逸分析与栈上分配
public class EscapeAnalysis {
private static class User {
int id;
String name;
User(int id, String name) {
this.id = id;
this.name = name;
}
}
public static void alloc() {
// 未逃逸对象可能被优化为栈上分配
User user = new User(1, "test");
}
public static void main(String[] args) {
long start = System.currentTimeMillis();
for (int i = 0; i < 100000000; i++) {
alloc();
}
System.out.println("耗时: " + (System.currentTimeMillis() - start));
}
}
优化效果：开启逃逸分析(-XX:+DoEscapeAnalysis)可显著减少GC压力
5.2 内存屏障与JMM
Java内存模型(JMM)定义了线程如何与内存交互：
public class MemoryBarrier {
private volatile boolean flag = false; // volatile插入内存屏障
private int value = 0;
public void writer() {
value = 42; // 普通写操作
flag = true; // volatile写，插入StoreStore屏障
}
public void reader() {
if (flag) { // volatile读，插入LoadLoad屏障
System.out.println(value); // 保证看到42
}
}
}
5.3 实战：电商系统JVM调优案例
场景：大促期间系统频繁Full GC
分析步骤：
- 使用
jstat -gcutil pid 1000观察GC情况 jmap -histo:live pid查看对象分布jstack pid分析线程状态
发现的问题：
- 老年代占用95%后触发Full GC
- 缓存层大量使用大对象
解决方案：
- 调整堆大小：-Xms8g -Xmx8g -Xmn3g
- 优化缓存策略：引入多级缓存
- 更换收集器：使用G1并设置-XX:MaxGCPauseMillis=200
- 代码优化：避免大对象直接进入老年代
// 优化前
public class ProductCache {
private static Map<Long, Product> cache = new HashMap<>();
public static Product getProduct(long id) {
if (!cache.containsKey(id)) {
// 从数据库加载完整产品信息(包含大字段)
Product product = loadFromDB(id);
cache.put(id, product); // 大对象直接缓存
}
return cache.get(id);
}
}
// 优化后
public class OptimizedProductCache {
private static Map<Long, Product> basicCache = new HashMap<>();
private static Map<Long, ProductDetail> detailCache = new WeakHashMap<>();
public static Product getProduct(long id) {
Product product = basicCache.get(id);
if (product == null) {
// 只加载基本信息
product = loadBasicFromDB(id);
basicCache.put(id, product);
}
return product;
}
public static ProductDetail getDetail(long id) {
// 大对象使用WeakHashMap，可被GC回收
ProductDetail detail = detailCache.get(id);
if (detail == null) {
detail = loadDetailFromDB(id);
detailCache.put(id, detail);
}
return detail;
}
}
六、总结与最佳实践
6.1 JVM调优原则
- 优先理解业务：不同应用类型(Web/计算/批处理)需要不同策略
- 数据驱动决策：基于监控数据而非猜测进行调优
- 循序渐进：每次只调整一个参数并观察效果
- 权衡取舍：吞吐量 vs 延迟 vs 内存占用
6.2 通用配置建议
| 应用类型 | 堆大小建议 | GC选择 | 关键参数 |
|---|---|---|---|
| Web应用 | 中等(4-8G) | CMS/G1 | 关注停顿时间 |
| 大数据处理 | 大(16G+) | Parallel | 最大化吞吐量 |
| 微服务 | 小(1-2G) | Serial/G1 | 快速启动 |
| 安卓应用 | 很小(<512M) | ART | 最小化内存 |
6.3 持续学习建议
- 阅读JVM规范与HotSpot源码
- 关注新GC算法(ZGC/Shenandoah)
- 实践性能测试与调优
- 参与JVM相关开源项目
Java JVM就像代码世界的“后勤管家”，管内存、搞回收，没它程序就像没头苍蝇，快吃透原理，让代码撒欢跑！
笑过之后请记住：生活就像我的排版，乱中有序，序中带梗。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
