【JVM】搞清类加载机制

优秀借鉴

1. 博文借鉴

【死磕JVM】五年 该知道JVM加载机制了!

java虚拟机Class对象是放在方法区还是堆中

Java类加载机制

2. 书籍借鉴

《深入理解Java虚拟机-JVM高级特性与实践》

1、概述

总所周知，在Java中每一个类或者接口，在编译之后都会生成相对应的.class文件，Java虚拟机把描述类的数据从Class文件中加载到内存，并对数据进行校验、转换解析和初始化，最终形成可以被虚拟机直接使用的Java类型，这个过程就是JVM的类加载机制。

在Java中，类的加载、连接、初始化过程都是在程序运行期间完成的，这种策略虽然会令类加载时稍微增加性能开销，但是却为Java程序提供了比较高的灵活性。对于类的生命周期共有7个阶段，分别是 加载、验证、准备、解析、初始化、使用、卸载，前5个阶段便是类的加载过程，即 加载、验证、准备、解析、初始化，其中的 验证、准备、解析 三个部分统称为 连接。

2、类加载的时机

2.1、概述

现在我们知道类的加载过程有 加载、验证、准备、解析、初始化 五个步骤，其顺序图如下：

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

值得注意的是，加载、验证、准备和初始化这四个阶段顺序确定的是开始的顺序，并非串行的顺序一个个开始执行结束，这是因为这些阶段通常都是互相交叉地混合进行的，会在一个阶段执行的过程中调用、激活另一个阶段。

2.2、初始化的主动引用

在加载阶段，《Java虚拟机规范》中并没有进行强制约束，但与对初始化阶段，《Java虚拟机规范》 则是严格规定了有且只有六种情况必须立即对类进行“初始化”，这也被称为对一个类进行主动引用(这个时候前三个步骤肯定已经开始)：

1. 遇到new、getstatic、putstatic或invokestatic这四条字节码指令时，如果类型没有进行过初始化，则需要先触发其初始化阶段；
   • new：指使用new关键字实例化对象；
   • getstatic：指读取一个类型的静态字段(被final修饰、已在编译期把结果放入常量池的静态字段除外)；
   • putstatic：指设置一个类型的静态字段(被final修饰、已在编译期把结果放入常量池的静态字段除外)；
   • invokestatic：指调用一个类型的静态方法。
2. 使用java.lang.reflect包的方法对类型进行反射调用的时候，如果类型没有进行过初始化，则需要先触发其初始化；
3. 当初始化类的时候，如果发现其父类还没有进行过初始化，则需要优先触发其父类的初始化；
4. 当虚拟机启动时，用户需要指定一个要执行的主类（包含main()方法的那个类），虚拟机会先初始化这个主类；
5. 在JDK8之后，如果某个接口中存在default关键字修饰的方法，那么在其实现类初始化之前，该接口要在实现类之前触发初始化；
6. 当使用JDK7新加入的动态语言支持时，如果一个java.lang.invoke.MethodHandle实例最后的解析结果为REF_getStatic、REF_putStatic、REF_invokeStatic、REF_newInvokeSpecial四种类型的方法句柄，并且这个方法句柄对应的类没有进行过初始化，则需要先触发其初始化。

需要特别指出的是，类的实例化和类的初始化是两个完全不同的概念：

• 类的实例化是指创建一个类的实例(对象)的过程;
• 类的初始化是指为类各个成员赋初始值的过程，是类生命周期中的一个阶段;

方法句柄（Method Handle）是一种轻量级的、类型安全的、动态性能较高的Java方法引用机制，通过java.lang.invoke.MethodHandle类来实现。它可以看作是Java7引入的一种新的方法引用方式，类似于Java5中引入的泛型和Java8中引入的Lambda表达式。

方法句柄可以看作是一种轻量级的函数指针，它是一种可以直接引用Java方法、构造函数、字段等对象的引用类型。与Java反射机制不同的是，方法句柄具有更高的性能和更好的类型检查。

2.3、初始化的被动引用

前面提及到了《Java虚拟机规范》中有且只有的六种初始化情况，这六种情况中的行为被称为对一个类型进行主动引用。除此之外，所有引用类型的方式都不会触发初始化，称为被动引用。下面引用《深入理解Java虚拟机》中三个例子进行演示：

2.3.1、子类引用父类的静态字段

被动引用例子之一：当我们通过子类引用父类的静态字段时，并不会导致子类初始化。

/**
 * 演示父类
 **/
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！”。

对于静态字段，只有直接定义这个字段的类才会被初始化，因此通过其子类来引用父类中定义的静态字段，只会触发父类的初始化而不会触发子类的初始化。

2.3.2、数组定义引用类型

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

// 复用了上面的父子类
public class NotInitialization {
    public static void main(String[] args) {
    	SuperClass[] sca = new SuperClass[10];
    }
}

上述代码运行之后，并没有输出“SuperClass init！”，这说明并没有触发数组中引用类型的初始化，这是因为在Java中对数组元素的访问进行了封装，因此数组中存放的都是默认值。

2.3.3、引用常量

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

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

上述代码运行之后，并没有输出"ConstClass init!"，这说明并没有触发ConstClass类的初始化。这是因为虽然在Java源码中确实引用了 ConstClass类的常量HELLOWORLD，但其实在编译阶段通过常量传播优化，已经将此常量的值“hello world”直接存储在NotInitialization类的常量池中，以后NotInitialization对常量 ConstClass.HELLOWORLD的引用，实际都被转化为NotInitialization类对自身常量池的引用了。

2.4、接口的特殊性

