JVM 双亲委派机制

   一、从 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 对象。这一过程分为五个阶段：

1. 加载（Loading）：通过类的全限定名获取二进制字节流，生成 Class 对象。
2. 验证（Verification）：检查字节码的安全性和合规性，防止恶意代码攻击。
3. 准备（Preparation）：为静态变量分配内存并设置默认初始值（如 int 初始化为 0）。
4. 解析（Resolution）：将符号引用转换为直接引用（如将类名转换为内存地址）。
5. 初始化（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;}@Overrideprotected 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 工程师的必经之路。