JVM虚拟机中的类加载机制和双亲委派模型

川长思鸟来 2024-03-22 11:54 29阅读 0赞

**目录**

虚拟机的类加载机制

名词解释

类加载的时机

类加载的过程

1.加载（Loading）阶段

非数组类型的加载阶段与数组类型区别

2.验证（Verification）阶段

1）文件格式验证

2）元数据验证

3）字节码验证

4）符号引用验证

3.准备（Preparation）阶段

4.解析（Resolution）阶段

解析阶段中所说的直接引用与符号引用又有什么关联呢？

5.初始化（Initialization）阶段

类加载器

类与类加载器

启动类加载器（Bootstrap Class Loader）

扩展类加载器（Extension Class Loader）

应用类加载器（Application Class Loader)

双亲委派模型

双亲委派模型工作过程

双亲委派模型优点

双亲委派模型（1.8以及之前版本）

双亲委派模型（1.9以及之后版本）

破坏双亲委派模型

第一次破坏

第二次破坏

第三次破坏

如何破坏双亲委派模型？

--------------------

> 代码编译的结果从本地机器码转变为字节码，是存储格式发展的一小步，却是编程语言发展的一大步。

--------------------

## 虚拟机的类加载机制 ##

Java虚拟机吧描述类的数据从Class文件加载到内存，并对数据进行校验、转换解析喝初始化，最终形成可以被虚拟机直接使用的Java类型，这个过程被称作**虚拟机的类加载机制**。

## 名词解释 ##

> **类型** ：在实际情况中，每个Class文件都有代表着Java语言中的一个类或接口的可能，本文章中对“类型”的描述都同时蕴含着类和接口的可能性， 而需要对类和接口分开描述的场景，会特别指明。
> 
> **Class文件：**本文章所提到“Class文件”并非特指某个存在于具体磁盘中的文件，而应当是一串二进制字节流，无论其以何种形式存在，包括但不限于磁盘文件、网络、数据库、内存或者动态产生等。

## 类加载的时机 ##

一个类型从被加载到虚拟机内存中开始，到卸载出内存为止，它的整个生命周期将会经历加载（Loading）、验证（Verification）、准备（Preparation）、解析（Resolution）、初始化（Initialization）、使用（Using）和卸载（Unloading）七个阶段，其中验证、准备、解析三个部分统称为连接（Linking）。

![18efacda1c8842bca5572fc16a847522.png][]

这五个阶段的顺序是确定的，类型的加载过程必须按照这种顺序**按部就班的开始**（不是按部就班的“进行”或者按部就班的“完成”），通常都是相互交叉地混合进行的，会在一个阶段执行的过程中调用、激活另一个阶段。

**解析阶段不一定：**它在某些情况下可以在初始化阶段之后再开始 ，这是为了支持Java语言的运行时绑定特性（也称为动态绑定或晚期绑定）。

**初始化阶段，《Java虚拟机规范》则是严格规定了有且只有六种情况必须立即对类进行“初始化”（而加载、验证、准备需要在此之前开始）：**

**1）**遇到new、getstatic、putstatic或invokestatic这四条字节码指令时，如果类型没有进行初始化，则需要先触发其初始化阶段。

**能够生成这四条指令的典型Java代码场景有：**

*  使用new关键字实例化对象的时候。
 *  读取或设置一个类型的静态字段（被final修饰、已在编译期把结果放入常量池的静态字段除外）的时候。
 *  调用一个类型的静态方法的时候。

**2）**使用java.lang.reflect包的方法对类型进行反射调用的时候，如果类型没有进行过初始化，则需要先触发其初始化。

**3）**当初始化类的时候，如果发现其父类还没有进行初始化，则需要先触发其父类的初始化。

**4）**当虚拟机启动时，用户需要指定一个要执行的主类（包含main() 方法的那个类），虚拟机会先初始化这个主类。

**5）**当使用JDK7新加入的动态语言支持时，如果一个java.lang.invoke.MethodHandle实例最后的解析结果为REF\_getStatic、REF\_putStatic、REF\_invokeStatic、REF\_newInvokeSpecial四种类型的方法句柄，并且这个方法句柄对应的类没有进行过初始化，则需要先触发其初始化。

