JVM深入理解

Java虚拟机（JVM）是Java平台的核心，它负责将Java字节码转换为特定平台的机器码并执行。本文将深入探讨JVM的内部工作原理、内存模型、垃圾回收机制以及性能调优等内容。

JVM概述

JVM的作用

JVM在Java生态系统中扮演着至关重要的角色：

跨平台性：实现了"一次编写，到处运行"的特性
内存管理：自动进行内存分配和回收
安全机制：提供字节码验证、安全管理器等安全保障
优化执行：通过即时编译等技术提高性能

JVM架构

JVM主要由以下几个部分组成：

类加载器（ClassLoader）：负责加载字节码文件
运行时数据区（Runtime Data Area）：存储程序运行时的数据
执行引擎（Execution Engine）：执行字节码指令
本地方法接口（Native Interface）：与本地方法库交互

类加载机制

类加载器层次结构

JVM中有以下几种类加载器：

java

// 类加载器层次结构
public class ClassLoaderDemo {
    public static void main(String[] args) {
        // 获取类加载器
        ClassLoader classLoader = ClassLoaderDemo.class.getClassLoader();
        System.out.println("当前类加载器: " + classLoader);
        
        // 获取父类加载器
        ClassLoader parentLoader = classLoader.getParent();
        System.out.println("父类加载器: " + parentLoader);
        
        // 获取引导类加载器
        ClassLoader bootstrapLoader = parentLoader.getParent();
        System.out.println("引导类加载器: " + bootstrapLoader); // 通常为null
        
        // 查看系统类加载器
        ClassLoader systemLoader = ClassLoader.getSystemClassLoader();
        System.out.println("系统类加载器: " + systemLoader);
    }
}

引导类加载器（Bootstrap ClassLoader）：加载Java核心类，如java.lang包下的类
扩展类加载器（Extension ClassLoader）：加载Java扩展目录（jre/lib/ext）下的类
应用程序类加载器（Application ClassLoader）：加载应用程序类路径下的类
自定义类加载器：开发者自定义的类加载器

类加载过程

类加载过程分为以下几个阶段：

加载（Loading）：查找并加载类的二进制数据
链接（Linking）：
- 验证（Verification）：确保字节码的安全性和正确性
- 准备（Preparation）：为类的静态变量分配内存并设置默认初始值
- 解析（Resolution）：将符号引用替换为直接引用
初始化（Initialization）：执行静态初始化代码
使用（Using）：类的实例化和方法调用
卸载（Unloading）：类被垃圾回收器回收

类加载器的双亲委派模型

双亲委派模型是Java类加载器的一种工作机制：

java

// 自定义类加载器示例
public class CustomClassLoader extends ClassLoader {
    private String classpath;
    
    public CustomClassLoader(String classpath) {
        this.classpath = classpath;
    }
    
    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        try {
            byte[] classData = loadClassData(name);
            if (classData == null) {
                throw new ClassNotFoundException();
            }
            return defineClass(name, classData, 0, classData.length);
        } catch (IOException e) {
            throw new ClassNotFoundException(e.getMessage());
        }
    }
    
    private byte[] loadClassData(String className) throws IOException {
        String path = classpath + File.separatorChar + 
                      className.replace('.', File.separatorChar) + ".class";
        FileInputStream fis = new FileInputStream(path);
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        byte[] buffer = new byte[1024];
        int len;
        while ((len = fis.read(buffer)) != -1) {
            bos.write(buffer, 0, len);
        }
        fis.close();
        bos.close();
        return bos.toByteArray();
    }
}

双亲委派模型的工作流程：

当一个类加载器收到类加载请求时，首先将请求委派给父类加载器
如果父类加载器无法加载，再由当前类加载器尝试加载
父类加载器一直向上追溯到引导类加载器

这种机制的好处是：

防止重复加载同一个类
保证Java核心类的安全，避免核心API被恶意代码替换

类加载器的破坏

