深入了解Java虚拟机---虚拟机类加载机制

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

类的生命周期

类加载时机

类从被加载到虚拟机内存中开始，直至从内存卸载为止一共包括7个阶段，如上图所示。其中 验证、准备以及解析这个三个过程统称为连接。

加载、验证、准备、初始化和卸载这5个阶段的顺序是确定的，累计的加载过程必须按照这种顺序按部就班地开始，但是解析阶段不一定，这是为了支持Java语言的动态绑定。但是这几个阶段又不是完全孤立分割的，也就是说某几个阶段可能会交叉进行。

有且仅有5种情况必须对类进行“初始化”（加载、验证、准备阶段在此之前就要完成）：

• 在遇到new、getstatic、putstatic、或invokestatic这4条字节码指令时，如果此时类未进行初始化， 那就需先触发其初始化。
  对应的Java代码场景是：使用new关键字实例化对象、读取或者设置一个静态字段（被final修饰，在编译时期把结果放入常量池中的静态字段除外）的值以及调用类的静态方法时；

• 使用java.lang.reflect包的方法对类进行反射调用时，如果类没有进行过初始化，那就需先触发其初始化；
• 当初始化一个类时，如果发现其父类尚未初始化，则需先触发其父类的初始化；
• 当虚拟机启动时，用户需要指定一个要执行的主类（包含main()方法的那个类），虚拟机会先初始化这个主类；
• 当使用动态语言支持时，如果一个java.lang.invoke.MethodHandle实例最后的解析结果REF_getStatic、REF_putStatic、REF_invokeStatic的方法句柄，并且这个方法句柄所对应的类没有进行过初始化，则需要先进行初始化。

注意：有且仅有上面五种情况会触发类的初始化

那么除此之外，所有引用类的方式都不会触发初始化，称为被动引用。
被动引用举例：

只会输出“SuperClass Init!” 不会触发SuperClass初始化 不会触发ConstClass类的初始化

接口的加载过程和类的加载过程稍有不同：
接口也有初始化的过程，这和类是一致的。但是接口中不允许出现“static{ }”语句块。
接口与类有真正区别的是在上面五种“有且仅有”条件中的第三个：

当一个类在初始化时，要求其父类全部都已经初始化过了，但是一个接口在初始化时，并不要求父接口已经完成初始化，而是要在用到父接口时才对其进行初始化。

类加载过程

Java虚拟机中类加载过程包括5个阶段：加载、准备、验证、解析、初始化。

加载

“加载（Loading）”是“类加载（Class Loading）”过程中的一个阶段。

“加载”阶段虚拟机需要完成以下3件事情：

• 通过类的全限定类名来获取此类的二进制字节流（可以从多种渠道获取，例如从ZIP包中、从网络中，或者是运行时计算生成等）；

• 将这个字节流所代表的静态存储结构转换为方法区的运行时数据结构；
• 在内存中生成一个代表这个类的java.lang.Class对象，作为方法区中这个类的各种数据的访问入口。

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

对于数组类而言，情况有所不同。
数组类本身不通过类加载器创建，它是由Java虚拟机直接创建的。但是数组类与类加载器仍然有很密切的关系。因为数组类的元素类型（Element Type,指的是数组去掉所有维度的类型）最终是要靠类加载器去创建，一个数组类（下面简称C）创建过程需要遵循以下规则：

• 如果数组的组件类型（Component Type，指的是数组去掉一个维度的类型）是引用类型，那就递归上面定义的加载过程去加载这个组件类型，数组C将在加载该组件类型的类加载器的类名称空间上被标识（一个类必须与类加载器一起确定唯一性）；

• 如果数组的组件类型不是引用类型（例如int[ ]数组)，Java虚拟机将会把数组C标记为与引导类加载器关联；
• 数组类的可见性与它的组件类型的可见性一致，如果组建类型不是引用类型，那数组类的可见性将默认为public。

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

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

验证

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

