深入理解JVM（六）：虚拟机类加载机制

快来打我* 2022-05-14 16:07 312阅读 0赞

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

在Java中，类型的加载、连接和初始化过程都是程序在运行期间完成的，这种策略虽然会令类加载时稍微增加一些性能开销，但是会为Java应用程序提供高度的灵活性。Java里天生的动态扩展语言特性就是依赖运行期动态加载和动态连接这个特点实现的。

我们可以看看下面的思维导图后，再对相关的知识进行一一介绍。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2pkZms0MjM_size_16_color_FFFFFF_t_70]

## 1. 类加载的时机 ##

从类被加载到虚拟机内存中开始，到卸载出内存为止，它的整个生命周期包括：加载、验证、准备、解析、初始化、使用和卸载7个阶段。其中验证、准备、解析3个部分统称为连接。这7个阶段发生的顺序如图所示。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2pkZms0MjM_size_27_color_FFFFFF_t_70]

**加载、验证、准备、初始化和卸载这个5阶段的顺序是确定**，类的加载过程必须按照这种顺序按部就班地开始。而解析阶段则不一定:它在某些情况下可以在初始化阶段之后开始，这是为了支持Java语言运行时绑定（也称为动态绑定或者晚期绑定）。

注意：**这里是写的是按部就班的开始，而不是按部就班的“进行或者完成”，强调这点是因为这些阶段都是交叉地混合式进行的，通常会在一个阶段执行的过程中调用、激活另外一个阶段。**

#### 1.1 必须对类进行“初始化”的5种情况 ####

什么情况下开始类加载中的加载过程，虚拟机并没有进行强制约束，这点可以交给虚拟机的具体实现来自由把握， 但是对于初始化阶段，虚拟机规范则是严格规定了有且只有5种情况必须对类进行“初始化”(而加载、验证、准备自然需要在此之前开始)。

(1)使用new 关键字实例化对象的时候(对应的字节码指令是new)、读取或设置一个类的静态字段（被final修饰、已在编译期把结果放入常量池的静态字段除外）的时候，以及调用一个类的静态方法的时候。

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

(3)当初始化一个类的时候，如果其父类还没有初始化，则需要先触发其父类的初始化。

(4)当虚拟机启动时，用户需要制定一个要执行的主类，虚拟机会先初始化这个主类。

(5)当使用JDK1.7的动态语言支持的一些情况。

这5种场景中的行为称之为对一个类进行主动引用。除此之外，所有的引用类的方式都不会触发初始化，称为被动引用。下面是三个被动引用的例子：

(1)通过子类引用父类的静态字段，不会导致子类初始化。

(2)通过数组定义引用类(创建数组的指令不是new)，不会触发此类的初始化。

(3)常量(变量加上final修饰)在编译阶段会存入调用类的常量池中，本质上并没有直接引用定义常量的类，因此不会触发定义常量的类的初始化。

接口的加载过程与类加载的过程稍有一些不同，接口也有初始化过程，这点与类是一致的，上面的代码都是用静态语句块"static\{\}"来输出初始化信息的，而接口中不能使用“static\{\}”语句块，但编译器仍然会为接口生成“<clinit()>”类构造器，用于初始化接口中所定义的成员变量。接口与类真正有所区别的是前面讲述的5种"有且仅有"需要开始初始化场景中的第3种：当一个类再初始化时，要求其父类全部都已经初始化过了，但是一个接口在初始化的时候，并不要求其父接口全部完成了初始化，只有在真正使用到父接口的时候才会初始化。

## 2. 类加载的过程 ##

接下来我们详细讲解一下Java虚拟机中类加载的全过程，也就是“加载、验证、准备、解析和初始化”这个5阶段。

#### 2.1 加载 ####

在加载阶段需要完成的三件事：  
（1） 通过一个类的全限定名来获取定义此类的二进制字节流

（2）将这个字节流代表的静态存储结构转化为方法区的运行时数据结构。

（3）在内存中生成一个代表这个类的java.lang.Class对象，作为方法区这个类的各种数据的访问入口。

#### 2.1 验证 ####

验证是连接的第一步，这一阶段的目的是确保Class文件的字节流中包含的信息符合当前虚拟机的要求，并且不会危害虚拟机自身的安全。

整体上看，验证阶段会分四个部分：文件格式验证、元数据验证、字节码验证、符号引用验证。

**1.文件格式验证**

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

**2.元数据验证**

对字节码描述的信息进行语义分析，以保证其描述的信息符合Java语言规范的要求。主要的目的是对类的元数据信息进行语义校验，保证不存在不符合Java语言规范的元数据信息。

**3.字节码验证**

通过数据流和控制流分析，确定程序语义是合法的、符合逻辑的。