**6）**当一个接口中定义了JDK8新加入的默认方法（被default关键字修饰的接口方法）时，如果有这个接口的实现类发生了初始化，那该接口要在其之前被初始化。

**主动引用：**对于这六种会触发类型进行初始化的场景，《Java虚拟机规范》中使用了一个非常强烈的限定语——“有且只有”，这六种场景中的行为称为对一个类型进行主动引用。

**被动引用：**所有引用类型的方式都不会触发初始化，称为被动引用。

**被动引用的例子**

栗子 一：

package org.fenixsoft.classloading;
    
    /**
     * 被动使用类字段栗子一：
     * 通过子类引用父类的静态字段，不会导致子类初始化
    **/
    public class SuperClass {
        static {
            System.out.println("SuperClass init!");
        }
        public static int value = 123;
    }
    
    public class SubClass extends SuperClass {
        static {
            System.out.println("SubClass init!");
        }
    }
    
    /**
     * 非主动使用类字段演示
    **/
    public class NotInitialization {
        public static void main(String[] args) {
            System.out.println(SubClass.value);
        }
    }

> 以上代码运行结果，只会输出“SuperClass init！”，而不会输出“SubClass init！”。对于静态字段，只有直接定义这个字段的类才会被初始化，因此通过其子类来引用父类中的定义的静态字段，只会触发父类的初始化而不会触发子类的初始化。
> 
> \-XX:+TraceClassLoading参数观察到此操作时会导致子类加载的。

栗子 二：

package org.fenixsoft.classloading;
    /**
     * 被动使用类字段栗子二：
     * 通过数组定义来引用类，不会触发此类的初始化
    **/
    
    public class SuperClass {
        static {
            System.out.println("SuperClass init!");
        }
        public static int value = 123;
    }
    
    public class NotInitialization {
        public static void main(String[] args) {
            SuperClass[] sca = new SuperClass[10];
        }
    }