验证阶段大致会包含下面4个阶段的检验动作：

1. 文件格式验证

2. 元数据验证
3. 字节码验证
4. 符号引用验证

1.文件格式验证
第一阶段要验证字节流是否符合Class文件格式的规范，并且能被当前版本的虚拟机处理。
这一阶段可能包含下面这些验证点：

• 是否以魔数0XCAFEBABE开头；

• 主、次版本号是否在当前虚拟机处理范围之内；
• 常量池中的常量是否有不被支持的常量类型；
• 指向常量的各种索引值是否有指向不存在的常量或不符合类型的常量；
• Class文件中各个部分以及文件本身是否有被删除的或附加的其他信息。

其实第一阶段的验证内容远不止上面这几条。
该验证阶段的目的是保证输入的字节流能正确地解析并存储于方法区之内，格式上符合描述一个Java类型信息的要求。该阶段的验证是基于二进制字节流进行的，只有通过了这个阶段的验证之后，字节流才会进入内存的方法区中进行存储。
所以后面的3个验证阶段全部是基于方法区的存储结构进行的，不会再操作字节流。

2.元数据验证
第二阶段的验证是对字节码描述的信息进行语义分析，以保证其描述的信息符合Java语言规范的要求，这个阶段可能包含的验证点如下：

• 这个类是否有父类（除了java.lang.Object之外，其他类都应该有父类）

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

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

3.字节码验证
第三阶段是整个验证过程中最复杂的一个阶段，主要目的是通过数据流和控制流分析，确定程序语义是合法的、符合逻辑的。
在第二阶段对元数据信息中的数据类型做完校验之后，这个阶段将对类的方法体进行校验分析，保证被校验类的方法在运行时不会做出危害虚拟机安全的事情，如：

• 保证任意时刻操作数栈的数据类型与指令代码序列都能配合工作，例如不会出现类似于这样的情况：在操作数栈中放置了一个int类型的数据，使用时却按long类型来载入本地变量表中；

• 保证跳转指令不会跳转到方法体以外的字节码指令上；
• 保证方法体中的类型转换是有效的，例如可以把一个子类对象赋值给父类数据类型，这是安全的。但是把父类对象赋值给子类数据类型，甚至把对象赋值给与它毫无继承关系、完全不相干的数据类型，则是危险和不合法的。

如果一个类方法体的字节码没有通过字节码验证，那就说明是有问题的。
但是就算一个方法体通过了字节码验证，也不能说它就一定是安全的：通过程序去校验程序逻辑是无法做到绝对准确的----不能通过程序准确地检查出程序是否能在有限的时间之内结束运行。

4.符号引用验证
最后一个阶段的验证发生在虚拟机将符号引用转换为直接引用的时候，这个转化动作将在连接的第三阶段---解析阶段中发生。符号引用可以看作是对类自身（常量池中的各种符号引用）的信息进行匹配性校验，通过需要校验下列内容：

• 符号引用中通过字符串描述的全限定性类名是否能找到对应的类；

• 在指定类中是否存在符合方法的字段描述符以及简单名称所描述的方法和字段；
• 符号引用中的类、字段、方法的访问性（private、protected、public、default）是否可以被当前类访问。

符号引用验证的目的是确保解析动作能正常执行，如果无法通过符号引用验证，那么将抛出一个java.lang.IncompatibleClassChangeError异常的子类，如java.lang.IllegalAccessError、java.lang.NoSuchFieldError、java.lang.NoSuchMethodError等。

对于虚拟机来说，验证阶段是非常重要，但不是必需的。如果说所运行的代码都已经被反复使用和验证过，那么在实施阶段就可以考虑使用-Xverify:none参数来关闭大部分的类验证措施，以缩短虚拟机类加载的时间。

准备

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

需要注意两点：

• 这时候进行内存分配的仅包括类变量（被static修饰的变量，即静态变量），而不包括实例变量，实例变量会在对象实例化的时候随着对象一起分配在Java堆中；

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