**4.符号引用验证**

最后一个阶段的校验发生在虚拟机符号引用转化为直接引用的时候，这个转化动作将在连接的第三阶段解析阶段中发生。符号引用验证可以看作是对类自身以外的信息进行匹配性校验。

目的是确保解析动作能够正常执行。

## 3. 准备 ##

准备阶段是正式为类**变量**分配内存并设置类变量的初始值，这些变量所使用的内存都将在方法区中分配。

## 4.解析 ##

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

**解析发生的时机：**  
要求在执行anewarray、checkcast、getfield、getstatic、instanceof、invokedynamic、invokeinterface、invokespecial、invokestatic、invokevirtual、ldc、ldc\_w、multianewarray、new、putfield和putstatic这16个用于操作符号引用的字节码指令之前，先对它们使用的符号进行解析。

**符号引用和直接引用**

符号引用则属于编译原理方面的概念。包括下面三类常量：类和接口的全限定名、字段的名称和描述符、方法的名称和描述符。  
字段和方法的名称就是变量名。

直接引用：直接指向目标的指针、相对偏移量或者是一个能间接定位到目标的句柄。

#### 4.1 对结果进行缓存 ####

对同一个符号引用进行多次解析请求是很常见的事情，除了invokedynamic指令以外，虚拟机实现可以对第一次解析的结果进行缓存从而避免解析动作重复进行。

虚拟机需要保证的是在同一个实体中，如果一个符号引用之前被成功解析过了，那么后续的引用解析请求就应当一直成功；同样的，如果第一次解析失败了，那么其他的指令对这个符号的解析请求也应该收到相同的异常。

invokedynamic指令的目的用于动态语言支持，这里“动态”的含义就是必须等到程序实际运行到这条指令的时候，解析动作才能进行。其他可触发解析动作的指令都是“静态”的，可以在刚刚完成加载阶段，还没有开始执行的代码时就进行解析。

#### 4.2 解析的动作 ####

解析动作主要针对类或接口、字段、类方法、接口方法、方法类型、方法句柄和调用点限定符7类符号引用。（后三种是与jdk1.7新增的动态语言支持息息相关，放在后面的博客一起讲解）

**1.类或接口的解析**：

假设当前代码所处的类是D，如果要把一个从未解析过的符号引用N解析为一个类或者接口C的直接引用，那么虚拟机完成整个解析过程需要下面三个步骤：

（1）如果C不是一个数组类型，那么虚拟机将会把代表N的全限定名传递给D的类加载器加载这个类C。在加载的过程中，由于元数据验证、字节码验证的需要，又可能触发其他的相关类的加载动作，如果加载这个类的父类或实现的接口。一旦这个加载过程出现了任何异常，解析过程就宣告失败。