在某些场景下，需要打破双亲委派模型：

SPI（Service Provider Interface）：如JDBC驱动加载
热部署：需要重新加载类时
隔离类加载：在同一个JVM中加载相同类的不同版本

运行时数据区

程序计数器（Program Counter Register）

程序计数器是一块较小的内存空间，用于记录当前线程执行的字节码行号。

线程私有，每个线程都有自己的程序计数器
如果线程执行的是Java方法，计数器记录正在执行的虚拟机字节码指令的地址
如果执行的是Native方法，计数器值为undefined
唯一一个在JVM规范中没有规定OutOfMemoryError情况的区域

Java虚拟机栈（Java Virtual Machine Stack）

虚拟机栈描述的是Java方法执行的内存模型：

java

// 演示栈溢出
public class StackOverflowDemo {
    private static int count = 0;
    
    public static void recursion() {
        count++;
        recursion(); // 无限递归，导致栈溢出
    }
    
    public static void main(String[] args) {
        try {
            recursion();
        } catch (StackOverflowError e) {
            System.out.println("栈溢出，递归次数: " + count);
            e.printStackTrace();
        }
    }
}

线程私有，生命周期与线程相同
每个方法执行时会创建一个栈帧（Stack Frame）
栈帧包含局部变量表、操作数栈、动态链接、方法出口等信息
可能抛出StackOverflowError（栈深度溢出）和OutOfMemoryError（栈扩展失败）

本地方法栈（Native Method Stack）

本地方法栈与虚拟机栈类似，但是为Native方法服务。

线程私有
可能抛出StackOverflowError和OutOfMemoryError

Java堆（Java Heap）

Java堆是JVM管理的内存中最大的一块，用于存储对象实例：

java

// 演示堆内存溢出
public class HeapOutOfMemoryDemo {
    static class OOMObject {}
    
    public static void main(String[] args) {
        List<OOMObject> list = new ArrayList<>();
        while (true) {
            list.add(new OOMObject()); // 不断创建对象，导致堆溢出
        }
    }
}

所有线程共享的内存区域
垃圾收集器的主要工作区域
可以细分为新生代和老年代，新生代又可分为Eden空间、From Survivor空间和To Survivor空间
可能抛出OutOfMemoryError

方法区（Method Area）

方法区用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据：

java

// 演示方法区内存溢出（JDK 8之前）
public class MethodAreaOOMDemo {
    public static void main(String[] args) {
        List<Class<?>> classes = new ArrayList<>();
        while (true) {
            // 使用动态代理生成大量类，导致方法区溢出
            classes.add(ClassGenerator.generateClass());
        }
    }
    
    static class ClassGenerator {
        public static Class<?> generateClass() {
            String className = "GeneratedClass" + System.nanoTime();
            ClassWriter cw = new ClassWriter(0);
            cw.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, className, null, "java/lang/Object", null);
            // 生成方法等...
            byte[] code = cw.toByteArray();
            return new ClassLoader() {
                public Class<?> defineClass(String name, byte[] b) {
                    return defineClass(name, b, 0, b.length);
                }
            }.defineClass(className, code);
        }
    }
}

所有线程共享的内存区域
在JDK 8及以后，方法区的实现是Metaspace，位于本地内存
在JDK 7及以前，方法区的实现是PermGen（永久代），位于堆内存
可能抛出OutOfMemoryError

运行时常量池（Runtime Constant Pool）

运行时常量池是方法区的一部分，用于存储编译期生成的各种字面量和符号引用：

线程共享
JDK 7及以后，运行时常量池移至堆内存中
可能抛出OutOfMemoryError

垃圾回收机制

垃圾回收的基本概念

垃圾回收（Garbage Collection，GC）是指自动回收不再被引用的对象所占用的内存空间。

对象存活判断算法

引用计数法

引用计数法通过记录对象被引用的次数来判断对象是否存活：

