一、从 JDK 到 JVM：Java 运行环境的基石
在 Java 开发领域，JDK（Java Development Kit）是开发者的核心工具包。它不仅包含了编译 Java 代码的工具（如 javac），还内置了 JRE（Java Runtime Environment）—— 即 Java 程序的运行时环境。而 JVM（Java Virtual Machine）则是 JRE 的核心，它如同一个 “翻译官”，将 Java 字节码转换为不同操作系统能理解的机器指令，实现了 “一次编写，到处运行” 的跨平台特性。
1.JVM 作用
Java 虚拟机负责装载字节码到其内部，解释/编译为对应平台上的机器码指令执行。
现在的 JVM 不仅可以执行 java 字节码文件,还可以执行其他语言编译后的字节码文件,是一个跨语言平台.
程序在执行之前先要把 java 代码转换成字节码（class 文件），jvm首先需要把字节码通过一定的方式 类加载器（ClassLoader）把文件加载到内存中的运行时数据区（Runtime Data Area） ，而字节码文件是jvm的一套指令集规范，并不能直接交个底层操作系统去执行，因此需要特定的命令解析器 执行引擎（Execution Engine） 将字节码翻译成底层系统指令再交由CPU 去执行，而这个过程中需要调用其他语言的接口本地库接口（NativeInterface） 来实现整个程序的功能，这就是这 4 个主要组成部分的职责与功能。
比如，当我们运行java HelloWorld时，JVM 首先通过类加载器找到HelloWorld.class文件，将二进制数据读入内存，创建HelloWorld.class对象。
二、JVM 模块划分与核心功能
JVM 的架构可分为四大模块：类加载器子系统、运行时数据区、执行引擎和本地方法接口。
1. 类加载器子系统
类加载器负责将字节码文件加载到 JVM 中。根据职责不同，JVM 提供了三种类加载器：
- 启动类加载器（Bootstrap ClassLoader）：用 C/C++ 实现，加载 Java 核心类库（如
rt.jar），位于%JAVA_HOME%/lib目录。- 扩展类加载器（Extension ClassLoader）：加载
%JAVA_HOME%/jre/lib/ext目录或java.ext.dirs指定路径的类库。- 应用程序类加载器（Application ClassLoader）：加载用户类路径（classpath）下的类，是程序默认的类加载器。
类加载器采用双亲委派机制：当一个类加载器收到加载请求时，会先委托父类加载器处理，只有父类无法加载时才尝试自己加载。这一机制确保了核心类的安全性和唯一性。例如，当尝试加载java.lang.String时，启动类加载器会优先加载核心库中的 String 类，避免用户自定义类覆盖核心类。
2. 运行时数据区
运行时数据区是 JVM 在执行程序时分配的内存区域，包含以下部分：
- 程序计数器：记录当前线程执行的字节码指令地址，是线程私有的最小内存空间。
- Java 虚拟机栈：每个线程创建时生成，保存方法调用的栈帧（包含局部变量表、操作数栈、方法返回地址等），线程私有，可能出现栈溢出（StackOverflowError）。
- 本地方法栈：管理本地方法（如 C/C++ 实现的方法）的调用。
- 堆内存：存储对象实例，是 GC（垃圾回收）的主要区域，分为新生代（Eden 和 Survivor 区）和老年代，通过分代收集算法优化回收效率。
- 方法区：存储类的元数据（如字节码、静态变量、常量池），JDK8 后称为元空间（Metaspace），逻辑上独立于堆。
3. 执行引擎
执行引擎是 JVM 的 “大脑”，负责将字节码转换为机器指令。它包含：
- 解释器：逐行解释执行字节码，启动快但效率较低。
- JIT 编译器：将频繁执行的 “热点代码” 编译为本地机器码，存储在方法区的 JIT 缓存中，提升执行效率。
- 垃圾回收器：自动回收不再使用的对象，主要针对堆内存，采用标记 - 复制、标记 - 清除、标记 - 压缩等算法。
4. 本地方法接口
本地方法接口允许 Java 调用非 Java 代码（如 C/C++），通过本地方法库实现与操作系统或硬件的交互，例如文件操作、网络通信等。
三、类加载的核心机制与实践
1. 类加载的作用与过程
类加载的核心任务是将字节码文件转换为 JVM 可识别的 Class 对象。这一过程分为五个阶段：
- 加载（Loading）：通过类的全限定名获取二进制字节流，生成 Class 对象。
- 验证（Verification）：检查字节码的安全性和合规性，防止恶意代码攻击。
- 准备（Preparation）：为静态变量分配内存并设置默认初始值（如 int 初始化为 0）。
- 解析（Resolution）：将符号引用转换为直接引用（如将类名转换为内存地址）。
- 初始化（Initialization）：执行静态代码块和静态变量赋值，这是类加载的最后一步。
2. 类加载的触发时机
类加载遵循 “按需加载” 原则，只有在需要使用类时才会触发。根据 JVM 规范，以下情况会强制加载类（主动引用）：
假设我们有一个 Hello 类
package com.ffyc.classload;
/**
* 问题：什么时候类会被加载？
*
*/
public class Hello {
// 作为静态成员时，类会被加载
static {
System.out.println("类被加载了......");
}
//作为main方法时，类也会被加载
public static void main(String[] args) {
System.out.println("1111111");
}
}
TestHello 类
package com.ffyc.classload;
public class TestHello {
public static void main(String[] args) throws ClassNotFoundException {
new Hello(); // 触发Hello类的初始化，并加载Hello类
Class.forName("com.ffyc.classload.Hello");//反射方式加载Hello类
}
}
3. 类加载的典型案例
(1) 主动引用（必定触发加载）
new实例化对象MyClass obj = new MyClass(); // 首次创建对象时加载- 访问类的静态变量或静态方法
int value = MyClass.staticField; // 访问静态字段 MyClass.staticMethod(); // 调用静态方法 - 反射调用（
Class.forName()）Class.forName("com.example.MyClass"); // 通过反射强制加载 - 初始化子类时（父类优先加载）
class Parent {} class Child extends Parent {} // 首次使用 Child 时，会先加载 Parent - 作为程序入口的主类（
main方法所在类）public class Main { public static void main(String[] args) {} // JVM 启动时加载 }
(2) 被动引用（不会触发加载）
- 通过子类引用父类的静态字段
class Parent { static int value = 10; } class Child extends Parent {} System.out.println(Child.value); // 仅加载 Parent，不加载 Child - 通过数组定义类
MyClass[] arr = new MyClass[10]; // 不会加载 MyClass - 引用常量（常量在编译期优化）
class MyClass { final static int VALUE = 10; } System.out.println(MyClass.VALUE); // 不触发加载（常量池直接访问）
四、类加载器分类
站在 java 开发人员的角度来看,类加载器就应当划分得更细致一些. 保持者三层类加载器.
1. 启动类加载器 (BootStrap ClassLoader)
这个类加载器使用 C/C++语言实现,也叫引导类加载器，嵌套在 JVM 内部.它用来加载java 核心类库.负责加载扩展类加载器和应用类加载器,并为他们指定父类加载器. 出于安全考虑,启动类加载器只加载存放在\lib 目录,或者被-Xbootclasspath 参数锁指定的路径中存储放的类.
2. 扩展类加载器(Extension ClassLoader)
Java 语言编写的,由 sun.misc.Launcher$ExtClassLoader 实现. 派生于 ClassLoader 类. 从 java.ext.dirs 系统属性所指定的目录中加载类库,或从JDK 系统安装目录的jre/lib/ext 子目录(扩展目录)下加载类库.如果用户创建的jar 放在此目录下,也会自动由扩展类加载器加载.
3. 应用程序类加载器(系统类加载器 Application ClassLoader)
Java 语言编写的,由 sun.misc.Launcher$AppClassLoader 实现.派生于 ClassLoader 类. 加载我们自己定义的类,用于加载用户类路径(classpath)上所有的类. 该类加载器是程序中默认的类加载器.ClassLoader 类 ， 它 是 一 个 抽 象 类 ， 其 后 所 有的类加载器都继承自ClassLoader（不包括启动类加载器）
五、双亲委派机制
Java 虚拟机对 class 文件采用的是按需加载的方式,也就是说当需要该类时才会将它的 class 文件加载到内存中生成 class 对象.而且加载某个类的class 文件时,Java 虚拟机采用的是双亲委派模式,即把请求交由父类处理,它是一种任务委派模式.
工作原理:
1. 如果一个类加载器收到了类加载请求,它并不会自己先去加载,而是把这个请求委托给父类的加载器去执行.
2. 如果父类加载器还存在其父类加载器,则进一步向上委托,依次递归,请求最终将到达顶层的启动类加载器.
3. 如果父类加载器可以完成类的加载任务,就成功返回,倘若父类加载器无法完成加载任务,子加载器才会尝试自己去加载,这就是双亲委派机制. 如果均加载失败，就会抛出 ClassNotFoundException 异常。
那么思考一下，如果我们自定义一个 String 类，会被加载吗？
直接上示例去验证你的答案
package java.lang;
/**
* 测试双亲委派机制
*/
public class String {
static {
System.out.println("自定义 String 类被加载！");
}
}
package com.ffyc.classload;
public class TestHello {
public static void main(String[] args) {
new Hello(); // 触发Hello类的初始化，并加载Hello类
try {
Class.forName("com.ffyc.classload.Hello");//反射方式加载Hello类
Class.forName("java.lang.String");
} catch (ClassNotFoundException e) {
throw new RuntimeException(e);
}
System.out.println("String类加载器为："+ String.class.getClassLoader()+"所以属于启动类加载器");
System.out.println("Hello类加载器为："+Hello.class.getClassLoader()+"所以属于系统类加载器");
}
}
输出结果为，并没有看到 "自定义 String 类被加载！" 这句话
可以看到，自定义的String 类虽然和jdk的String类同包同名，但还是没有被加载，这就是双亲委派机制，那么问题来了，我就想让它加载我自己定义的String类，该怎么做？
六、如何打破双亲委派机制
Java 虚拟机的类加载器本身可以满足加载的要求，但是也允许开发者自定义类加载器。 在 ClassLoader 类中涉及类加载的方法有两个,loadClass(String name), findClass(String name),这两个方法并没有被 final 修饰,也就表示其他子类可以重写. 重写 findClass 方法 我们可以通过自定义类加载重写方法打破双亲委派机制, 再例如 tomcat 等都有自己定义的类加载器.
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
public class CustomClassLoader extends ClassLoader {
private final String classPath;
public CustomClassLoader(String classPath) {
this.classPath = classPath;
}
@Override
protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
synchronized (getClassLoadingLock(name)) {
// 检查是否已加载过该类
Class<?> loadedClass = findLoadedClass(name);
if (loadedClass != null) {
return loadedClass;
}
// 打破双亲委派：先尝试自己加载，再委托父类
try {
// 自定义加载逻辑（例如从指定路径加载类）
byte[] classBytes = loadClassBytes(name);
if (classBytes != null) {
return defineClass(name, classBytes, 0, classBytes.length);
}
} catch (IOException e) {
// 加载失败，继续委托父类加载器
}
// 委托父类加载器（保留原有机制的兜底）
return super.loadClass(name, resolve);
}
}
private byte[] loadClassBytes(String className) throws IOException {
// 将类名转换为文件路径（例如com.example.MyClass → /path/com/example/MyClass.class）
String path = classPath + File.separator + className.replace('.', File.separatorChar) + ".class";
File file = new File(path);
if (!file.exists()) {
return null;
}
try (FileInputStream fis = new FileInputStream(file)) {
byte[] bytes = new byte[(int) file.length()];
fis.read(bytes);
return bytes;
}
}
}public class Main {
public static void main(String[] args) throws Exception {
// 创建自定义类加载器，指定加载路径
CustomClassLoader loader = new CustomClassLoader("/path/to/classes");
// 加载自定义类（优先从指定路径加载）
Class<?> clazz = loader.loadClass("com.example.MyClass");
Object instance = clazz.newInstance();
System.out.println(instance.getClass().getClassLoader()); // 输出：CustomClassLoader
}
}七、总结
JVM 的类加载机制是 Java 程序运行的基石，它通过类加载器、运行时数据区和执行引擎的协同工作，确保了程序的跨平台性和高效执行。理解类加载的过程、时机和类加载器的工作原理，不仅能帮助开发者优化程序性能，还能深入排查类冲突、内存泄漏等问题。无论是日常开发还是高级调优，掌握 JVM 类加载机制都是成为优秀 Java 工程师的必经之路。