> 以上代码运行结果，没有输出“SuperClass init！”，说明并没有触发类org.fenixsoft.classloading.SuperClass的初始化阶段。但是这段代码里面触发了另一个名为“\[Lorg.fenixsoft.classloading.SuperClass”的类的初始化阶段，对于用户代码来说，这并不是一个合法的类型名称，它是一个由虚拟机自动生成的、直接继承于java.lang.Object的子类，创建动作由字节码指令newarray触发。

## 类加载的过程 ##

### 1.加载（Loading）阶段 ###

“加载”（Loading）阶段是整个“类加载”（Class Loading）过程中的一个阶段，在加载阶段，Java虚拟机需要完成以下三件事情：

*  通过一个类的全限定名来获取定义此类的二进制字节流。
 *  将这个字节流所代表的静态存储结构转化为方法区的运行时数据结构。
 *  在内存中生成一个代表这个类的java.lang.Class对象，作为方法区这个类的各种数据的访问入口。

#### 非数组类型的加载阶段与数组类型区别 ####

**非数组类型的加载阶段**（准确地说，是加载阶段中获取类的二进 制字节流的动作）是开发人员可控性最强的阶段。加载阶段既可以使用Java虚拟机里内置的引导类加 载器来完成，也可以由用户自定义的类加载器去完成，开发人员通过定义自己的类加载器去控制字节 流的获取方式（重写一个类加载器的findClass()或loadClass()方法），实现根据自己的想法来赋予应用 程序获取运行代码的动态性。

**数组类**而言，情况就有所不同，数组类本身不通过类加载器创建，它是由Java虚拟机直接在 内存中动态构造出来的。但数组类与类加载器仍然有很密切的关系，因为数组类的元素类型（Element Type，指的是数组去掉所有维度的类型）最终还是要靠类加载器来完成加载。

### 2.验证（Verification）阶段 ###

验证是连接阶段的第一步，这一阶段的目的是确保Class文件的字节流中包含的信息符合《Java虚拟机规范》的全部约束要求，保证这些信息被当作代码运行后不会危害虚拟机自身的安全。

验证阶段是非常重要的，这个阶段是否严谨，直接决定了Java虚拟机是否能承受恶意代码的攻 击，从代码量和耗费的执行性能的角度上讲，验证阶段的工作量在虚拟机的类加载过程中占了相当大 的比重。

验证阶段大致上会完成下面四个阶段的检验动作：文件格式验证、元数据验证、字节码验证和符合引用验证。

#### 1）文件格式验证 ####

第一阶段要验证字节流是否符合Class文件格式的规范，并且能被当前版本的虚拟机处理。

*  是否以魔数0xCAFEBABE开头。
 *  主、次版本号是否在当前Java虚拟机接受范围之内。
 *  常量池的常量中是否有不被支持的常量类型（检查常量tag标志）。
 *  指向常量的各种索引值中是否有指向不存在的常量或不符合类型的常量。
 *  CONSTANT\_Utf8\_info型的常量中是否有不符合UTF-8编码的数据。
 *  Class文件中各个部分及文件本身是否有被删除的或附加的其他信息。

#### 2）元数据验证 ####

第二阶段是对字节码描述的信息进行语义分析，以保证其描述的信息符合《Java语言规范》的要求。

*  这个类是否有父类（除了java.lang.Object之外，所有的类都应当有父类）。
 *  这个类的父类是否继承了不允许被继承的类（被final修饰的类）。
 *  如果这个类不是抽象类，是否实现了其父类或接口之中要求实现的所有方法。
 *  类中的字段、方法是否与父类产生矛盾（例如覆盖了父类的final字段，或者出现不符合规则的方法重载，例如方法参数都一致，但返回值类型却不同等）。

#### 3）字节码验证 ####

第三阶段是整个验证过程中最复杂的一个阶段，主要目的是通过数据流分析和控制流分析，确定 程序语义是合法的、符合逻辑的。这阶段就要 对类的方法体（Class文件中的Code属性）进行校验分析，保证被校验类的方法在运行时不会做出危害 虚拟机安全的行为。

#### 4）符号引用验证 ####

最后一个阶段的校验行为发生在虚拟机将符号引用转化为直接引用\[3\]的时候，这个转化动作将在 连接的第三阶段——解析阶段中发生。符号引用验证可以看作是对类自身以外（常量池中的各种符号 引用）的各类信息进行匹配性校验，通俗来说就是，该类是否缺少或者被禁止访问它依赖的某些外部 类、方法、字段等资源。

### 3.准备（Preparation）阶段 ###

准备阶段是正式为类中定义的变量（即静态变量，被static修饰的变量）分配内存并设置类变量初 始值的阶段，从概念上讲，这些变量所使用的内存都应当在方法区中进行分配，但必须注意到方法区 本身是一个逻辑上的区域，在JDK 7及之前，HotSpot使用永久代来实现方法区时，实现是完全符合这 种逻辑概念的；而在JDK 8及之后，类变量则会随着Class对象一起存放在Java堆中，这时候“类变量在 方法区”就完全是一种对逻辑概念的表述了。

### 4.解析（Resolution）阶段 ###

解析阶段是Java虚拟机将常量池内的符号引用替换为直接引用的过程

在Class文件中它以CONSTANT\_Class\_info、 CONSTANT\_Fieldref\_info、CONSTANT\_Methodref\_info等类型的常量出现。

#### 解析阶段中所说的直接引用与符号引用又有什么关联呢？ ####

*  **符号引用（Symbolic References）：**符号引用以一组符号来描述所引用的目标，符号可以是任何 形式的字面量，只要使用时能无歧义地定位到目标即可。符号引用与虚拟机实现的内存布局无关，引 用的目标并不一定是已经加载到虚拟机内存当中的内容。各种虚拟机实现的内存布局可以各不相同， 但是它们能接受的符号引用必须都是一致的，因为符号引用的字面量形式明确定义在《Java虚拟机规 范》的Class文件格式中。
 *  **直接引用（Direct References）：**直接引用是可以直接指向目标的指针、相对偏移量或者是一个能 间接定位到目标的句柄。直接引用是和虚拟机实现的内存布局直接相关的，同一个符号引用在不同虚 拟机实例上翻译出来的直接引用一般不会相同。如果有了直接引用，那引用的目标必定已经在虚拟机 的内存中存在。

解析动作主要针对类或接口、字段、类方法、接口方法、方法类型、方法句柄和调用点限定符这7 类符号引用进行，分别对应于常量池的CONSTANT\_Class\_info、CON-STANT\_Fieldref\_info、 CONSTANT\_Methodref\_info、CONSTANT\_InterfaceMethodref\_info、 CONSTANT\_MethodType\_info、CONSTANT\_MethodHandle\_info、CONSTANT\_Dyna-mic\_info和 CONSTANT\_InvokeDynamic\_info 8种常量类型\[2\]。下

### 5.初始化（Initialization）阶段 ###

类的初始化阶段是类加载过程的最后一个步骤，之前介绍的几个类加载的动作里，除了在加载阶 段用户应用程序可以通过自定义类加载器的方式局部参与外，其余动作都完全由Java虚拟机来主导控 制。直到初始化阶段，Java虚拟机才真正开始执行类中编写的Java程序代码，将主导权移交给应用程序。

## 类加载器 ##

Java虚拟机设计团队把类加载阶段中的“通过一个类的全限定名来获取描述该类的二进制字节流”这个动作放到Java虚拟机外部去实现，以便让应用程序自己决定如何去获取所需的类。实现这个动作的代码被称为“类加载器”（ClassLoader）。

### 类与类加载器 ###

类加载器虽然只用于实现类的加载动作，但它在Java程序中起到的作用却远超类加载阶段。

对于任意一个类，都必须由加载它的类加载器和这个类本身一起共同确立其在Java虚拟机中的唯一性，每 一个类加载器，都拥有一个独立的类名称空间。

这句话可以表达得更通俗一些：比较两个类是否“相 等”，只有在这两个类是由同一个类加载器加载的前提下才有意义，否则，即使这两个类来源于同一个 Class文件，被同一个Java虚拟机加载，只要加载它们的类加载器不同，那这两个类就必定不相等。

这里所指的“相等”，包括代表类的Class对象的equals()方法、isAssignableFrom()方法、isInstance() 方法的返回结果，也包括了使用instanceof关键字做对象所属关系判定等各种情况。

**在Java虚拟机的角度，只存在两种不同的类加载器：**

一种是**启动类加载器（Bootstrap Class Loader）**：这个类加载器使用C++语言实现，是虚拟机自身的一部分；

一种是**其他所有的类加载器**：这些类加载器都由Java语言实现，独立存在于虚拟机外部，并且全都继承自抽象类java.lang.ClassLoader。

**在java8以及以前的版本都会用到如下三种加载器：**

*  **启动类加载器（Bootstrap Class Loader）**
 *  **扩展类加载器（Extension Class Loader）**
 *  **应用类加载器（Application Class Loader)**