优点：实现简单，判定效率高
缺点：无法解决循环引用问题

可达性分析算法

可达性分析算法通过一系列称为"GC Roots"的对象作为起始点，从这些节点开始向下搜索，搜索所走过的路径称为引用链：

如果一个对象到GC Roots没有任何引用链相连，则证明此对象是不可达的，可能被回收
GC Roots包括：虚拟机栈中引用的对象、方法区中类静态属性引用的对象、方法区中常量引用的对象、本地方法栈中JNI引用的对象

引用类型

Java中有四种引用类型：

java

// 引用类型示例
public class ReferenceDemo {
    public static void main(String[] args) throws InterruptedException {
        // 强引用
        Object strongRef = new Object();
        
        // 软引用
        SoftReference<Object> softRef = new SoftReference<>(new Object());
        
        // 弱引用
        WeakReference<Object> weakRef = new WeakReference<>(new Object());
        
        // 虚引用
        ReferenceQueue<Object> queue = new ReferenceQueue<>();
        PhantomReference<Object> phantomRef = new PhantomReference<>(new Object(), queue);
        
        // 手动触发GC
        System.gc();
        
        // 等待GC完成
        Thread.sleep(1000);
        
        System.out.println("强引用: " + strongRef);
        System.out.println("软引用: " + softRef.get());
        System.out.println("弱引用: " + weakRef.get());
        System.out.println("虚引用: " + phantomRef.get()); // 始终返回null
    }
}

强引用（Strong Reference）：最常见的引用类型，只要强引用存在，垃圾回收器就不会回收被引用的对象
软引用（Soft Reference）：在内存不足时，垃圾回收器会回收软引用指向的对象
弱引用（Weak Reference）：垃圾回收器在下一次GC时，无论内存是否充足，都会回收弱引用指向的对象
虚引用（Phantom Reference）：无法通过虚引用获取对象实例，唯一作用是在对象被回收时收到通知

垃圾收集算法

标记-清除算法

标记-清除（Mark-Sweep）算法是最基础的垃圾收集算法：

标记阶段：标记出所有需要回收的对象
清除阶段：回收被标记对象占用的内存
优点：实现简单
缺点：会产生内存碎片，可能导致大对象无法分配内存

复制算法

复制（Copying）算法将内存分为大小相等的两块，每次只使用其中一块：

当一块内存用完时，将存活的对象复制到另一块内存
然后清理第一块内存
优点：不会产生内存碎片
缺点：内存利用率低，只使用了一半的内存空间
应用场景：主要用于新生代的垃圾回收

标记-整理算法

标记-整理（Mark-Compact）算法结合了标记-清除算法和复制算法的优点：

标记阶段：标记出所有需要回收的对象
整理阶段：将所有存活的对象移动到一端，然后清理掉边界以外的内存
优点：不会产生内存碎片，内存利用率高
缺点：整理过程需要额外的开销
应用场景：主要用于老年代的垃圾回收

分代收集算法

分代收集（Generational Collection）算法是根据对象的存活周期将内存划分为几个区域：

新生代：存放新创建的对象，采用复制算法
- Eden空间：新对象优先在Eden空间分配
- Survivor空间：分为From Survivor和To Survivor，用于存放经历过GC但仍存活的对象
老年代：存放存活时间较长的对象，采用标记-清除或标记-整理算法

垃圾收集器

Serial收集器

Serial收集器是最基本、发展历史最悠久的收集器：

单线程收集器
在收集过程中会暂停所有用户线程（Stop-The-World）
适用于Client模式下的虚拟机

ParNew收集器

ParNew收集器是Serial收集器的多线程版本：

多线程收集器
同样会产生Stop-The-World停顿
是Server模式下新生代的首选收集器，特别是在多核CPU环境下

Parallel Scavenge收集器

Parallel Scavenge收集器是一个新生代收集器，使用复制算法：

多线程收集器
关注吞吐量（吞吐量=运行用户代码时间/(运行用户代码时间+垃圾收集时间)）
提供自适应调节策略

