JVM高级特性与实践（八）：虚拟机的类加载机制

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

与那些在编译时需要进行连接工作的语言不同，在Java语言里，类型的加载、连接和初始化过程都是在程序运行期间完成的，此策略虽会令类加载时稍增加性能开销，但为Java程序提供高度的灵活性，Java里天生可以动态扩展的语言特性就是依赖运行期动态加载和动态连接这个特点实现的。

在前面几篇博文中了解了Class文件存储格式的具体内容，及描述的各种信息，最终都需要加载到虚拟机中之后才能运行和使用。而虚拟机是如何加载这些Class文件？Class文件中的信息进入到虚拟机后会发生什么变化？

此博文将来解答以上问题，大致知识点如下：

• 类加载机制概念
• 触发类初始化的场景
• 类的生命周期
• 加载、验证、准备、解析和初始化五大阶段的作用、工作任务、原理

JVM高级特性与实践（一）：Java内存区域 与 内存溢出异常 
JVM高级特性与实践（二）：对象存活判定算法（引用） 与 回收 
JVM高级特性与实践（三）：垃圾收集算法 与 垃圾收集器实现 
JVM高级特性与实践（四）：内存分配 与 回收策略 
JVM高级特性与实践（五）：实例探究Class类文件 及 常量池 
JVM高级特性与实践（六）：Class类文件的结构（访问标志，索引、字段表、方法表、属性表集合） 
JVM高级特性与实践（七）：九大类字节码指令集（实例探究 ）

一. 类加载的时机

为避免语言表达产生的误差，先声明两点：

• 在实际情况中，每个Class文件都有可能代表着Java语言中的一个类或接口，后文中直接对“类”的描述都包含了类和接口的可能性，而对于类和接口需要分开描述的场景会特别指明。

• 下面所提到的“Class文件”并非特指某个存在于具体磁盘中的文件，应当是一串二进制的字节流，无论以何种形式存在都可以。

1. 类加载阶段

类从被加载到虚拟机内存中开始，到卸载出内存为止，它的整个生命周期包括：

• 加载（Loading）
• 验证（Verification）
• 准备（Preparation）
• 解析（Resolution）
• 初始化（Initialzation）
• 使用（Using）
• 卸载（Unloading）

其中验证、准备、解析3个部分统称为连接（Linking），这7个阶段的发生顺序如下图所示：

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

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

---

2. 触发类初始化的场景

Java虚拟机中并无强制约束何时开始类加载过程，由虚拟机的具体实现来自由把握。但是对于初始化阶段，虚拟机规范严格规定了有且只有5种情况必须立即对类进行“初始化”（而加载、验证、准备自然需要在此之前开始）：

• 遇到new， getstatic， putstatic, 或 invokestatic 这4条字节码指令时，如果类没有进行过初始化，则需要先触发其初始化。生成这4条指令的最常见的java代码场景是：使用new关键字实例化对象的时候，读取或设置一个类的静态字段（被final修饰、已在编译器把结果放入常量池的静态字段除外）的时候，以及调用一个类的静态方法的时候；

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

• 当初始化一个类的时候，如果发现其父类还没有进行过初始化，则需要先触发其父类的初始化；

• 当虚拟机启动时，用户需要制定一个要执行的主类（包含main方法的那个类），虚拟机会先初始化这个主类；

• 当使用jdk1.7 的动态语言支持时，如果一个 java.lang.invoke.MethodHandle 实例最后的解析结果 REF_getStatic, REF_putStatic, REF_invokeStatic 的方法句柄，并且这个方法句柄所对应的类没有进行过初始化，则需要先触发其初始化；

---

3. 被动引用

（1）概念

• 主动运用：对于以上5种触发类进行初始化的场景，上文的描述中使用了一个强烈的限定语“有且仅有”，这些场景的行为称为对一个类进行主动运用。

• 被动引用：所有引用类的方法都不会触发初始化

（2）实例一证明

这一小点中来详细了解被动引用，以下通过3个例子来说明：

【被动引用的例子 之一】

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);
    }

}
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

结果输出：

SuperClass init!
 
 
1
 
 
1

分析：