#### **启动类加载器（Bootstrap Class Loader）** ####

这个类加载器负责加载存放在 \\lib目录，或者被-Xbootclasspath参数所指定的路径中存放的，而且是Java虚拟机能够 识别的（按照文件名识别，如rt.jar、tools.jar，名字不符合的类库即使放在lib目录中也不会被加载）类 库加载到虚拟机的内存中。

#### **扩展类加载器（Extension Class Loader）** ####

这个类加载器是在类sun.misc.Launcher$ExtClassLoader 中以Java代码的形式实现的。它负责加载\\lib\\ext目录中，或者被java.ext.dirs系统变量所 指定的路径中所有的类库。

#### **应用类加载器（Application Class Loader)** ####

这个类加载器由 sun.misc.Launcher$AppClassLoader来实现。由于应用程序类加载器是ClassLoader类中的getSystemClassLoader()方法的返回值，所以有些场合中也称它为“系统类加载器”。它负责加载用户类路径 （ClassPath）上所有的类库，开发者同样可以直接在代码中使用这个类加载器。如果应用程序中没有 自定义过自己的类加载器，一般情况下这个就是程序中默认的类加载器。

![99d0095f69c248aa8824d6979d573a97.png][]

JDK 9之前的Java应用都是由这三种类加载器互相配合来完成加载的，如果用户认为有必要，还可 以加入自定义的类加载器来进行拓展，典型的如增加除了磁盘位置之外的Class文件来源，或者通过类 加载器实现类的隔离、重载等功能。