接口的加载过程与类加载过程稍有不同，针对接口需要做一些特殊说明：接口也有初始化过程， 这点与类是一致的，上面的代码都是用静态语句块 static{} 来输出初始化信息的，而接口中不能使 用 static{} 语句块，但编译器仍然会为接口生成 <clinit>() 类构造器，用于初始化接口中所定义的成员变量。

接口与类真正有所区别的是前面讲述的六种“有且仅有”需要触发初始化场景中的第三种：

• 对于类：当一个类在初始化时，要求其父类全部都已经初始化过了；
• 对于接口：当一个接口在初始化时，并不要求其父接口全部都完成了初始化，只有在真正使用到父接口的时候（如引用接口中定义的常量）才会初始化。

类构造器 <clinit> 是由编译器自动生成的，且只会执行一次，它负责对类变量进行初始化。在 <clinit> 方法中，类变量被赋予了初始值，这些初始值可以是静态代码块中的赋值语句、类变量的默认值或者是显式赋值语句等。

3、加载

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

1. 通过一个类的全限定名来获取定义此类的二进制字节流，即通过全限定名去找到与其对应的.class文件；
2. 将这个字节流所代表的静态存储结构，即这个.class文件内的二进制数据读取出来，转化为方法区的运行时数据结构；
3. 在内存即堆中生成一个代表这个类的java.lang.Class对象，作为方法区这个类的各种数据的访问入口。

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

4、连接

4.1、验证

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

在验证阶段大致上会完成下面四个阶段的检验动作：

• 文件格式验证：验证字节流是否符合Class文件格式的规范。例如：是否以0xCAFEBABE开头、主次版本号是否在当前虚拟机的处理范围之内、常量池中的常量是否有不被支持的类型 … 等等；
• 元数据验证：对字节码描述的元数据信息进行语义分析，要符合Java语言规范。例如：是否继承了不允许被继承的类（例如final修饰过的）、类中的字段、方法是否和父类产生矛盾 … 等等；
• 字节码验证：对类的方法体进行校验分析，确保这些方法在运行时是合法的、符合逻辑的；
• 符号引用验证：发生在解析阶段，符号引用转为直接引用的时候，例如：确保符号引用的全限定名能找到对应的类、符号引用中的类、字段、方法允许被当前类所访问 … 等等。

值得注意的是，验证阶段的重要性是毋庸置疑的，但却不是必须的，它对程序运行期没有影响，如果所引用的类经过反复验证，那么可以考虑采用-Xverifynone参数来关闭大部分的类验证措施，以缩短虚拟机类加载的时间。

4.2、准备

准备阶段是正式为类中定义的变量（即静态变量，被static修饰的变量）分配内存并设置类变量初始值的阶段。

虽然概念很简单，但是在这一阶段仍然需要注意以下点：

• 进行内存分配的仅包括类变量，而不包括实例变量，实例变量将会在对象实例化时随着对象一起分配在堆中；
• 设置初始化值指的是给变量赋零值而非Java代码中被显式赋予的值，如程序中public static int value = 1，那么value变量在准备阶段过后的值为int的零值0，而非被显式赋予的1；
• 如果类变量被final字段修饰，那么准备阶段赋予的值便为显示指定的值，如上面的value字段加上final关键字，那么value变量在准备阶段过后的值为被显式赋予的1，而非int的零值0；
• 在JDK8取消永久代后，方法区变成了一个逻辑上的区域，这些类变量的内存实际上是分配在Java堆中的。

Java中所有的数据类型零值如下：

数据类型	零值	数据类型	零值
boolean	false	byte	(byte)0
short	(short)0	int	0
long	0L	float	0.0f
double	0.0d	char	‘\u0000’
reference	null

4.3、解析

解析阶段是Java虚拟机将常量池内的符号引用替换为直接引用的过程，解析动作主要针对类或接口、字段、类方法、接口方法、方法类型、方法句柄和调用点限定符这7类符号引用进行。我们可以把解析阶段中，符号引用转换为直接引用的过程，理解为当前加载的这个类，和它所引用的类，正式进行“连接“的过程。

这里补充一下符号引用和直接引用的基本概念：

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

5、初始化

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

进行准备阶段时，变量已经赋过一次系统要求的初始零值，而在初始化阶段，则会根据程序中显示设定的值进行赋值。同时静态代码块中也会在此时执行，两者的顺序由在程序中出现的顺序决定的，定义在它之后的变量，在前面的静态语句块可以赋值，但是不能访问。下面是例子：

public class LoadTest {
    static {
        // 对定义在静态代码块之后的变量可以赋值
        i = 0;
        // 对定义在静态代码块之后的变量不能访问，报错提示：(java: 非法前向引用)
        System.out.println(i);
    }
    static int i = 1;

    public static void main(String[] args) {
        new LoadTest();
    }
}

改正之后的代码应该是这样子，同时建议编码过程中静态代码块应编写在变量定义之后：

public class Test {
    // 将变量定义移到静态代码块之前
    static int i = 1; 
    static {
        // 给变量赋值
        i = 0; 
        // 打印变量的值，可以正常输出
        System.out.print(i); 
    }
}

6、新建一个对象会发生什么

我们都知道在新建一个对象之后，我们拿到的实例便是已经赋值完成的了，那么整个流程是怎么样的呢？下面便是流程介绍：

1. 父类的静态变量初始化(只执行一次)；
2. 子类的静态变量初始化(只执行一次)；
3. 父类的静态代码块执行(只执行一次)；
4. 子类的静态代码块执行(只执行一次)；
5. 父类的实例变量初始化；
6. 父类的构造器执行；
7. 子类的实例变量初始化；
8. 子类的构造器执行。

有父类时一定先执行父类，整体的流程为：静态变量->静态代码块->实例变量和构造器