(001-下)JVM类加载器补充

1.JVM虚拟机主要分为五大模块(如下图)

1）类装载器子系统
2）运行时数据区
3）执行引擎
4）本地方法接口
5）垃圾收集模块

2.类的加载
虚拟机类装载子系统：虚拟机把描述类的数据从class文件加载到内存，并对数据进行校验、转换解析和初始化，最终形成可以被虚拟机直接使用的Java类型。

类的加载指的是将类的.class文件中的二进制数据读入到内存中，将其放在运行时数据区的方法区内，然后在堆区创建一个java.lang.Class对象，用来封装类在方法区内的数据结构。类的加载最终形态是位于堆区中的Class对象，Class对象封装了类在方法区内的数据结构，并且向java程序员提供访问方法区内的数据结构的接口。

类加载器并不需要等到某个类被"首次主动使用"时再加载它，JVM规范允许类加载器在预料某个类将要被使用时就预先加载它，如果在预先加载的过程中遇到.class文件缺失或存在错误，类加载器必须在程序首次主动使用该类时才报告错误(LinkageError错误) 如果这个类一直没有被程序主动使用，那么类加载器就不会报错。

加载.class文件的方式：

• 通过本地系统中直接加载
• 通过网络下载.class文件
• 从zip、jar等归档文件中加载.class文件
• 从专有数据库中提取.class文件
• 将java源文件动态编译成.class文件

3.类的生命周期
类从被加载到虚拟机内存中开始到卸载出内存为止，它的整个生命周期包括：加载、验证、准备、解析、初始化、使用、卸载七个阶段。


什么时候类加载？

• 使用new关键字实例化对象
• 读取或设置一个类的静态变量的时候
• 调用类的静态方法的时候
• 对类进行反射调用的时候
• 初始化子类时，父类会先被初始化
• 对类使用动态代理的时候需要先被初始化

4.类加载过程
类的加载过程包括了加载、验证、准备、解析、初始化五个阶段。

在这五个阶段中，加载、验证、准备和初始化这四个阶段发生的顺序是确定的，而解析阶段则不一定，它在某些情况下可以在初始化阶段之后开始，这是为了支持Java语言的运行时绑定（也称为动态绑定或晚期绑定）。另外注意这里的几个阶段是按顺序开始，而不是按顺序进行或完成，因为这些阶段通常都是互相交叉地混合进行的，通常在一个阶段执行的过程中调用或激活另外一个阶段。

Java中的绑定：绑定指的是把一个方法的调用与方法所在的类（方法主体）关联起来，对Java来说绑定分为静态绑定和动态绑定。

• 静态绑定（即前期绑定）：在程序执行前方法已经被绑定，此时由编译器或其它连接程序实现。针对java，简单的可以理解为程序编译期的绑定。java当中的方法只有final、static、private和构造方法是前期绑定的。
• 动态绑定（即后期绑定）：在运行时根据具体对象的类型进行绑定。在java中几乎所有的方法都是后期绑定的。

5.加载