## 双亲委派模型 ##

**双亲委派模型（Parents Delegation Model）：**各种类加载器之间的层次关系被称为类加载器的“双亲委派模型。

双亲委派模型要求除了顶层的启动类加载器外，其余的类加载器都应有自己的父类加载器。这里的类加载器之间的父子关系一般不是以继承（Inheritance）的关系来实现的，而是通常使用组合（Composition）关系来复用父加载器的代码。

### 双亲委派模型工作过程 ###

如果一个类加载器收到了类加载的请求，它首先不会自己在尝试加载这个类，而是把这个请求委派给父类加载器去完成，每一个层次的类加载器都是如此，因此所有的加载请求最终都应该传送到最顶层的启动类加载器中，只有当父加载器反馈自己无法完成这个记载请求（它的搜索范围中没有找到所需的类）时，子加载器才会尝试自己去完成加载。

### 双亲委派模型优点 ###

*  避免类的重复加载，确保一个类的全局唯一性。Class与加载它的类加载器一起具备了一种带有优先级的层次关系，当父级已经加载了该类时，就没有必要子Class Loader再加载一次；
 *  保护程序安全，防止核心API被随意篡改。

### 双亲委派模型（1.8以及之前版本） ###

![5d6943bf402045b99b5fa099394f284b.png][]

### 双亲委派模型（1.9以及之后版本） ###

但是在Java9以及以后的版本中，为了模块化系统的顺利实施，模块下的类加载器主要几个变动：

1.  **扩展类加载器（Extension Class Loader）**被平台类加载器（Platform ClassLoader）取代（java9中整个JDK都是基于了模块化的构建，原来的rt.jar和tools.jar都被拆分了数十个JMOD文件）。因为java类库可以满足扩展的需求并且能随时组合构建出程序运行的jre，所以取消了JAVA\_HOME\\lib\\ext和JAVA\_HOME\\jre目录
2.  **平台类加载器**和**应用程序类加载器**都不在派生自java.net.URLClassLoader。现在启动类加载器、平台类加载器、应用程序类加载器全都继承于jdk.internal.loader.BuiltinClassLoader，在BuiltinClassLoader中实现了新的模块架构下类如何从模块中加载的逻辑，以及模块中资源可访问性的处理。

![15894df6cb3a405a8e8598b3572d44d7.png][]

## 破坏双亲委派模型 ##

到目前为止（JDK8），双亲委派模型有过3次大规模的“被破坏”的情况。

### 第一次破坏 ###

由于双亲委派模型是在JDK1.2之后才被引入的，而类加载器和抽象类 java.lang.ClassLoader 则在JDK1.0时代就已经存在，用户去继承 java.lang.ClassLoader 的唯一目的就是为了**重写 loadClass() 方法**，因为虚拟机在进行类加载的时候会调用加载器的私有方法 loadClassInternal()，而这个方法唯一逻辑就是去调用自己的 loadClass() 。为了兼容这些已有代码，Java设计者引入双亲委派模型时不得不做出一些妥协，在JDK1.2之后的 java.lang.ClassLoader 中添加了一个新的 protected 方法 findClass() ，并引导用户编写类加载逻辑时，尽可能去重写这个方法，而不是在 loadClass() 中编写代码。

### 第二次破坏 ###

双亲委派模型的第二次“被破坏”是**由这个模型自身的缺陷所导致**的，双亲委派很好地解决了**各个类加载器协作时基础类型的一致性问题**（越基础的类由越上层的加载器进行加载），基础类之所以称为“基础”，是因为它们总是作为被用户代码继承，调用的API存在。但是如果基础类又要调用回用户的代码，那该么办？