（2）如果C是一个数组类型，并且数组的元素类型为对象，也就是N的描述符会是类似“\[Ljava/lang/Integer”的形式，那将会按照第一点的规则加载数据元素类型。如果N的描述符如前面所假设的形式，需要加载的元素的类型就是“java.lang.Integer”，接着由虚拟机生成一个代表此数组维度和元素的数组对象。

（3）如果上面的步骤没有出现任何异常，那么C在虚拟机中实际上已经成为一个有效的类或接口了，但是在解析完成之前还要进行符号引用验证，确认D是否具备对C的访问权限，如果发现不具备访问权限，将抛出java.lang.IllegalAccessError异常。

**2.字段解析**

要解析一个未被解析过的字段符号引用，首先会对字段所属的类或者接口的符号引用进行解析。（就是1中描述的情况）如果在解析这个类或接口符号引用的过程中出现了任何异常，都会导致字段符号引用解析的失败。如果解析成功，那么接下来的过程如下（将字段所属【不是它的类型】的类或者接口用C来表示）：

（1）如果C本身包含了简单名称和字段描述符都与目标匹配的字段，则返回这个字段的直接引用，查找结束。

（2）否则，如果在C中实现了接口，将会按照继承关系从下往上递归搜索各个接口和它的父接口，如果接口中包含了简单名称和字段描述符都与目标相匹配的字段，则返回这个字段的直接引用，查找结束。

（3）否则，如果C不是java.lang.Object的话，将会按照继承关系从下往上递归搜索其父类，如果父类中包含了简单名称和字段描述都与目标相匹配的字段，则返回这个字段的直接引用。

（4）否则查找失败，抛出java.lang.NoSuchFieldError异常。

如果查找过程成功返回了引用，将对这个字段进行权限验证，如果发现不具备对字段的访问权限，将抛出java.lang,IllegalAccessError异常。

**3.类方法解析**

类解析的方法与字段解析的一样，也需要先解析出类方法表的class\_index项中索引的方法所属的类或者接口的符号引用。如果查找成功返回了直接引用，将会对这个方法进行权限验证，如果发现不具备对此方法的权限访问，则报错。

**4.接口方法解析**

接口方法也需要先解析出接口方法表的class\_index项中的索引方法所属的类或者接口的符号引用。由于接口中所有的方法默认都是public，所以不存在访问权限的问题，因此接口方法的符号解析不会抛出java.lang.IllegalAccessError异常。

#### 4.5 初始化 ####

类初始化阶段是类加载过程的最后一步，前面的类加载的中，除了加载阶段用户应用程序可以通过自定义加载器参与之外，其余动作完全由虚拟机主导和控制。到了初始化阶段，才真正开始执行类中定义的java代码（或者说是字节码）。

在准备阶段，变量已经赋过一次系统要求的初始值，而在初始化阶段，则根据程序员通过程序制定的主观计划去初始化类变量和其他资源，或者可以从另外一个角度来表达：**初始化阶段是执行类构造器()方法的过程。**

*  <clinit>()方法是由编译器自动收集类中所有类变量的赋值动作和静态语句块（static\{\}块）中的语句合并产生的。编译器收集的顺序是由语句在源文件中出现的顺序所决定的，静态语句块中只能访问到定义在静态语句块之前的变量，在前面的静态语句块可以赋值，但是不能访问。
 *  <clinit>()方法与类的构造函数不同，它不需要显示的调用父类构造器，虚拟机会保证子类的<clinit>()方法执行之前，父类的<clinit>()的方法的类肯定是object类。
 *  由于父类的<clinit>()方法先执行，也意味着父类中定义的静态语句块要优于子类的赋值操作。
 *  如果一类中没有静态语句块也没有对变量的赋值操作，那么编译器可以不为这个类生成<clinit>()方法
 *  接口中不能使用静态语句块，但仍然有变量初始化的赋值操作，因此接口和类一样都会生成<clinit>方法。但接口与类不同的是，执行接口的<clinit>()方法不需要先执行父接口的<clinit>()方法。只有父接口中定义的变量使用时，父接口才会初始化。
 *  虚拟机会保证一个类的<clinit>()方法在多线程环境中被正确的加锁、同步，如果多个线程同时初始化一个类，那么只会有一个线程去执行这个类的<clinit>方法。

**关于上面重要几点的总结**：

> **1.通过数组定义引用类，不会触发类的初始化。但是在数组类加载的时候，将触发组件类型的加载。数组将在加载该组件类型的类加载器的类名称上被表示。**  
> **2. 一个类在初始化的时候，要求其父类全部得初始化，但是一个接口在初始化时，并不要求父接口完成了初始化，只有在真正使用到父接口中定义的变量才会初始化。**  
> **3.非数组类型在加载阶段既可以用系统的引导器还可以使用自定义的引导器，而数组类本身由虚拟机创建。**

## 5. 类加载器 ##

前面的类加载过程中，除了在加载阶段用户应用程序可以通过自定义类加载器参与之外，其余的动作完全由虚拟机主导和控制。

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

#### 5.1 类和类加载器 ####

对于任意一个类，都需要由加载它的类加载器和这个类本身一同确立其在Java虚拟机中的唯一性。比较两个类是否“相等”，只有在这个两个类是由同一个类加载的前提下才有意义，否则 ，即使这两个类来源于同一个Class文件，被同一个虚拟机加载，只要加载它们的类加载器不同，那么这两个类就必定不相等。

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

#### 5.2 双亲委派模型 ####

**类加载器的分类：**

从开发人员的角度来看，类加载器还可以划分的更加细致一些，绝大部分Java程序都会使用到下面3种系统提供的类加载器。

*  **启动类加载器(Bootstrap ClassLoader)：用于加载<JAVA\_HOME>\\lib目录中的类库。**（启动类加载器无法被Java程序直接引用，用户在编写自定义类加载器时，如果需要把加载请求委派给引导类加载器，可以使用null直接代替。）
 *  **扩展类加载器(Extension ClassLoader)：负责加载<JAVA\_HOME>\\lib\\ext目录中的所有类库。**（开发者可以直接使用扩展类库）
 *  **应用程序类加载器(Application ClassLoader)：这个类加载器负责加载用户类路径上指定的类库。**（开发者可以直接使用这个类加载器，如果应用程序中没有自定义过自己的类加载器，那么程序默认的就是这个类加载器）

如果有必要，还可以加入自己定义的类加载器。

**双亲委派模型：**

类加载器之间的关系如图所示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2pkZms0MjM_size_16_color_FFFFFF_t_70 1]

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

双亲委派模型的工作过程：