Serial Old收集器

Serial Old收集器是Serial收集器的老年代版本：

单线程收集器
使用标记-整理算法
适用于Client模式，或作为CMS收集器的后备方案

Parallel Old收集器

Parallel Old收集器是Parallel Scavenge收集器的老年代版本：

多线程收集器
使用标记-整理算法
适合注重吞吐量的应用场景

CMS收集器

CMS（Concurrent Mark Sweep）收集器是一种以获取最短回收停顿时间为目标的收集器：

基于标记-清除算法
主要步骤：初始标记、并发标记、重新标记、并发清除
优点：并发收集，低停顿
缺点：对CPU资源敏感，可能产生内存碎片，无法处理浮动垃圾

G1收集器

G1（Garbage-First）收集器是面向服务端应用的垃圾收集器：

基于标记-整理算法
将堆内存划分为大小相等的独立区域（Region）
可以精确控制停顿时间
支持分代收集
适用于大堆内存环境

ZGC收集器

ZGC（Z Garbage Collector）是Java 11引入的低延迟垃圾收集器：

停顿时间极短（<10ms）
支持TB级内存
使用读屏障技术实现并发处理
适用于对延迟极为敏感的应用场景

Shenandoah收集器

Shenandoah收集器是一种低暂停时间的垃圾收集器：

支持大堆内存
停顿时间不受堆大小影响
使用并发标记-整理算法

GC日志分析

java

// 开启GC日志的JVM参数
/*
-XX:+PrintGCDetails
-XX:+PrintGCDateStamps
-Xloggc:gc.log
*/

// GC日志示例分析
/*
2023-06-15T10:00:00.123+0800: [GC (Allocation Failure) [PSYoungGen: 1024K->512K(2048K)] 1024K->608K(8192K), 0.0012345 secs] [Times: user=0.01 sys=0.00, real=0.00 secs]
*/

GC日志内容解释：

时间戳：GC发生的时间
GC类型：Minor GC还是Full GC
原因：GC触发的原因（如Allocation Failure表示分配内存失败）
内存变化：GC前后各区域的内存使用情况
耗时：GC执行的时间

内存分配与回收策略

对象优先在Eden分配

大多数情况下，对象在新生代Eden区中分配，当Eden区没有足够空间时，触发Minor GC。

大对象直接进入老年代

大对象（如很长的字符串或数组）会直接进入老年代，避免在Eden区和Survivor区之间频繁复制。

java

// 设置大对象阈值的JVM参数
/*
-XX:PretenureSizeThreshold=3145728 // 3MB，超过此大小的对象直接进入老年代
*/

长期存活的对象将进入老年代

对象每经历一次Minor GC并存活，年龄增加1岁，当年龄达到阈值时，进入老年代。

java

// 设置晋升老年代年龄阈值的JVM参数
/*
-XX:MaxTenuringThreshold=15 // 默认值为15
*/

动态对象年龄判定

如果在Survivor空间中相同年龄的所有对象大小的总和大于Survivor空间的一半，年龄大于或等于该年龄的对象可以直接进入老年代。

空间分配担保

在Minor GC发生前，JVM会检查老年代最大可用的连续空间是否大于新生代所有对象的总空间：

如果成立，则Minor GC可以安全进行
如果不成立，会查看HandlePromotionFailure设置是否允许担保失败
- 如果允许，则继续检查老年代最大可用连续空间是否大于历次晋升到老年代对象的平均大小
  - 如果大于，则尝试进行Minor GC，但有风险
  - 如果小于，则改为进行Full GC
- 如果不允许，则直接进行Full GC

JVM调优

JVM参数类型

JVM参数主要分为三类：

标准参数：所有JVM都支持的参数，以-开头
bash
```
-version
-help
-cp <classpath>
```

非标准参数：以-X开头，特定版本JVM支持的参数

bash

