JVM 之双亲委派机制与打破双亲委派-优快云博客

本文链接：https://blog.youkuaiyun.com/Libra_97/article/details/148980540

JVM 之双亲委派机制与打破双亲委派

一、什么是双亲委派？

当类加载器收到类加载请求时，会先将请求委托给父类加载器处理，最终传递至顶层的启动类加载器（Bootstrap Class Loader）。只有当父类加载器无法完成加载任务时，子类加载器才会尝试自行加载。

二、为什么需要双亲委派机制？

1. 安全层面

防止恶意类替换核心类（如java.lang.Object）：所有类加载最终由顶层加载器处理，确保核心类来自可信来源。

2. 避免重复加载

父类加载器已加载的类，子类无需重复加载，提升性能。例如：
- 无论哪个加载器加载java.lang.Object（位于rt.jar），最终都由启动类加载器处理，保证全局唯一。

三、双亲委派机制源码解析

/**
 * 类加载核心方法，实现双亲委派逻辑
 */
protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
    synchronized (getClassLoadingLock(name)) {
        // 1. 先检查类是否已加载，避免重复加载
        Class<?> c = findLoadedClass(name);
        if (c == null) {
            long t0 = System.nanoTime();
            try {
                // 2. 委托父类加载器加载
                if (parent != null) {
                    c = parent.loadClass(name, false);
                } else {
                    // 父类为null时，使用启动类加载器
                    c = findBootstrapClassOrNull(name);
                }
            } catch (ClassNotFoundException e) {
                // 父类加载失败，继续由子类尝试
            }

            // 3. 父类加载失败时，调用findClass自行加载
            if (c == null) {
                long t1 = System.nanoTime();
                c = findClass(name);
                // 性能统计
                sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
                sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
                sun.misc.PerfCounter.getFindClasses().increment();
            }
        }
        // 4. 按需解析类
        if (resolve) {
            resolveClass(c);
        }
        return c;
    }
}

四、为什么需要破坏双亲委派？

1. 双亲委派的局限性

双亲委派机制实现了自上而下的类加载顺序（子类委托父类加载），但在以下场景中会遇到问题：

基础类需要调用用户自定义类：如 JDK 提供的 SPI（Service Provider Interface）机制。
类加载顺序的逆向需求：父类加载器需要依赖子类加载器加载的类。

2. 典型场景：SPI 机制与数据库驱动

以 JDBC 驱动加载为例：

java.sql.Driver接口定义在 JDK 中（由启动类加载器加载），但其实现类（如 MySQL 驱动）由第三方厂商提供，需由系统类加载器（AppClassLoader） 加载。
启动类加载器无法直接加载用户实现的驱动类，因此需要打破双亲委派，由父类加载器反向委托子类加载器完成加载。

五、如何破坏双亲委派？

1. 重写`loadClass`方法（JDK 1.2 前兼容方式）

原理：双亲委派逻辑核心在loadClass方法中，重写该方法可绕过默认的委托流程。

示例

protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
    // 自定义加载逻辑，不调用父类loadClass方法
    if (需要自行加载的条件) {
        return findClass(name);
    }
    return super.loadClass(name, resolve);
}

注意：JDK 1.2 后推荐重写findClass方法（而非loadClass），但为向前兼容仍保留了重写loadClass的能力。

2. 使用线程上下文类加载器（Thread Context ClassLoader）

核心机制：通过Thread.currentThread().setContextClassLoader()设置加载器，允许父类加载器使用子类加载器加载类。
应用场景
- JDBC 驱动加载：DriverManager通过ServiceLoader.load(Driver.class)调用上下文类加载器加载驱动实现类。
- Spring 框架：通过上下文类加载器实现逆向依赖加载。

源码示例

// 设置线程上下文类加载器
Thread.currentThread().setContextClassLoader(loader);

// 在DriverManager中使用上下文类加载器
ServiceLoader<Driver> loadedDrivers = ServiceLoader.load(Driver.class);

六、破坏双亲委派的典型案例：DriverManager 加载流程

static {
    loadInitialDrivers();
    System.out.println("JDBC DriverManager initialized");
}

private static void loadInitialDrivers() {
    // 1. 获取系统属性中的驱动配置
    String drivers = System.getProperty("jdbc.drivers");
    
    // 2. 使用ServiceLoader加载驱动（核心：通过上下文类加载器加载）
    ServiceLoader<Driver> loadedDrivers = ServiceLoader.load(Driver.class);
    Iterator<Driver> driversIterator = loadedDrivers.iterator();
    
    // 3. 加载用户定义的驱动类
    String[] driversList = drivers.split(":");
    for (String aDriver : driversList) {
        // 关键：通过系统类加载器加载用户实现的驱动类
        Class.forName(aDriver, true, ClassLoader.getSystemClassLoader());
    }
}

核心逻辑：

ServiceLoader.load(Driver.class)会默认使用当前线程的上下文类加载器（通常是系统类加载器），实现父类（JDK 核心类）委托子类（用户类加载器）加载驱动实现类。

七、总结：双亲委派与破坏场景对比

场景	是否遵循双亲委派	实现方式
加载 JDK 核心类	是	启动类加载器直接加载
加载应用自定义类	是	应用类加载器→扩展类加载器→启动类加载器
加载 SPI 实现类	否	线程上下文类加载器逆向加载
自定义类加载器	可选择	重写`loadClass`或使用上下文加载器