那么在非“通常情况”之下呢？
如果类的字段属性表中存在ConstantValue属性，那在准备阶段变量value就会被初始化为ConstantValue属性所指定的值。
假设类变量value的定义为：
public static final int value = 123;
编译时Javac将会为value生成ConstantValue属性，在准备阶段虚拟机就会根据ConstantValue的设置将value赋值为123。

解析

解析阶段是虚拟机将常量池中的符号引用转化为直接引用的过程。

• 符号引用(Symbolic Reference)：

符号引用以一组符号来描述所引用的目标，符号可以是任何形式的字面量，只要使用时能无歧义地定位到目标即可。符号引用与虚拟机实现的内存布局无关，引用的目标并不一定已经加载到内存当中。各种虚拟机实现的内存布局可以各不相同，但是它们能接受的符号引用必须都是一致的，因为符号引用的字面量形式明确定义在Java虚拟机规范的Class文件格式中。

• 直接引用（Direct Referenct）：

直接引用可以是直接指向目标的指针、相对偏移量或者是一个能简介定位到目标的句柄。直接引用是和虚拟机实现的内存布局息息相关的，同一个符号引用在不同虚拟机实例上翻译出来的直接引用一般不会相同。如果有了直接引用，那引用的目标必定已经在内存中存在。

虚拟机规范中未规定解析发生的具体时间，只要求在执行anewarray、checkcast、getfield、getstatic、instanceof、invokeinterface、invokespecial、invokestatic、invokevirtual、ldc、ldc_w、multianewarray、new、putfield和putstatic这16个用于操作符号引用之前，先对它们所使用的符号引用进行解析。所以虚拟机实现可以根据需要来判断是在类被加载之前时就对常量池中的符号引用进行解析，还是等到一个符号引用将要被使用前才去解析它。

注意：

• 因为对同一个符号引用进行多次解析式很常见的事情，除invokedynamic指令以外，虚拟机可以实现对第一次解析的结果进行缓存（在运行时常量池中记录直接引用。并把常量标识为已经解析的状态）从而避免解析动作重复进行。无论是否执行了多次解析动作，虚拟机需要保证的是在同一个实体当中，如果一个符号引用之前就已经解析过，那么后续的引用解析请求也应当一直成功；同样，如果第一次解析失败了，那么其他指令对此引用的解析请求也应当收到相同的异常；

• 对于invokedynamic指令，以上规则就不成立。当碰到某个前面已经由invokedynamic指令触发过解析的符号引用时，并不意味着这个解析结果对于其他invokedynamic指令也同样生效。

1.类或接口的解析
2.字段解析
3.类方法解析
4.接口方法解析

初始化

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

在准备阶段，变量已经赋过一次系统要求的初始值，而在初始化阶段，则根据程序员通过程序制定的主观计划去初始化类变量和其他资源。

初始化阶段是执行类构造器<clint>()方法的过程

• <clinit>()方法是由编译器自动收集类中所有类变量的赋值动作和静态代码块中的语句合并产生的。静态代码块中只能访问到定义在静态代码块之前的静态变量。假如说有个静态变量在静态代码块之后定义，那么代码块可以给它赋值，但是不能访问它：

非法向前引用变量

• <clinit>()方法和类的构造函数（实例构造器<linit><>方法）不同，它不用显式调用父类构造器。虚拟机会在子类的<clinit>（）方法执行前，保证已经执行完了父类的<clinit>()方法。因此在虚拟机中第一个被执行的<clinit>()方法的类肯定是java.lang.Object

• 由于父类的<clinit>（）方法先执行，也就意味着父类中定义的静态语句块要优先于子类静态变量的赋值操作：

字段B的值为2而不是1

• <clinit>()方法对于类或者接口来说不是必需的，假如一个类中没有静态代码块，并且没有对类变量的赋值操作，那么编译器就不会给这个类生成<clinit>()方法。