> **如果一个类加载器收到了类加载的请求，它首先不会自己去尝试加载这个类，而是把这个请求委派给父类加载器去完成，每一层的类加载器都是如此，因此所有的加载请求最终都应该传送到启动类加载器，只有当父加载器反馈自己无法完成这个加载请求是，子类才会尝试自己去加载。**

双亲委派模型的好处：

**使用双亲委派模型来组织类加载器之间的关系，有一个显而易见的好处就是java类随着它的类加载器一起具备了一种带有优先级的层次关系**。越基础的类由越上层的加载器进行加载。

例如java.lang.Object，它存放在rt.jar之中，无论哪一个类加载这个类，最终都是委派给了模型最顶端的启动类加载器进行加载，因此Object类在程序的各个类加载器环境中都是同一个类。相反如果没有采用双亲委派模型的话，那么系统中可能会出现多个不同的Object类。

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

**第一次“被破坏”:**

**原因**：发生在双亲委派模型出现之前，即JDK1.2发布之前。类加载器和抽象类java.lang.ClassLoader在JDK1.0就存在了。

**解决**:在JDK1.2之后的java.lang.ClassLoader添加了一个新的protected方法findClass()。在此之前，用户去继承java.lang.ClassLoader的唯一目的就是重写loadClass()方法，因为虚拟机在进行类加载时会调用加载器的私有方法loadClassInternal()，而这个方法的唯一逻辑就是调用自己的loadClass()。 JDK1.2之后引导将自己的类加载逻辑写到findClass()方法中覆盖父类的方法，ClassLoader类将双亲委派的逻辑写到了loadClass中，在loadClass方法的逻辑里如果父类加载失败，则会调用自己的finaClass()方法中，这样就可以保证新写出来的类加载器是符合双亲委派的。

**第二次“被破坏”:**

**原因**：由于模型本身的缺陷，导致启动类加载器没有办法加载用户的代码。

Java 提供了很多服务提供者接口（Service Provider Interface，SPI），允许第三方为这些接口提供实现。常见的 SPI 有 JDBC、JCE、JNDI、JAXP 和 JBI 等。  
这些 SPI 的接口由 Java 核心库来提供，而这些 SPI 的实现代码则是作为 Java 应用所依赖的 jar 包被包含进类路径（CLASSPATH）里。SPI接口中的代码经常需要加载具体的实现类。(**加载实现类的时候，会使用当前的类加载器进行加载**)。那么问题来了，SPI的接口是Java核心库的一部分，是由启动类加载器(Bootstrap Classloader)来加载的；SPI的实现类是由系统类加载器(System ClassLoader)来加载的。引导类加载器是无法找到 SPI 的实现类的，因为依照双亲委派模型，BootstrapClassloader无法委派AppClassLoader来加载类。

**解决**:引入了线程上下文类加载器，这个类加载器可以通过java.lang.Thread类的setContextClassLoader()方法进行设置，如果创建线程时，还没有设置，它将会从父线程中继承一个，如果应用程序的全局范围都没有设置过的话，那么这个类加载器默认就是应用程序类加载器。使用线程上下文类加载器，可以在执行线程中抛弃双亲委派加载链模式。**如果直接使用应用程序类加载器还是会按照双亲委派模型进行执行，但是使用线程上下文类加载器就不会按照双亲委派加载链模式执行。**

**拿JNDI为例，它的核心是由JRE核心类(rt.jar)实现的，要由启动类加载器去加载。但这些核心JNDI类必须能加载由第三方厂商提供的JNDI实现，但是这个不能用启动类加载器去加载。解决办法就是让核心JNDI类使用线程上下文类加载器，从而有效的打通类加载器层次结构，逆着代理机制的方向使用类加载器。**

详细：[https://www.cnblogs.com/mengchunchen/p/7845173.html][https_www.cnblogs.com_mengchunchen_p_7845173.html]

**第三次“被破坏”**

由于用户对程序动态性的追求导致的，如：代码热替换（HotSwap）、模块热部署（Hot Deployment）等。

在OSGi环境下，类加载器不再是双亲委派模型中 的树状结构，而是进一步发展为更加复杂的网状结构。

（待补充)

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2pkZms0MjM_size_16_color_FFFFFF_t_70]: /images/20220503/24046425b8ee454bb764ca0932498caf.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2pkZms0MjM_size_27_color_FFFFFF_t_70]: /images/20220503/b01772c3eab444ae9ae3c77445494529.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2pkZms0MjM_size_16_color_FFFFFF_t_70 1]: /images/20220503/9397497aa4054660b874205f11e28f1b.png
[https_www.cnblogs.com_mengchunchen_p_7845173.html]: https://www.cnblogs.com/mengchunchen/p/7845173.html