一个典型的例子就是JNDI服务，JNDI现在已经是Java的标准服务，它的代码由启动类加载器去加载（在JDK1.3时放进去的 rt.jar），但JNDI的目的就是对资源进行集中管理和查找，它需要调用由独立厂商实现并部署在应用程序的 ClassPath 下的JNDI接口提供者的代码，但启动类加载器不可能“认识”这些代码。

为了解决这个问题，Java设计团队只好引入了一个不太优雅的设计：线程上下文类加载器（Thread Context ClassLoader）。这个类加载器可以通过 java.lang.Thread 类的setContextClassLoader() 方法进行设置，如果创建线程时还未设置，他将会从父线程中继承一个，如果在应用程序的全局范围内都没有设置过的话，那这个类加载器默认就是应用程序类加载器。

有了线程上下文加载器，JNDI服务就可以使用它去加载所需要的SPI代码，也就是父类加载器请求子类加载器去完成类加载的动作，这种行为实际上就是打通了双亲委派模型层次结构来逆向使用类加载器，实际上已经违背了双亲委派模型的一般性原则。Java中所有涉及SPI的加载动作基本上都采用这种方式，例如JNDI、JDBC、JCE、JAXB和JBI等。

### **第三次破坏** ###

双亲委派模型的第三次“被破坏”是由于用户对程序动态性的追求导致的，这里所说的“动态性”指的是当前一些非常“热门”的名词：代码热替换、模块热部署等，简单的说就是机器不用重启，只要部署上就能用。

OSGi实现模块化热部署的关键则是它自定义的类加载器机制的实现。每一个程序模块（Bundle）都有一个自己的类加载器，当需要更换一个 Bundle 时，就把 Bundle 连同类加载器一起换掉以实现代码的热替换。在OSGi环境下，类加载器不再是双亲委派模型中的树状结构，而是进一步发展为更加复杂的网状结构，当受到类加载请求时，OSGi将按照下面的顺序进行类搜索：

*  将java.＊开头的类委派给父类加载器加载;
 *  否则，将委派列表名单内的类委派给父类加载器加载；
 *  否则，将 Import 列表中的类委派给 Export 这个类的 Bundle 的类加载器加载；
 *  否则，查找当前 Bundle 的 ClassPath，使用自己的类加载器加载；
 *  否则，查找类是否在自己的 Fragment Bundle 中，如果在，则委派给 Fragment Bundle 的类加载器加载；
 *  否则，查找 Dynamic Import 列表的 Bundle，委派给对应 Bundle 的类加载器加载；
 *  否则，类加载器失败。

## 如何破坏双亲委派模型？ ##

*  使用SPI机制；
 *  自定义类继承 ClassLoader，作为自定义类加载器，重写 loadClass() 方法，不让它执行双亲委派逻辑，从而打破双亲委派。但是遇到自定义类加载器和核心类重名或者篡改核心类内容，jvm会使用沙箱安全机制，保护核心类，防止打破双亲委派机制，防篡改，如果重名的话就报异常。

> **小知识：**
> 
> SPI：是一种服务发现机制。它通过在ClassPath路径下的META-INF/services文件夹查找文件，自动加载文件里所定义的类。这一机制为很多框架扩展提供了可能，比如在JDBC中就使用了到了SPI机制。

**作者：筱白爱学习！！**

**欢迎关注转发评论点赞沟通，您的支持是筱白的动力！**

[18efacda1c8842bca5572fc16a847522.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/d487fe27885641338006c68f7c1bab1b.png
[99d0095f69c248aa8824d6979d573a97.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/2192b8f383654928af6b80fd6630f7a2.png
[5d6943bf402045b99b5fa099394f284b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/9b7869ec33e749c08a806845eff19ef5.png
[15894df6cb3a405a8e8598b3572d44d7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/3fa38e35863a463b8a29482a5472d146.png