结论先行:双亲委派的本质是「加载请求逐层上交,父加载器搞不定才自己来」,目的是保证核心类库的唯一和安全。但有三类场景天生需要破坏它:容器隔离(Tomcat)、核心库反向加载实现类(SPI)、热部署。理解「为什么必须破坏」,比背加载器层次有用得多。
加载一个类到底做了什么
类生命周期是加载 → 验证 → 准备 → 解析 → 初始化。两个常考点:准备阶段给静态变量赋的是零值(static int a = 1 此时 a 等于 0),真正赋 1 发生在初始化阶段;初始化由首次「主动使用」触发(new、读写静态字段、反射调用等),所以类是懒加载的。这里有一个衍生结论值得记住:类的初始化是线程安全的,JVM 保证 <clinit> 只执行一次——静态内部类单例写法不需要加锁,靠的正是类初始化锁。另一个衍生点是类没有显式「卸载」API,回收的唯一途径是回收它的加载器,这个限制决定了热部署的实现方式。
加载过程的产物可以自己验证:Class.forName("X") 会触发初始化,ClassLoader.loadClass("X") 只加载不初始化——JDBC 驱动历史上要求 forName 正是为了执行驱动类静态块里的注册逻辑,现代容器走 SPI 机制后这个显式调用就不再必要。两个 API 的差别是高频面试点,也是排查「静态块没执行」类问题的钥匙。
双亲委派:三层结构
三层加载器各管一段:Bootstrap 加载核心类(Object、String),Platform(JDK 9 前的 Ext)加载扩展类,Application 加载 classpath。工作方式在 ClassLoader.loadClass 里:
protected Class<?> loadClass(String name, boolean resolve)
throws ClassNotFoundException {
synchronized (getClassLoadingLock(name)) {
Class<?> c = findLoadedClass(name); // 1. 已经加载过?
if (c == null) {
try {
if (parent != null) {
c = parent.loadClass(name); // 2. 先委托父加载器
} else {
c = findBootstrapClassOrNull(name);
}
} catch (ClassNotFoundException e) {
// 父加载器管辖范围内没有这个类
}
if (c == null) {
c = findClass(name); // 3. 父加载器管不了,自己找
}
}
return c;
}
}
两个收益:同一个类只会被加载一次(类的唯一性由「加载器 + 类名」共同保证);你写一个 java.lang.String 也无法欺骗 JVM,因为请求会先到 Bootstrap,核心类早就加载过了。注意唯一性的准确表述:同一个类文件被两个不同的加载器加载,得到的是两个互不相干的 Class 对象,instanceof 不成立、互相赋值抛 ClassCastException——「加载器也是类型的一部分」这句话,是后面所有破坏场景与线上诡异问题的钥匙。
层次关系可以自己验证:String.class.getClassLoader() 返回 null(Bootstrap 由虚拟机自身实现,Java 层不可见);ClassLoader.getSystemClassLoader() 拿到 Application 加载器;自定义加载器不传 parent 时默认父级就是它。把这几个值打印一遍,三层结构就不再抽象。
为什么要破坏它
场景一:SPI。 JDBC 的接口 DriverManager 由 Bootstrap 加载,实现类 mysql-connector 在 classpath 由 Application 加载,但 Bootstrap 根据委派模型看不见下层的类。解法是线程上下文类加载器:核心库通过 Thread.currentThread().getContextClassLoader() 拿到 Application 加载器去加载厂商实现,相当于开了一条「逆向通道」:
// JDBC 驱动加载的逆向通道(简化示意)
ClassLoader tccl = Thread.currentThread().getContextClassLoader();
Class<?> driverClass =
Class.forName("com.mysql.cj.jdbc.Driver", true, tccl);
场景二:容器隔离。 Tomcat 需要两个 Web 应用各自使用不同版本的同一个类,双亲委派的「全局唯一」反而成了障碍。WebappClassLoader 的做法是反过来:先在自己管辖范围内找,找不到才委托父加载器,实现应用之间的类隔离。
场景三:热部署。 类一旦加载无法单独卸载(除非回收整个 ClassLoader),热替换的唯一途径是 new 一个新的 ClassLoader 重新加载改过的类,再用新 Class 生成新对象替换旧的。OSGi、脚本引擎热更新都是这个路数。
三类场景加上模块化,破坏方式集中对照:
| 场景 | 必须破坏的原因 | 破坏手段 | 代表实现 |
|---|---|---|---|
| SPI/JDBC | 核心接口要加载下层实现类 | 线程上下文类加载器逆向加载 | DriverManager |
| Web 容器隔离 | 每应用独立的类空间 | 先自己找、再委托父级 | Tomcat WebappClassLoader |
| 热部署 | 类卸载以加载器为单位 | 新建加载器重新加载 | 脚本引擎、OSGi |
| 模块化 | 委派按模块而非层次 | 模块间导入导出关系 | OSGi / JPMS |
还有一个被忽略的历史细节:双亲委派在 JDK 1.2 才引入,更早的年代用户直接重写 loadClass 是常态,所以「破坏」从来不是禁忌,而是与历史兼容的设计延续。理解这一点,就不会把双亲委派当成不可触碰的铁律,而是「默认安全、按需破坏」的工程约定。
自定义加载器的正确姿势
实现自定义加载器时重写 findClass 而不是 loadClass——保留双亲委派骨架,只改变「自己怎么找字节码」这一步;除非你在写容器或热部署框架,否则不要轻易重写 loadClass 推翻委派逻辑:
// 错误写法:重写 loadClass 推翻委派,核心类唯一性被破坏
public class BadLoader extends ClassLoader {
@Override
public Class<?> loadClass(String name) throws ClassNotFoundException {
return findClass(name); // 自己先找:同名的 java.lang.String 会被
// 再加载一份,与 Bootstrap 那份互不兼容
}
}
// 正确写法:只重写 findClass,委派骨架原样保留
public class ReloadableLoader extends ClassLoader {
private final String pluginDir;
ReloadableLoader(String pluginDir, ClassLoader parent) {
super(parent); // 委派给父加载器的能力不变
this.pluginDir = pluginDir;
}
@Override
protected Class<?> findClass(String name) throws ClassNotFoundException {
byte[] bytes = readPluginClass(name); // 只自定义「字节码从哪来」
if (bytes == null) {
throw new ClassNotFoundException(name);
}
return defineClass(name, bytes, 0, bytes.length);
}
}
类加载引发的经典线上问题
三类高频问题值得排在排查手册里。一是依赖冲突:classpath 里同一个类出现两个版本(不同 jar 的传递依赖),加载到哪个版本取决于 classpath 顺序与加载器策略,报错形态多为 NoSuchMethodError、NoClassDefFoundError。二是重复类导致类型不兼容:自定义加载器或容器隔离场景下同一个类加载两份,instanceof 失败、强转抛 ClassCastException,报错信息里两个类名一模一样,极具迷惑性。三是初始化异常掩盖:<clinit> 抛出后类被标记为初始化失败,后续使用统一抛 NoClassDefFoundError,真实根因在第一次异常里,要看日志最早的那条。排查工具:-verbose:class 或 arthas 的 sc/jad/sm 命令能直接回答「这个类是谁加载的、字节码从哪来」。
Web 容器里还有一类专属问题:应用把第三方 jar 放进 Tomcat 的 lib 目录(容器共享层),另一个应用想用不同版本就被迫冲突——正确位置是各应用的 WEB-INF/lib。共享层只放真正全局且版本收敛的库,这条纪律能避免大部分容器类冲突。
把这些问题串起来记:类冲突的三种形态——版本冲突(加载错版本)、重复类(同一类加载两份)、初始化失败(首异常被掩盖)——对应三种排查入口:依赖树、加载器身份、最早的异常日志。三个入口都记熟,类加载类问题的排查就不再靠猜。
生产案例
某服务升级依赖版本后间歇性抛 NoSuchMethodError,涉及一个工具类的某个重载方法。排查发现新旧两个版本的 jar 同时在 classpath 里:新 jar 是直接依赖,旧 jar 是另一个内部组件的传递依赖,依赖仲裁把旧版本留了下来,运行时加载到旧版本类,而编译时用的是新签名。之后团队把三条防线固化下来:CI 里接入 maven-enforcer-plugin 的重复类检测;升级依赖后强制核对依赖树,确认关键组件版本唯一;线上备好 -verbose:class 的排查套路,第一时间确认「加载到的类来自哪个 jar」。这个案例的教训是:双亲委派保证的是「一个加载器内类不重复」,不保证「classpath 里没有重复类」——后者是构建问题,要在构建期拦截,运行期发现就已经是线上故障了。