-Xms<size>  # 初始堆大小
-Xmx<size>  # 最大堆大小
-Xmn<size>  # 新生代大小
-Xss<size>  # 线程栈大小

非稳定参数：以-XX开头，用于JVM调优和Debug

bash

-XX:+UseG1GC  # 使用G1垃圾收集器
-XX:MaxGCPauseMillis=200  # 最大GC暂停时间目标
-XX:ParallelGCThreads=4  # GC线程数

常用JVM调优参数

bash

# 堆内存设置
-Xms512m    # 初始堆大小
-Xmx1024m   # 最大堆大小，建议与-Xms设置相同，避免频繁调整堆大小

# 新生代设置
-Xmn256m    # 新生代大小，一般设为堆大小的1/3到1/4
-XX:SurvivorRatio=8  # Eden区与Survivor区的比例，默认8:1:1

# 老年代设置
-XX:NewRatio=2  # 新生代与老年代的比例，默认2:1

# 垃圾收集器选择
-XX:+UseSerialGC       # 使用Serial收集器
-XX:+UseParNewGC       # 使用ParNew收集器
-XX:+UseParallelGC     # 使用Parallel Scavenge收集器
-XX:+UseParallelOldGC  # 使用Parallel Old收集器
-XX:+UseConcMarkSweepGC  # 使用CMS收集器
-XX:+UseG1GC           # 使用G1收集器
-XX:+UseZGC            # 使用ZGC收集器（Java 11+）

# GC性能调优
-XX:MaxGCPauseMillis=200  # G1收集器的最大暂停时间目标
-XX:GCTimeRatio=99       # Parallel收集器的吞吐量目标
-XX:ParallelGCThreads=4  # GC线程数
-XX:ConcGCThreads=2      # CMS收集器的并发线程数

# 内存分配调优
-XX:PretenureSizeThreshold=3145728  # 大对象直接进入老年代的阈值（3MB）
-XX:MaxTenuringThreshold=15        # 对象晋升老年代的年龄阈值

# 字符串常量池设置
-XX:+UseStringDeduplication  # 启用字符串去重（G1收集器）

# 元空间设置（JDK 8+）
-XX:MetaspaceSize=128m      # 元空间初始大小
-XX:MaxMetaspaceSize=256m   # 元空间最大大小

# GC日志设置
-XX:+PrintGCDetails        # 打印详细GC日志
-XX:+PrintGCDateStamps     # 打印GC发生的时间戳
-Xloggc:gc.log             # GC日志文件路径
-XX:+UseGCLogFileRotation  # 启用GC日志文件轮转
-XX:NumberOfGCLogFiles=10  # GC日志文件数量
-XX:GCLogFileSize=100M     # GC日志文件大小

# 监控与诊断
-XX:+HeapDumpOnOutOfMemoryError  # OOM时自动生成堆转储文件
-XX:HeapDumpPath=./heapdump.hprof  # 堆转储文件路径
-XX:+PrintCommandLineFlags     # 打印JVM命令行参数

JVM调优案例

案例1：Web应用调优

场景描述：一个中等规模的Web应用，运行在4核8G服务器上。

调优目标：

降低GC暂停时间
提高系统吞吐量
避免OOM异常

调优参数：

bash

java -Xms4g -Xmx4g -Xmn2g -XX:SurvivorRatio=8 -XX:+UseG1GC -XX:MaxGCPauseMillis=200 -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=./heapdump.hprof -jar app.jar

参数说明：

-Xms4g -Xmx4g：设置初始和最大堆大小为4G，充分利用服务器内存
-Xmn2g：新生代大小为2G，占堆大小的50%
-XX:SurvivorRatio=8：Eden区与Survivor区的比例为8:1:1
-XX:+UseG1GC：使用G1收集器，适合Web应用对响应时间的要求
-XX:MaxGCPauseMillis=200：设置最大GC暂停时间目标为200ms
-XX:+HeapDumpOnOutOfMemoryError：OOM时生成堆转储文件，便于分析问题