上述代码运行后，输出结果并非是SubClass init!。对于静态字段，只有直接定义这个字段的类才会初始化，因此通过其子类来引用父类中定义的静态字段，只会触发父类的初始化而并非子类的初始化。

（3）实例二证明

【被动引用的例子 之二】

package org.fenixsoft.classloading;

/**
 * 被动使用类字段演示二：
 * 通过数组定义来引用类，不会触发此类的初始化
 **/
public class NotInitialization {

    //......SuperClass类的定义同上（节省版面，不再重复贴出）

    public static void main(String[] args) {
        SuperClass[] sca = new SuperClass[10];
    }

}
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

分析

运行之后发现并没有输出理想结果：SuperClass init!，说明没有触发类 org.fenixsoft.classloading.SuperClass的初始化阶段，但是触发到了另一个名为“[Lorg.fenixsoft.classloading.SuperClass”的类初始化阶段，对于用户而言，这不是一个合法的类名称，它是一个由虚拟机自动生成的、直接继承于 java.lang.Object 的子类，创建动作由字节码指令newarray触发。

这个类代表了一个元素类型为org.fenixsoft.classloading.SuperClass的一维数组，数组中应有的属性和方法都实现在此类中。Java语言中对数组的访问比C/C++相对安全是因为这个类封装了数组元素的访问方法，而C/C++直接翻译为对数组指针的移动。

（4）实例三证明

【被动引用的例子 之三】

package org.fenixsoft.classloading;

/**
 * 被动使用类字段演示三：
 * 常量在编译阶段会存入调用类的常量池中，本质上没有直接引用到定义常量的类，因此不会触发定义常量的类的初始化。
 **/
public class ConstClass {

    static {
        System.out.println("ConstClass init!");
    }

    public static final String HELLOWORLD = "hello world";
}

/**
 * 非主动使用类字段演示
 **/
public class NotInitialization {

    public static void main(String[] args) {
        System.out.println(ConstClass.HELLOWORLD);
    }
}
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

分析

上述代码运行之后，也没有输出ConstClass init! ，因为虽然Java源码中引用了 ConstClass类中的常量HELLOWORLD，但其实在编译阶段通过常量传播化，已经将该常量值“hello world”存储到NotInitialization 类的常量池中，以后NotInitialization 对常量ConstClass.HELLOWORLD 的引用实际转化为NotInitialization 类对自身常量池的引用。

也就是说，实际上NotInitialization 的Class文件之中并没有ConstClass类的符号引用入口，这两个类在编译成Class文件时已无任何联系。

---

4. 接口加载与类加载

（1）接口的初始化过程

接口也有初始化过程，类中用静态语句块staitc 来输出初始化信息的，而接口中不能使用“static”语句块，但编译器仍然会为接口生成 “()” 类构造器，用于初始化接口中定义的成员变量。

（2）区别

• 当一个类在初始化时：要求其父类全部都已经初始化过了。
• 在一个接口初始化时：并不要求其父接口全部不完成初始化，只有在真正使用到父接口的时候才会初始化。

---

---

---

---

二. 类加载过程

接下来详细讲解Java虚拟机中类加载的全过程，即 加载、验证、准备、解析和初始化这5个阶段所执行的具体动作。

1. 加载

（1）开始时机

Java虚拟机中并无强制约束何时开始类加载过程，由虚拟机的具体实现来自由把握。但是对于初始化阶段，虚拟机规范严格规定了有且只有5种情况必须立即对类进行“初始化”。（5种情况在上一点有详细讲解，在此不赘述）

（2）工作任务

注意，“加载”是“类加载”（Class Loading）过程的一个阶段，切勿混淆。在加载阶段，虚拟机要完成以下3件事情：

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

以上这3点要求并不算具体，因此虚拟机实现与具体应用的灵活度都是相当大。例如，第一条要求中并无指明二进制流要从从一个Class文件中获取，准确的说是没有指明从哪里获取及如何获取。

（3）非数组类的加载阶段

相对于类加载的其它过程，一个非数组类的加载阶段（准确来说是加载阶段中获取类的二进制字节流的动作）是开发人员可控性最强的，因此该阶段可以使用系统提供的引导类加载器完成，也可以由用户自定义的类加载器完成，通过自定义类加载器去控制字节流的获取方式，即重写一个类加载器的loadClass 方法。

（4）数组类的加载阶段

对于数组类而言，情况有所不同，因为数组本身不通过类加载器，它是由虚拟机直接创建的。但它仍与类加载器有很大联系，数组类的元素类型（ElementType，指的是数组去掉所有维度的类型）最终是由类加载器创建，一个数组类创建过程需遵循以下规则：

• 如果数组的组件类型（ComponentType，指的是数组去掉一个维度的类型）是引用类型，就递归采用本节中定义的加载过程去加载此组件类型，数组类将在加载该组件类型的类加载器的类名称空间上被标识。
• 如果数组的组件类型不是引用类型（例如int[]数组），Java虚拟机将会把数组类标记为与引导类加载器关联。
• 数组类的可见性与它的组件类型的可见性一致，如果组件类型不是引用类型，那数组类的可见性将默认为public。

（5）加载阶段完成后

加载阶段完成后，虚拟机外部的二进制字节流就按照虚拟机所需的格式存储在方法区之中，方法区的数据存储格式由虚拟机实现自行定义，虚拟机规范未规定此区域的具体数据结构。然后在内存实例化一个 java.lang.Class类的对象（并无明确规定是在Java 堆中，对于HotSpot虚拟机而言，Class对象比较特殊，它虽是对象，但存放在方法区里），这个对象将作为程序访问方法区中的这些类型数据的外部接口。

---

---

2. 验证

（1）开始时机

加载阶段 与 连接阶段 的部分内容（如一部分字节码文件格式验证动作）是交叉进行的。加载阶段尚未完成，连接阶段可能已经开始，但这些加载加载阶段之中进行的动作，仍然属于连接阶段的内容，这两个阶段的开始时间仍然保持着固定的先后顺序。

（2）作用

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

Java语言本身是相对安全的语言（相对于C/C++），使用纯粹的Java代码无法做到诸如访问数组边界之外的数据、将一个对象转型为它未实现的数据类型、跳转到不存在的代码行等，如果这样做了，编译器将拒绝编译，但是Class文件不一定由Java源码编译而来，完全可以使用任何途径，如：用十六进制编辑器直接编写来产生Class文件，在字节码层面上，上述Java代码无法做到的事情都是可以实现的，此时虚拟机如果不检查输入的字节流，很有可能因为载入了有害的字节流而导致系统崩溃，所以验证时虚拟机对自身保护的一项重要工作。

验证阶段非常重要，直接决定了虚拟机是否能承受恶意代码的攻击，从执行性能的角度来讲，该阶段的工作量在虚拟机的类加载子系统中占有了相当大一部分。

（3）工作任务

虚拟机规范对该阶段的规定非常笼统，仅要求如果验证到输入的字节流不符合Class文件的存储格式，就抛出一个java.lang.VerifyError异常（JDK1.6的API文档对该异常类的描述为：当“校验器”检测到一个类文件虽然格式正确，但包含着一些内部不一致问题或安全性问题时，抛出该错误）或其子类异常，具体检查哪些方面、如何检查、何时检查，都未做强制要求或明确说明，故不同的虚拟机对验证的实现有所不同，但大致都会完成如下4个阶段的检查过程：

a. 文件格式验证

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

• 是否以魔数0xCAFEBABE开头
• 主次版本号是否在当前虚拟机的处理范围之内
• 常量池的常量中是否有不被支持的常量类型（tag标志）
• ……

该阶段的主要目的是保证输入的字节流能被正确的解析并存储于方法区内，格式上符合描述一个Java类型信息的要求。

该阶段的验证是基于字节流的，经过这个阶段的验证后，字节流才会进入内存的方法区中进行存储，故后面的三个验证阶段是基于方法区的存储结构进行的。

b. 元数据验证

第二阶段：对字节码描述的信息（即类的元数据信息）进行语义分析，以保证其描述的信息符合Java语言规范的要求。例如以下验证：

• 该类是否有父类（除了 java.lang.Object之外，所有的类都应有父类）
• 该类的父类是否继承了不允许被继承的类（final修饰的类）
• 若此类不是抽象类，是否实现了其父类或接口之中要求实现的所有方法
• ……

该阶段的主要目的是对类的元数据信息进行语义检验，保证不存在不符合Java语言规范的元数据信息。

c. 字节码验证

第三阶段：进行数据流和控制流分析，即对类的方法体进行校验分析以保证被校验类的方法在运行时不会做出危害虚拟机安全的行为。例如以下验证：

• 保证任意时刻操作数栈的数据类型与指令代码序列都能配合工作
• 保证跳转指令不会跳转到方法体以外的字节码指令上
• 保证方法体中类型转换是有效的
• ……

该阶段是整个验证阶段最复杂的，主要目的是通过数据流和控制流分析，确定程序语义是否合法、符合逻辑的。

如果一个类方法体的字节码没有通过字节码验证，那肯定有问题，即使通过了也不代表是安全的。通过程序去校验程序逻辑是无法做到绝对精确的—— 不能通过程序准确检查出程序是否能在有限时间内结束运行。

d. 符号引用验证

第四阶段：验证发生在虚拟机将符号引用转化为直接引用时，这个转化动作将在连接的第三阶段 —— 解析阶段发生。符号引用验证可以看作是对类自身以外（常量池中各种符号引用）的信息进行匹配性校验。例如以下验证：

• 符号引用中通过字符串描述的全限定名是否能找到对应的类
• 指定的类中是否存在符合描述符与简单名称描述的方法与字段
• 符号引用中的类、字段、方法的访问性（private、protected、public、default）是否可被当前类访问
• ……

符号引用验证的目的是确保解析动作能够正常执行，如果无法通过符号引用验证，那么将会抛出一个java.lang.IncompatibleClassChangeError异常的子类，如下图所示：

（4）验证阶段小结

对于虚拟机的类加载机制来说，验证阶段是一个非常重要、但不一定必要（因为对程序运行期无影响）的阶段。如果所运行的全部代码（包括自己编写的和第三方包中代码）都已被反复使用和验证过，那么在验证阶段可考虑使用-Xverify:none 参数来关闭大部分的类验证措施，以缩短虚拟机类加载时间。

---

---

3. 准备

（1）工作任务

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

（2）易混淆点

此阶段有2个容易混淆的部分需要特别强调：

• 该阶段进行内存分配的仅包括类变量（被static修饰的变量），不包括实例变量，实例变量将在对象初始化时随对象一起分配在堆内存中

• 这里所说的初始值“通常情况下”是指数据类型的零值，如一个类变量定义为：public static int value =123;，变量value 在准备阶段之后的值为0而不是123。因为此时尚未开始执行任何Java方法，而把value 赋值为123的 putstatic指令是程序被编译后，存放在类构造器<clinit>()方法中，所以把赋值动作放到初始化阶段运行。

（3）基本数据类型的零值

下面列举出了Java中所有基本数据类型的零值：

（4）初始化的“特殊情况”

上面提到，在“通常情况”下初始值是零值，那相对的会有一些“特殊情况”：如果类字段的字段属性表中包含ConstantValue属性，那在准备阶段变量就会被初始化为ConstantValue属性所指定的值。

如果上面 value 变量定义变为public final static int value = 123;，编译时javac会为value 生成ConstantValue属性，准备阶段虚拟机就会根据ConstantValue的设置将a的值置为123。

---

---

4. 解析

（1）开始时机

虚拟机规范并未规定解析动作发生的具体时间，仅要求在执行anewarray、checkcast、getfield、getstatic、instanceof、invokeinterface、invokespecial、invokestatic、invokevirtual、multianewarray、new、putfield和putstatic这13个用于操作符号引用的字节码指令之前，先对它们所使用的符号引用进行解析。

（2）符号引用和直接引用

解析阶段是虚拟机将常量池中的符号引用替换为直接引用的过程。符号引用在Class文件中以 CONSTANT_Class_info、CONSTANT_Fieldref_info、CONSTANT_Methodref_info等类型的常量出现，在解析阶段符号引用和直接引用的关联如下：

• 符号引用 （Symbolic References）：符号引用以一组符号来描述所引用的目标，符号可以是任何形式的字面量，只要使用时能无歧义地定位到目标即可。

符号引用与虚拟机实现的内存布局无关，引用的目标并不一定已经加载到内存中。各种虚拟机实现的内存布局可以各不相同，但是它们能接受的符号引用必须一致，因为符号引用的字面量形式明确定义在Java虚拟机规范的Class文件格式中。

• 直接引用（Direct Refenrences）：直接引用可以是直接目标的指针、相对偏移量或是一个能间接定位到目标的句柄。

直接引用是和虚拟机实现的内存布局有关的，同一个符号引用在不同虚拟机实例上翻译出来的直接引用一般不会相同。如果有了直接引用，那么引用的目标必定已经在内存中存在。

（3）工作任务

对同一个符号引用进行多次解析请求是很常见的，虚拟机实现可能会对第一次解析的结果进行缓存（将直接引用保存在运行时常量池中），无论是否真正执行了多次解析动作，虚拟机实现必须保证在同一个实体中，如果一个符号引用之前已经被成功解析过，后续的引用解析请求就应当一直成功，反之亦然。

解析动作主要针对类或接口、字段、类方法、接口方法、方法类型、方法句柄和调用点限定符 7 类符号引用进行，分别对应于常量池中CONSTANT_Class_info、CONSTANT_Fieldref_info、CONSTAN_Methodref_info、CONSTANT_InterfaceMethodref_info、CONSTANT_MethodType_info、CONSTANT_MethodHandle_info、CONSTANT_InvokeDynamic_info 7 种类型常量。

下面介绍前4种引用的解析过程（由于后三种与新增动态语言支持有关，留后后续介绍）：

a. 类或接口的解析

假设当前代码所处的类为D，如果要把一个从未解析过的符号引用N解析为一个类或接口C的直接引用，那虚拟机完成整个解析需以下3个步骤（依次而下）：

• 1）如果C 不是一个数组类型，虚拟机将会把代表N的全限定名传递给 D 的类加载器去加载这个类 C。在加载过程中，由于元数据验证、字节码验证的需要，又可能触发其他相关类的加载动作（例如加载这个类的父类或实现的接口）。一旦这个加载过程出现任何异常，解析过程宣告失败。
• 2）如果C 是一个数组类型，并且数组的元素类型为对象，也就是N 的描述符会是类似“[Ljava/lang/Integer”的形式，将会按照第一点的规则加载数组元素类型。如果N的描述符如前面所假设的形式，需要加载的数据是“java.lang.Integer”，接着由虚拟机生成一个代表此数组维度和元素的数组对象。
• 3）如果上面步骤无任何异常，那么 C在虚拟机中实际上已经成为一个有效的类或接口了，但在解析完成之前还要进行符号引用验证，确认 D 是否具备对C的访问权限。若不具备访问权限，将抛出 java.lang.IllegalAccessError异常。

b. 字段解析

要解析一个未被解析过的字段符号引用，首先将会对字段表内 class_index 项中索引的 CONSTANT_Class_info 符号进行引用解析，也就是字段所属的类或接口的符号引用。如果在此解析这个类或接口符号引用的过程中出现任何异常，都会导致字段符号引用解析的失败。如果解析成功，那将这个字段所属的类或接口用 C 表示，虚拟机规范要求按照如下步骤进行后续字段搜索：

• 1）如果C 本身包含了简单名称和字段描述符都与目标相匹配的字段，则返回这个字段的直接引用，查找结束。
• 2） 否则，如果在C 中实现了接口，将会按照继承关系从下往上递归搜索各个接口和它的父接口，如果接口中包含了简单名称和字段描述符都与目标相匹配的字段，则返回这个字段的直接引用，查找结束。
• 3）否则，如果 C 不是 java.lang.Object 的话，将会按照继承关系从下往上递归搜索其父类，如果在父类中包含了简单名称和字段描述符都与目标相匹配的字段，则返回这个字段的直接引用，查找结束。
• 4）否则，查找失败，抛出 java.lang.NoSuchFieldError 异常

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

以上就是字段解析的步骤，但是在实际应用中，虚拟机的编译实现可能会比上述规范要求严格一些，如果有一个同名字段同时出现在 C 的接口和父类中，或者同时在自己或父类的多个接口中出现，那编译器将可能拒绝编译。例如以下代码：

package org.fenixsoft.classloading;

public class FieldResolution {

    interface Interface0 {
        int A = 0;
    }

    interface Interface1 extends Interface0 {
        int A = 1;
    }

    interface Interface2 {
        int A = 2;
    }

    static class Parent implements Interface1 {
        public static int A = 3;
    }

    static class Sub extends Parent implements Interface2 {
        public static int A = 4;//注释掉将会无法编译
    }

    public static void main(String[] args) {
        System.out.println(Sub.A); //输出结果为4
    }
}
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

如果注释Sub类中的public static int A = 4; ，接口与父类同时存在字段A，编译器将会提示“This field Sub.A is ambiguous”，并且无法编译，结果如下图：

c. 类方法解析

类方法解析的第一个步骤与字段解析相同，也需要先解析出类方法表的 class_index 项中索引的方法所属的类或接口的符号引用，如果解析成功，依然用C 表示这个类。虚拟机会按照以下步骤进行后续的类方法搜索：

• 1） 类方法和接口方法符号引用的常量类型定义时分开的，如果在类方法表中发现 class_index 项中索引的C 是个接口，直接抛出 java.lang.IncompatibleClassChangeError异常。
• 2）如果通过第一步，在类 C中查找是否有简单名称和描述符都与目标相匹配的方法，如果有则返回这个方法的 直接引用，查找结束。
• 3）否则，在类C 的父类中递归查找是否有简单名称和描述符都与目标相匹配的方法，如果有则返回这个方法的 直接引用，查找结束。
• 4）否则，在类C 实现的接口列表以及它们的父接口中递归查找是否有简单名称和描述符都与目标相匹配的方法，如果存在匹配的方法，说明类C 是一个抽象类，这时查找结束，抛出 java.lang.AbstractMethodError异常。
• 5）否则，宣告方法查找失败，抛出 java.lang.NoSuchMethodError异常。

最后，如果查找过程成功返回了直接引用，将会对这个方法进行权限验证，如果发现不具备此方法的访问权限，将抛出 java.lang.IllegalAccessError 异常。

d. 接口方法解析

接口方法也需要先解析出接口方法表的 class_index 项中索引的方法所属的类或接口的符号引用，如果解析成功，依然用C表示这个接口。虚拟机会按照以下步骤进行后续的接口方法搜索：

• 1）与类方法解析不同，如果在接口方法表中发现 class_index 中的索引C 是个类而不是接口，直接抛出 java.lang.IncompatibleClassChangeError异常。
• 2）否则，在接口 C中查找是否有简单名称和描述符都与目标相匹配的方法，如果有则返回这个方法的 直接引用，查找结束。
• 3）否则，在接口 C 的父接口中递归查找，直到 java.lang.Object类为止，看是否有简单名称和描述符都与目标相匹配的方法，如果有则返回这个方法的 直接引用，查找结束。
• 4）否则，宣告方法查找失败，抛出 java.lang.NoSuchMethodError异常。

由于接口中的所有方法默认是public的，所以不存在访问权限的问题，因此接口方法的符号解析应当不会抛出 java.lang.IllegalAccessError 异常。

---

---

5. 初始化

（1）开始时机

类初始化阶段是“类加载过程”中最后一步，在之前的阶段，除了加载阶段用户应用程序可以通过自定义类加载器参与，其它阶段完全由虚拟机主导和控制，直到初始化阶段，才真正开始执行类中定义的Java程序代码。

（2）工作任务

在准备阶段，变量已经赋过一次初始值，在初始化阶段，则是根据程序员通过程序制定的主观计划去初始化类变量和其它资源，简单说，初始化阶段即虚拟机执行类构造器<clinit>()方法的过程。

（3）< clinit>()方法

下面来详细讲解<clinit>()方法是怎么生成的，首先来了解此方法执行过程中可能会影响到程序运行行为的特点和细节：

• <clinit>()方法是由编译器自动收集类中所有类变量的赋值动作和静态语句块（static{} 块）中的语句合并产生的，编译器收集的顺序由语句在源文件中出现的顺序决定，特别注意的是，静态语句块只能访问到定义在它之前的类变量，定义在它之后的类变量只能赋值，不能访问。例如以下代码：

public class Test {
    static {
        i = 0;  //  给变量复制可以正常编译通过
        System.out.print(i);  // 这句编译器会提示“非法向前引用”  
    }
    static int i = 1;
}
 
 
1
2
3
4
5
6
7
 
 
1
2
3
4
5
6
7

• <clinit>()方法与类的构造函数（或者说实例构造器<init>() 方法）不同，不需要显式的调用父类的()方法。虚拟机会自动保证在子类的<clinit>()方法运行之前，父类的<clinit>()方法已经执行结束。因此虚拟机中第一个执行<clinit>()方法的类肯定为java.lang.Object。

• 由于父类的<clinit>()方法先执行，也就意味着父类中定义的静态语句块要优于子类的变量赋值操作。例如以下代码：

static class Parent {
        public static int A = 1;
        static {
            A = 2;
        }
}

static class Sub extends Parent {
        public static int B = A;
}

public static void main(String[] args) {
        System.out.println(Sub.B);//输出结果是父类中的静态变量值A，也就是2
}
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14

• <clinit>()方法对于类或接口不是必须的，如果一个类中不包含静态语句块，也没有对类变量的赋值操作，编译器可以不为该类生成<clinit>()方法。

• 接口中不可以使用静态语句块，但仍然有类变量初始化的赋值操作，因此接口与类一样都会生成<clinit>()方法。但接口与类不同的是，执行接口的<clinit>()方法不需要先执行父接口的<clinit>()方法。只有当父接口中定义的变量使用时，父接口才会初始化。另外，接口的实现类在初始化时也一样不会执行接口的<clinit>()方法。

• 虚拟机会保证一个类的<clinit>()方法在多线程环境下被正确的加锁和同步，如果多个线程同时初始化一个类，只会有一个线程执行这个类的<clinit>()方法，其它线程都会阻塞等待，直到活动线程执行<clinit>()方法完毕。如果在一个类的<clinit>()方法中有耗时的操作，就可能造成多个进程阻塞，在实际过程中此种阻塞很隐蔽，可见下例：

static class DeadLoopClass {
    static {
        // 如果不加上这个if语句，编译器将提示“Initializer does not complete normally”并拒绝编译
        if (true) {
            System.out.println(Thread.currentThread() + "init DeadLoopClass");
            while (true) {
            }
        }
    }
}

public static void main(String[] args) {
    Runnable script = new Runnable() {
        public void run() {
            System.out.println(Thread.currentThread() + "start");
            DeadLoopClass dlc = new DeadLoopClass();
            System.out.println(Thread.currentThread() + " run over");
        }
    };

    Thread thread1 = new Thread(script);
    Thread thread2 = new Thread(script);
    thread1.start();
    thread2.start();
}
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

运行结果：

由以上结果可知，一条线程在死循环以模拟长时间操作，另外一条线程在阻塞等待。

---

---

---

---

三. 总结

此篇博文融合了前面讲解的Class文件相关知识，即虚拟机加载Class文件的过程，将描述类的数据从Class文件加载到内存，并对数据进行校验、转换解析和初始化，最终形成可以被虚拟机直接使用的Java类型。详细学习了类加载过程中的“加载”、“验证”、“准备”、“解析”、“初始化”这5个阶段中虚拟机所做的工作任何和执行步骤。

此部分是在JVM学习中或者面试中的一大重点，需细心理解体会其JVM的类加载机制。若对操作系统熟悉的朋友，可以将操作系统中的内存分区与之相比较，细细想来确有些相似，可以验证各类知识虽然不同，但是大体都有些相似之处，需要我们融汇贯通，综合起来思考其运作原理，你会发现看似不同的系统机制，其实内部还是有相似的底层原理支撑，只是具体的实现各不相同罢了。