• 接口中不能使用静态代码块，但是仍然有为变量进行赋值的操作，所以和类一样，接口也会生成<clinit>()方法。但是与类不同的是，执行接口的<clinit>()方法时候并不要求父接口已经将<clinit>()方法执行完毕。只有当父接口中定义的变量被使用时，才会执行父接口的<clinit>()方法。另外，接口的实现类在初始化时也一样不会执行接口的<clinit>()方法。

• 虚拟机会保证一个类的<clinit>（）方法在多线程环境中被正确地加锁、同步，如果多线程同时去初始化一个类，那么只有一个线程去执行这个类的<clinit>()方法，其他线程都需要阻塞等待，直到活动线程执行<clinit>()方法完毕。如果在一个类的<clinit>()方法中有耗时很长的操作，就可能造成多个进程阻塞。需要注意的是，其他线程虽然会被阻塞，但如果执行<clinit>()那条线程退出<clinit>()方法后，其他线程唤醒之后不会再次进入<clinit>()方法。同一个类加载器下，一个类型只会初始化一次。

关于类加载器

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

类加载器虽然只用于实现类的加载动作，但它在Java程序中起到的作用却远远不限于类加载阶段。对于任意一个类，都需要加载它的类加载器和这个类本身一同确立其在Java虚拟机中的唯一性。每一个类加载器都拥有一个独立的类命名空间。通俗点说，也就是比较两个类是否“相等”，只有在这两个类是由同一个类加载器加载的前提下才有意义，否则即使这两个类来源于同一个Class文件，被同一个虚拟机加载，只要加载它们的类加载器不同，那这两个类就必定不相等。

双亲委派模型

从虚拟机角度来讲，只存在两种类加载器：一种是启动类加载器(Bootstrap ClassLoader),这个类加载器使用C++语言实现，是虚拟机自身的一部分；另一种就是所有其他的累加器其，这些类加载器全部由Java语言实现，独立于虚拟机外部，并且全都继承自抽象类java.lang.ClassLoader。

从Java开发人员的角度，绝大部分Java程序会使用到以下三种类加载器：

• 启动类加载器(Bootstrap ClassLoader)：

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

• 拓展类加载器(Extension ClassLoader)：

这个加载器由sum.misc.Launcher$ExtClassLoader实现，它负责加载<JAVA_HOME>\lib\ext 目录中的，或者被 java.ext.dirs 系统变量所指定的路径中的所有类库，开发者可以直接使用拓展类加载器。

• 应用类加载器(Application ClassLoader)：

由 sum.misc.Launcher$ApplicationLoader 实现。由于这个类加载器是CalssLoader中的 getSystemClassLoader()方法的返回值，所以一般也称它为系统类加载器。它负责加载用户类路径(ClassPath)上所指定的类库，开发者可以直接使用这个类加载器，如果应用程序当中没有自定义过自己的类加载器，一般情况下默认使用这个类加载器。

类加载器双亲委派模型

上图展示的类加载器之间的关系，称为类加载器的双亲委派模型（Parents Delegation Mode）。双亲委派模型要求除了顶层的启动类加载器之外，其他的类加载器都应该有自己的父类加载器。这里类加载器之间的父子关系一般不会以继承(Inheritance)的关系来实现，而是都使用组合(Composition)关系来复用父加载器的代码。

双亲委派机制工作原理：

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

使用双亲委派模型的好处：

Java类随着它的类加载器一起具备了一种带有优先级的层次关系。如类java.lang.Object，它存放在 rt.jar 之中，无论哪个类加载器要加载这个类，最终都是委派给顶层的启动类加载器进行加载，因此Object类在程序中的各种类加载器环境中都是同一个类。相反，若没有使用双亲委派模型，由各个类加载器自行去加载的话，如果用户自己编写了一个叫做java.lang.Object的类，并存放在程序的ClassPath中，那么系统将会出现多个不同的Object类，Java类型体系中最基础的行为也就无法保证，应用程序也会变得一片混乱。