案例2：批处理应用调优

场景描述：一个数据处理应用，主要进行大量数据计算，运行在8核16G服务器上。

调优目标：

最大化吞吐量
高效处理大数据集

调优参数：

bash

java -Xms12g -Xmx12g -XX:+UseParallelGC -XX:+UseParallelOldGC -XX:GCTimeRatio=99 -XX:ParallelGCThreads=8 -jar batch-app.jar

参数说明：

-Xms12g -Xmx12g：设置较大的堆内存，充分利用服务器资源
-XX:+UseParallelGC -XX:+UseParallelOldGC：使用Parallel收集器，注重吞吐量
-XX:GCTimeRatio=99：设置吞吐量目标为99%，即GC时间不超过1%
-XX:ParallelGCThreads=8：设置GC线程数为8，与CPU核心数一致

JVM诊断工具

jps - Java进程状态工具

jps命令用于列出正在运行的JVM进程。

bash

# 列出所有JVM进程
jps

# 列出JVM进程并显示完整的类名
jps -l

# 列出JVM进程及其JVM参数
jps -v

jstat - JVM统计监控工具

jstat命令用于监控JVM的各种统计信息。

bash

# 查看类加载统计
jstat -class <pid>

# 查看内存使用统计
jstat -gc <pid>

# 查看GC统计，每1000毫秒输出一次，共输出10次
jstat -gcutil <pid> 1000 10

# 查看编译统计
jstat -compiler <pid>

jinfo - JVM配置信息工具

jinfo命令用于查看和修改JVM的配置信息。

bash

# 查看JVM的所有配置信息
jinfo <pid>

# 查看特定JVM参数的值
jinfo -flag <param_name> <pid>

# 动态修改JVM参数（部分参数支持）
jinfo -flag +<param_name> <pid>  # 开启参数
jinfo -flag -<param_name> <pid>  # 关闭参数
jinfo -flag <param_name>=<value> <pid>  # 设置参数值

jmap - JVM内存映射工具

jmap命令用于生成堆转储快照和内存使用情况统计。

bash

# 生成堆转储文件
jmap -dump:format=b,file=heap.bin <pid>

# 查看堆内存使用情况
jmap -heap <pid>

# 查看对象实例统计
jmap -histo <pid>

# 查看年轻代和老年代的对象统计
jmap -histo:live <pid>  # 会先触发一次Full GC

jstack - JVM堆栈跟踪工具

jstack命令用于生成线程堆栈信息，用于分析线程死锁、阻塞等问题。

bash

# 生成线程堆栈信息
jstack <pid>

# 查看锁的持有情况
jstack -l <pid>

# 查看混合模式的堆栈信息
jstack -m <pid>

JConsole - JVM监控控制台

JConsole是一个基于GUI的JVM监控工具。

bash

# 启动JConsole
jconsole

# 连接到特定的JVM进程
jconsole <pid>

JConsole可以监控：

内存使用情况
线程状态
类加载信息
CPU使用情况
MBean属性和操作

VisualVM - 可视化VM工具

VisualVM是一个功能更强大的JVM监控和分析工具。

bash

# 启动VisualVM（JDK 9之前）
jvisualvm

# JDK 9+中，VisualVM不再包含在JDK中，需要单独下载

VisualVM的主要功能：

监控JVM性能和资源使用情况
分析堆转储文件
分析线程堆栈
分析CPU和内存使用情况
插件扩展功能

Java Flight Recorder (JFR) 和 Java Mission Control (JMC)

JFR是一个低开销的事件收集框架，JMC是一个用于分析JFR数据的工具。

bash

# 启动JFR记录
jcmd <pid> JFR.start duration=60s filename=recording.jfr

# 停止JFR记录
jcmd <pid> JFR.stop

# 启动JMC（JDK 7u40及以上版本）
jmc