• 加载过程(在加载阶段虚拟机需要完成以下三件事情
  1）通过一个类的全限类名来获取其定义的二进制字节流，是可控性最强的阶段(Class文件、Jar包、网络中Applet、JSP)
  2）将这个字节流所代表的静态存储结构转化为方法区的运行时数据结构
  3）在Java堆中生成一个代表这个类的java.lang.Class对象(Class对象比较特殊，存放在方法区)，作为对方法区中这些数据的访问入口
• 类加载机制
  **全盘负责：**当一个类加载器负责加载某个Class时，该Class所依赖的和引入的其它Class也将由该类加载器负责载入，除非显示使用另外一个类加载器来载入。
  **父类委托：**先让父类加载器试图加载该类，只有在父类加载器无法加载该类时才会尝试从自己的类路径中加载该类。
  **缓存机制：**缓存机制将会保证所有加载过的Class都会被缓存，当程序中需要使用某个Class时，类加载器先从缓存区寻找该Class，只有缓存区不存在，系统才会读取该类对应的二进制数据，并将其转换成Class对象，存入缓存区。这就是为什么修改了Class后，必须重启JVM，程序的修改才会生效。
• 类加载器
  对于任意一个类，都需要由它的类加载器和这个类本身一同确定其在就Java虚拟机中的唯一性，也就是说，即使两个类来源于同一个Class文件，只要加载它们的类加载器不同，那这两个类就必定不相等。这里的“相等”包括了代表类的Class对象的equals（）、isAssignableFrom（）、isInstance（）等方法的返回结果，也包括了使用instanceof关键字对对象所属关系的判定结果。

6.验证
验证的目的是为了确保Class文件中的字节流包含的信息符合当前虚拟机的要求，而且不会危害虚拟机自身安全。

不同的虚拟机对类验证的实现可能会有所不同，但大致都会完成以下四个阶段的验证：
文件格式的验证、元数据的验证、字节码验证和符号引用验证。

• 文件格式的验证
  验证字节流是否符合Class文件格式的规范，并且能被当前版本的虚拟机处理，该验证的主要目的是保证输入的字节流能正确的解析并存储于方法区之内。经过该阶段的验证后，字节流才会进入内存的方法区中进行存储，后面的三个验证都是基于方法区的存储结构进行的。
• 元数据验证
  对类的元数据信息进行语义校验（其实就是对类中的各种数据类型进行语法校验），保证不会存在不符合Java语法规范的元数据信息。
• 字节码验证
  该阶段验证的主要工作是进行数据流和控制流分析，对类的方法体进行校验分析，以保证被校验的类的方法在运行时不会做出危害虚拟机安全的行为。
• 符号引用验证
  这是最后一个阶段的验证，它发生在虚拟机将符号引用转化为直接引用的时候，主要是对类自身以外的信息（常量池中的各种符号引用）进行匹配性的校验。

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

1. 这时候进行内存分配的仅包括类变量(static)，分配在方法区，而不包括实例变量，实例变量会在对象实例化时随着对象一块分配在java堆中。
2. 这里所设置的初始值通常情况下是数据类型默认值(如0、0L、null、false等)，而不是在java代码中被显示的赋值（初始化阶段才会执行）。

假设一个类变量的定义为：public static int value = 3；
那么变量value在准备阶段过后的初始值为0，而不是3，
因为这时候尚未开始执行任何Java方法，而把value赋值为3的putstatic指令是在程序编译后，存放于类构造器（）方法之中的，
所以把value赋值为3的动作将在初始化阶段才会执行。

3. 如果类字段的字段属性表中存在ConstantValue属性，即同时被static和final修饰，那么在准备阶段value就会被初始化为ConstantValue属性所指定的值。

假设上面的类变量value被定义为： public static final int value = 3；
编译时Javac将会为value生成ConstantValue属性，在准备阶段虚拟机就会根据ConstantValue的设置将value赋值为3。
我们可以理解为static final常量在编译期就将其结果放入了调用它的类的常量池中。

下表列出了Java中所有基本数据类型以及reference类型的默认零值：

这里还需要注意如下几点：
　　1）对基本数据类型来说，对于类变量（static）和全局变量，如果不显式地对其赋值而直接使用，则系统会为其赋予默认的零值，而对于局部变量来说，在使用前必须显式地为其赋值，否则编译时不通过。
　　2）对于同时被static和final修饰的常量，必须在声明的时候就为其显式地赋值，否则编译时不通过；
　　3）对于只被final修饰的常量则既可以在声明时显式地为其赋值，也可以在类初始化时显式地为其赋值，总之，在使用前必须为其显式地赋值，系统不会为其赋予默认零值。
　　4）对于引用数据类型reference来说，如数组引用、对象引用等，如果没有对其进行显式地赋值而直接使用，系统都会为其赋予默认的零值，即null。如果在数组初始化时没有对数组中的各元素赋值，那么其中的元素将根据对应的数据类型而被赋予默认的零值。

8.解析
解析阶段是虚拟机将常量池中的符号引用转化为直接引用的过程。解析阶段可能开始于初始化之前，也可能在初始化之后。虚拟机会根据需要来判断，到底是在类加载加载时就对常量池中的符号引用进行解析（初始化之前），还是等到一个符号引用将要被使用前才去解析它（初始化之后）。

对同一个符号引用进行多次解析请求是很常见的事情，虚拟机实现可能会对第一次解析的结果进行缓存（在运行时常量池中记录直接引用，并把常量标识为已解析状态），从而避免解析动作重复进行。

符号引用：
符号引用就是以一组符号来描述所引用的目标，符号可以是任何形式的字面量，只要使用时能够无歧义的定位到目标即可。符号引用与虚拟机的内存布局无关，引用的目标并不一定加载到内存中。在Java中，一个java类将会编译成一个class文件。在编译时，java类并不知道所引用的类的实际地址，因此只能使用符号引用来代替。比如org.demo.User类引入了org.demo.Student类，在编译时User并不知道Student类的实际内存地址，因此只能使用org.demo.Student（假设是这个，当然实际中是由类似于CONSTANT_Class_info的常量来表示的）来表示Student类的地址。各种虚拟机实现的内存布局可能有所不同，但是他们能接受的符号引用都是一致的，因为符号引用的字面量形式明确定义在JAVA虚拟机规范的Class文件格式中。

直接引用：
直接引用可以是：
（1）直接指向目标的指针(比如，指向“类型”[Class对象]、类变量、类方法的直接引用可能是指向方法区的指针)
（2）相对偏移量(比如，指向实例变量、实例方法的直接引用都是偏移量)
（3）一个能间接定位到目标的句柄
直接引用是和虚拟机的布局相关的，同一个符号引用在不同的虚拟机实例上翻译出来的直接引用一般不会相同。如果有了直接引用，那引用的目标必定已经被加载入内存中了。

解析动作主要针对类、字段、类方法、接口方法等四类符号引用，分别对应常量池中的CONSTANT_Class_info、CONSTANT_Fieldref_info、CONSTANT_Methodref_info、CONSTANT_InterfaceMethodref_info四种常量类型。

• 类或接口的解析
  判断所要转化成的直接引用是对数组类型还是普通的对象类型的引用，从而进行不同的判断。
• 字段解析
  对字段进行解析时，会先在本类中查找是否包含有简单名称和字段描述都与目标相匹配的字段，如果有则查找结束；如果没有则会按照继承关系从上往下递归搜索该类所实现的各个接口和它们的父接口，还没有的话则按照继承关系从上往下递归搜索其父类，直到查找结束。（查找流程如下图：）
  
• 类方法解析
  对类方法的解析与对字段解析的搜索步骤差不多，只是多了判断该方法所处的是类还是接口的步骤，而且对类方法的匹配搜索，是先搜索父类，再搜索接口。
• 接口方法解析
  与类方法解析步骤类似，只是接口不会有父类，因此，只递归向上搜索父接口就行了。

9.初始化
初始化是类加载过程的最后一步，到了此阶段才真正开始执行类中定义的Java程序代码。在准备阶段，类变量已经被赋过一次系统要求的初始值，而在初始化阶段，则是根据程序开发者通过程序指定的主观计划去初始化类变量和其它资源，或者可以从另外一个角度来表达：初始化阶段是执行类构造器＜clinit＞()方法的过程。

• clinit()方法的执行规则

1、＜clinit＞()方法是由编译器自动收集类中的所有类变量的赋值动作和静态语句块中的语句合并产生的，编译器收集的顺序是由语句在源文件中出现的顺序所决定的，静态语句块中只能访问到定义在静态语句块之前的变量，定义在它之后的变量，在前面的静态语句中可以赋值，但是不能访问。

2、＜clinit＞()方法与实例构造器< init >()方法（类的构造函数）不同，它不需要显式地调用父类构造器，虚拟机会保证在子类的< clinit >()方法执行之前，父类的< clinit >()方法已经执行完毕。因此，在虚拟机中第一个被执行的< clinit >()方法的类肯定是java.lang.Object。

3、< clinit >()方法对于类或接口来说并不是必须的，如果一个类中没有静态语句块，也没有对类变量的赋值操作，那么编译器可以不为这个类生成< clinit >()方法。

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

5、虚拟机会保证一个类的< clinit >()方法在多线程环境中被正确地加锁和同步，如果多个线程同时去初始化一个类，那么只会有一个线程去执行这个类的< clinit >()方法，其他线程都需要阻塞等待，直到活动线程执行< clinit >()方法完毕。如果在一个类的< clinit >()方法中有耗时很长的操作，那就可能造成多个线程阻塞，在实际应用中这种阻塞往往是很隐蔽的。

• 类进行初始化情况
• 主动引用
  虚拟机规范严格规定了有且只有四种情况必须立即对类进行初始化:

1. 遇到new、getstatic、putstatic、invokestatic这四条字节码指令时，如果类还没有进行过初始化，则需要先触发其初始化。
   生成这四条指令最常见的Java代码场景:
   A）使用new 关键字实例化对象
   B）读取或设置一个类的静态字段(static)时（被static修饰又被final修饰的，已在编译期把结果放入常量池的静态字段除外）
   C）调用一个类的静态方法时
2. 使用Java.lang.refect包的方法对类进行反射调用时，如果类还没有进行过初始化，则需要先触发其初始化。
3. 当初始化一个类的时候，如果发现其父类还没有进行初始化，则需要先触发其父类的初始化。
4. 当虚拟机启动时，用户需要指定一个要执行的主类，虚拟机会先执行该主类。

虚拟机规定只有这四种情况才会触发类的初始化，称为对一个类进行主动引用，除此之外所有引用类的方式都不会触发其初始化，称为被动引用。

• 被动引用
  下面举一些例子来说明被动引用：
  1、通过子类引用父类中的静态字段，这时对子类的引用为被动引用，因此不会初始化子类，只会初始化父类。 对于静态字段，只有直接定义这个字段的类才会被初始化，因此，通过其子类来引用父类中定义的静态字段，只会触发父类的初始化而不会触发子类的初始化。
  2、常量在编译阶段会存入调用它的类的常量池中，本质上没有直接引用到定义该常量的类，因此不会触发定义常量的类的初始化
  3、通过数组定义来引用类，不会触发类的初始化

• 类的实例化顺序
  （1）类中的static代码在类加载时就执行，且只执行这一次。（先静态）
  （2）如果一个类A继承了类B，在类A实例化时要先加载类B，在执行类A的构造函数时要先执行父类B的构造函数，所以此时要实例化类B。（先父后子）
  （3）一个类实例化之前要先实例化类的成员变量（非静态），再执行该类的构造函数。（先成员后构造）

  JAVA类实例化详细顺序：
  1.父类【静态成员】和【静态代码块】，按在代码中出现的顺序依次执行。
  2.子类【静态成员】和【静态代码块】，按在代码中出现的顺序依次执行。
  3.父类的【普通成员变量】和【普通代码块】，按在代码中出现的顺序依次执行。
  4.执行父类的构造方法。
  5.子类的【普通成员变量】和【普通代码块】，按在代码中出现的顺序依次执行。
  6.执行子类的构造方法。

10.结束
在如下几种情况下，JAVA虚拟机将结束生命周期。

• 执行了System.exit()方法
• 程序正常执行结束
• 程序在执行过程中遇到了异常或错误而异常终止
• 由于操作系统出现错误而导致Java虚拟机进程终止

11.程序里类的加载
类的加载有三种方式：

• 命令行启动应用时候由JVM初始化加载
• 通过Class.forName()方法动态加载
• 通过ClassLoader.loadClass()方法动态加载

package com.springli.microservice.gateway.jvm;

/**
 * @program: micro-service-frame
 * @ClassName ClassLoadTest
 * @description: 类加载模式
 * @author: SpirngLi
 * @create: 2020-09-08 13:57
 **/
public class ClassLoadTest {

    public static void main(String[] args) throws ClassNotFoundException {
        ClassLoader loader = User.class.getClassLoader();
        System.out.println(loader);

        //使用ClassLoader.loadClass()来加载类，不会执行初始化块
        loader.loadClass("com.springli.microservice.gateway.jvm.User");

        //使用Class.forName()来加载类，默认会执行初始化块
        Class.forName("com.springli.microservice.gateway.jvm.User");

        //如果通过Class.forName()来加载类且不想进行初始化则
        Class.forName("com.springli.microservice.gateway.jvm.User",false,loader);

    }

}

package com.springli.microservice.gateway.jvm;

import lombok.Data;

/**
 * @program: micro-service-frame
 * @ClassName User
 * @description: 用户实体
 * @author: SpirngLi
 * @create: 2020-09-07 15:13
 **/
@Data
public class User {
    private Long id;
    private String name;
    private Integer age;


    static{
        System.out.println("执行了User的静态代码块");
    }
}

12.总结
整个类加载过程中，除了在加载阶段用户应用程序可以自定义类加载器参与之外，其余所有的动作完全由虚拟机主导和控制。
到了初始化才开始执行类中定义的Java程序代码（亦及字节码），但这里的执行代码只是个开端，它仅限于（）方法。
类加载过程中主要是将Class文件（准确地讲，应该是类的二进制字节流）加载到虚拟机内存中，真正执行字节码的操作，在加载完成后才真正开始。
虚拟机把描述类的数据从class文件（准确地讲，应该是类的二进制字节流）加载到内存，并对数据进行校验、转换解析和初始化，最终形成可以被虚拟机直接使用的Java类型。

一些参考文章:
类的加载、连接、初始化
类加载时机