JVM性能监控与分析

内存问题分析

内存泄漏

内存泄漏是指对象不再被应用程序使用，但垃圾回收器无法回收它们的情况。

识别内存泄漏的方法：

观察堆内存使用情况，看是否持续增长
分析堆转储文件，找出占用内存最多的对象
检查对象引用链，找出是什么阻止了它们被回收

常见的内存泄漏场景：

静态集合类持有对象引用
监听器和回调未正确注销
数据库连接、文件流等资源未关闭
内部类持有外部类引用

内存溢出

内存溢出（OutOfMemoryError）是指JVM无法分配足够的内存空间。

常见的内存溢出类型：

Java heap space：堆内存不足
PermGen space/Metaspace：方法区/元空间不足
Java virtual machine stack：线程栈溢出
Requested array size exceeds VM limit：请求创建的数组大小超过虚拟机限制

解决方法：

增加相应内存区域的大小
优化代码，减少内存使用
检查是否存在内存泄漏

线程问题分析

死锁

死锁是指两个或多个线程相互等待对方释放资源，导致所有线程都无法继续执行的情况。

java

// 死锁示例
public class DeadlockDemo {
    private static Object lock1 = new Object();
    private static Object lock2 = new Object();
    
    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            synchronized (lock1) {
                System.out.println("Thread 1: Holding lock 1");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {}
                System.out.println("Thread 1: Waiting for lock 2");
                synchronized (lock2) {
                    System.out.println("Thread 1: Holding lock 1 and lock 2");
                }
            }
        });
        
        Thread thread2 = new Thread(() -> {
            synchronized (lock2) {
                System.out.println("Thread 2: Holding lock 2");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {}
                System.out.println("Thread 2: Waiting for lock 1");
                synchronized (lock1) {
                    System.out.println("Thread 2: Holding lock 2 and lock 1");
                }
            }
        });
        
        thread1.start();
        thread2.start();
    }
}

检测死锁的方法：

使用jstack命令生成线程堆栈，查找死锁信息
使用JConsole或VisualVM监控线程状态

避免死锁的方法：

按相同顺序获取锁
使用可中断的锁（如ReentrantLock）
设置获取锁的超时时间
使用Lock.tryLock()尝试获取锁

线程阻塞

线程阻塞是指线程在等待资源或条件时处于非运行状态。

常见的线程阻塞原因：

IO操作阻塞
等待锁释放
等待其他线程的结果
线程睡眠

分析线程阻塞的方法：

使用jstack查看线程堆栈，分析阻塞原因
使用JConsole监控线程状态

GC问题分析

频繁GC

频繁GC会导致应用程序性能下降，响应时间变长。

频繁GC的可能原因：

堆内存设置过小
对象创建速度过快
内存泄漏
新生代设置不合理

解决方法：

增加堆内存大小
优化对象创建，减少临时对象
检查并修复内存泄漏
调整新生代和老年代的比例

GC停顿时间过长

GC停顿时间过长会影响应用程序的响应时间，特别是对延迟敏感的应用。

解决方法：

使用低停顿的垃圾收集器（如G1、ZGC）
调整GC相关参数，如-XX:MaxGCPauseMillis
增加GC线程数
优化内存使用模式

总结

本文深入探讨了JVM的各个方面，包括类加载机制、运行时数据区、垃圾回收机制、内存分配与回收策略、JVM调优以及诊断工具等。了解JVM的工作原理对于Java开发者来说是非常重要的，它可以帮助开发者编写更高效的代码，更好地解决性能问题，以及更有效地进行应用程序调优。

JVM调优是一个复杂的过程，需要根据应用程序的特点和运行环境进行调整。在进行调优时，应该首先建立性能基准，然后通过监控和分析工具找出性能瓶颈，最后进行有针对性的优化。最重要的是，每次优化后都应该进行验证，确保优化效果符合预期。

JVM深入理解 ​

JVM概述 ​

JVM的作用 ​

JVM架构 ​

类加载机制 ​

类加载器层次结构 ​

类加载过程 ​

类加载器的双亲委派模型 ​

类加载器的破坏 ​

运行时数据区 ​

程序计数器（Program Counter Register） ​

Java虚拟机栈（Java Virtual Machine Stack） ​

本地方法栈（Native Method Stack） ​

Java堆（Java Heap） ​

方法区（Method Area） ​

运行时常量池（Runtime Constant Pool） ​

垃圾回收机制 ​

垃圾回收的基本概念 ​

对象存活判断算法 ​

引用计数法 ​

可达性分析算法 ​

引用类型 ​

垃圾收集算法 ​

标记-清除算法 ​

复制算法 ​

标记-整理算法 ​

分代收集算法 ​

垃圾收集器 ​

Serial收集器 ​

ParNew收集器 ​

Parallel Scavenge收集器 ​

Serial Old收集器 ​

Parallel Old收集器 ​

CMS收集器 ​

G1收集器 ​

ZGC收集器 ​

Shenandoah收集器 ​

GC日志分析 ​

内存分配与回收策略 ​

对象优先在Eden分配 ​

大对象直接进入老年代 ​

长期存活的对象将进入老年代 ​

动态对象年龄判定 ​

空间分配担保 ​

JVM调优 ​

JVM参数类型 ​

常用JVM调优参数 ​

JVM调优案例 ​

案例1：Web应用调优 ​

案例2：批处理应用调优 ​

JVM诊断工具 ​

jps - Java进程状态工具 ​

jstat - JVM统计监控工具 ​

jinfo - JVM配置信息工具 ​

jmap - JVM内存映射工具 ​

jstack - JVM堆栈跟踪工具 ​

JConsole - JVM监控控制台 ​

VisualVM - 可视化VM工具 ​

Java Flight Recorder (JFR) 和 Java Mission Control (JMC) ​

JVM性能监控与分析 ​

内存问题分析 ​

内存泄漏 ​

内存溢出 ​

线程问题分析 ​

死锁 ​

线程阻塞 ​

GC问题分析 ​

频繁GC ​

GC停顿时间过长 ​

总结 ​

JVM深入理解

JVM概述

JVM的作用

JVM架构

类加载机制

类加载器层次结构

类加载过程

类加载器的双亲委派模型

类加载器的破坏

运行时数据区

程序计数器（Program Counter Register）

Java虚拟机栈（Java Virtual Machine Stack）

本地方法栈（Native Method Stack）

Java堆（Java Heap）

方法区（Method Area）

运行时常量池（Runtime Constant Pool）

垃圾回收机制

垃圾回收的基本概念

对象存活判断算法

引用计数法

可达性分析算法

引用类型

垃圾收集算法

标记-清除算法

复制算法

标记-整理算法

分代收集算法

垃圾收集器

Serial收集器

ParNew收集器

Parallel Scavenge收集器

Serial Old收集器

Parallel Old收集器

CMS收集器

G1收集器

ZGC收集器

Shenandoah收集器

GC日志分析

内存分配与回收策略

对象优先在Eden分配

大对象直接进入老年代

长期存活的对象将进入老年代

动态对象年龄判定

空间分配担保

JVM调优

JVM参数类型

常用JVM调优参数

JVM调优案例

案例1：Web应用调优

案例2：批处理应用调优

JVM诊断工具

jps - Java进程状态工具

jstat - JVM统计监控工具

jinfo - JVM配置信息工具

jmap - JVM内存映射工具

jstack - JVM堆栈跟踪工具

JConsole - JVM监控控制台

VisualVM - 可视化VM工具

Java Flight Recorder (JFR) 和 Java Mission Control (JMC)

JVM性能监控与分析

内存问题分析

内存泄漏

内存溢出

线程问题分析

死锁

线程阻塞

GC问题分析

频繁GC

GC停顿时间过长

总结