JVM虚拟机（二）类加载器、双亲委派模型、类装载的执行过程

- 一、类加载器
- - 1.1 什么是类加载器？
  - 1.2 类加载器的分类
- 二、双亲委派模型
- - 2.1 什么是双亲委派模型？
  - - 1）示例一：加载自己创建的类
    - 2）示例二：加载JDK原有的类
  - 2.2 JVM 为什么采用双亲委派模型？
- 三、类装载的执行过程
- - 3.1 加载
  - 3.2 验证
  - 3.3 准备
  - 3.4 解析
  - 3.5 初始化
  - 3.6 使用
  - 3.7 卸载
  - 3.8 总结

一、类加载器

1.1 什么是类加载器？

首先，我们来看一下类加载器在 JVM 组成中的位置：

在这里插入图片描述

类加载器：用于装载字节码文件（.class文件）。
运行时数据区：用于分配存储空间。
执行引擎：执行字节码文件或本地方法。
垃圾回收器：用于对 JVM 中的垃圾内容进行回收。

当 Java 源码编译为 Class 文件之后，由类加载子系统将 .class 字节码文件装载到运行时数据区。然后运行数据区去分布内存，然后再去执行就可以了。下面我们来看一下更加完整的回答：

类加载器：JVM 只会运行二进制文件，类加载器的作用就是将字节码文件加载到JVM中，从而让 Java 程序能够启动起来。

我们知道了类加载器之后，那么类加载器有哪些种类呢？

1.2 类加载器的分类

大家来看下面的图，类加载器一共分了四种，它们分别各司其职：

第一个是启动类加载器，或者叫引导类加载器（BootStrap ClassLoader）。用 C++ 语言编写，嵌套在 JVM 内部，主要用来加载 Java 的核心库。它会去加载 JAVA_HOME/jre/lib 路径下的所有 jar 包。
第二个是扩展类加载器（ExtClassLoader），它主要加载 JAVA_HOME/jre/lib/ext 路径下的所有 jar 包，其实就是扩展目录。如果用户自己的 jar 包也放在 JAVA_HOME/jre/lib/ext 目录下的话，也会自动使用扩展类加载器去加载里面的类。
第三个是应用类加载器（AppClassLoader），它负责加载环境变量 CLASSPATH 下面所有的类，是默认的类加载器。一般来说，Java 应用的类都是由它去完成加载。

在 Java 的日常开发中，基本上都是由以上三种类加载器配合来去完成加载的，各自加载各自的类。
最后一个是自定义类加载器（CustomizeClassLoader），自定义类继承 ClassLoader，实现自定义类加载规则。这个在我们平时的开发中用的并不是很多。

以上就是全部的四种类加载器。一般面试官问到这里，都没有问完，还会问一下什么是双亲委派模型？

二、双亲委派模型

2.1 什么是双亲委派模型？

双亲委派模型：英文是 Parent Delegation Model，这里的 “双亲” 实际指的是父级。加载某一个类，先委托上一级的加载器进行加载，如果上级加载器也有上级，则会继续向上委托，如果该类委托上级没有被加载，子加载器再尝试加载该类。

1）示例一：加载自己创建的类

举个例子，我们自己编了一个 Student 类：

按照类加载器的分类，应该是在应用类加载器（AppClassLoader）中加载。
双亲委派的意思就是先不进行加载，它要委托上级加载器进行加载，也就是扩展类加载器（ExtClassLoader）。
而扩展类加载器也有上级，所以它会继续向上委托，就找到了启动类加载器（BootStrap ClassLoader）。
但是我们会发现，Student 类并不在 JAVA_HOME/jre/lib 和 JAVA_HOME/jre/lib/ext 目录下，所以说这两个类加载器并不能加载这个类。
这个时候才会由应用类加载器（AppClassLoader）去加载 Student 类。

2）示例二：加载JDK原有的类

java.lang.String 类是我们在 Java 开发过程中经常会用到的一个字符串类，假如我们在当前的代码中用到了 String 类：

首先会来到应用类加载器（AppClassLoader），它会向上委托。
但是扩展类加载器（ExtClassLoader）也有上级，它也会向上委托。
然后启动类加载器（BootStrap ClassLoader）就会去 lib 目录中找有没有 String 类，找到后就会去加载 String 类，然后将加载好的 String 类返回给 AppClassLoader，让它直接去使用就可以了。

以上就是双亲委派模式，但是面试官还会问：为什么会采用双亲委派机制呢？

2.2 JVM 为什么采用双亲委派模型？

这里有两个原因：

通过双亲委派机制可以避免某一个类被重复加载，当父类已经加载后则无需重复加载，保证唯一性。
为了安全，保证类库 API 不会被修改。

举个例子：比如我们自己定义了一个 String 类，如下所示：

package java.lang;

public class String {
    public static void main(String[] args) {
        System.out.println("demo info");
    }
}

此时执行 main() 方法，就会出现异常：

在类 java.lang.String 中找不到 main 方法。

在这里插入图片描述

为什么会报这个错误呢？主要原因还是因为双亲委派机制。

由于是双亲委派的机制，自己定义的 java.lang.String 类在启动类加载器中并没有得到加载，而是加载了核心 jre 库中有相同名字的类文件，但该类中并没有 main() 方法。
这样可以防止而已篡改核心API库。

三、类装载的执行过程

这里会比较难，因为类装载的步骤实在是太多了，大家不太能够记得住，所以建议先去理解。

类装载的执行过程：类从加载到虚拟机中开始，直到卸载为止，它的整个生命周期包括了：加载、验证、准备、解析、初始化、使用和卸载这 7个阶段。其中，验证、准备和解析这三个部分统称为连接（linking）。

看到这里可能大家有点懵，没关系，下面我们对每个阶段进行详细讲解。

3.1 加载

在这里插入图片描述

加载阶段，主要做了以下事情：

通过类的全名，获取类的二进制数据流。
解析类的二进制数据流为方法区内的数据结构（Java类模型），也就是把类的信息存入方法区。
创建 java.lang.Class 类的实例，表示该类型。作为方法区这个类的各种数据的访问入口。

为了方便理解，我们来看一下下面这个图：

比如说现在有一个 Person 类，它被类加载器加载之后就会存入运行时数据区。在运行时数据区中，有两个区域进行存储，当然作用是不一样的：

第一个是方法区/元空间（Metaspace），存储的是 Person 类的信息。比如：Person 类的构造函数、方法、字段等。它都是存储的类的结构。
第二个是堆（Heap），在堆中会开辟一段空间去存储类的 Class 对象。这有什么作用呢？后期当我们去创建对象的时候，比如说创建了 “张三” 和 “李四” 两个对象：
- 这两个对象都是基于 Person 的 Class 去创建的，所以每个对象的对象头都会指向 Person 的 Class 对象。
- 但是 “张三” 和 “李四” 这些具体类中的数据（比如：方法、构造函数、字段）需要通过方法区才能获得。这个时候，Person 的 Class 对象就能找到方法区中 Person 类对应的数据结构，来创建这两个对象。

这个就是加载过程中所要做的事了，主要就是先把二进制数据流读入到运行时数据区，在元空间中存储类的信息，在堆中开辟一块空间来存储这个类的 Class 对象，方便后期创建对象时使用。

下面我们来看第二个阶段：

3.2 验证

在这里插入图片描述

验证阶段，属于连接的一部分，主要是验证类是否符合 JVM规范，进行安全性检查。检查内容分为四项：

文件格式验证
元数据验证
字节码验证

前三项都属于格式检查，如：文件格式是否错误、语法是否错误、字节码是否合规。
符号引用验证：Class 文件在其常量池中会通过字符串记录自己将要使用的其他类或者方法，检查它们是否存在。

比如下面这个使用 javap 命令看到的字节码中对的常量池，方法在引用的时候，都会到常量池中查表翻译，找到对应的类或者方法去执行。所以这里验证的主要是这些方法或者类是否存在，如果不存在就会报类或者方法找不到（ClassNotFoundExcaption、MethodNotFoundException）。这也属于安全校验的一部分。

以上就是验证的部分，下面我们看一下第三阶段。

3.3 准备

在这里插入图片描述

准备阶段，也属于连接的一部分，主要是为类变量分配内存，并设置类变量初始值。那什么是类变量呢？类变量，也称静态变量，就是类中被 static 修饰的变量。

准备阶段分为三种情况：

static 修饰的变量，分配空间的时候在当前的准备阶段完成（设置默认值），真正赋值的时候在初始化阶段才会完成。

例如：下图中的 b 变量，在当前准备阶段，它只会赋一个默认值，由于 b 是 int 类型，那么默认值是 0。真正把 b 赋值为 10 的时候是在初始化阶段才会完成。
static 修饰的变量是 final 的基本类型（int、long等），或者字符串常量，这个时候值已经是确定的，所以在准备阶段就完成了赋值的操作。

例如：下图中的 c、d 变量，它们是被 static 和 final 同时修饰的基本类型，这种情况就会在准备阶段直接完成赋值。
static 修饰的变量是 final 的引用类型（Object等），那么赋值也会在初始化阶段完成。

例如：下图中的 obj 变量，它是被 static 和 final 同时修饰的 Object，这种情况并不会在当前准备阶段去赋值，而是和没有被 final 修饰的基本类型一样，也是在初始化阶段完成赋值。

以上就是准备阶段所需要完成的事了，下面我们再来看一下第四阶段。

3.4 解析

在这里插入图片描述

解析阶段，也属于连接的一部分，主要是把类中的符号引用转换为直接引用。

什么是符号引用？什么是直接引用呢？
比如：方法中调用了其他方法，方法名可以理解为符号引用，而直接引用就是使用指针直接指向方法。我们还是使用之前 javap 解析出来的字节码为例：

在这里插入图片描述

左边是 main() 方法的执行指令，右边是常量池，执行的时候我们需要到常量池中查表翻译，这里就会找到当前某一个方法（Methodref 表示方法定义），#4 会引用 #24 和 # 25：

可以看到 #24 是一个 Class，#25 是 NameAndType，其中 #24 还引用了 #31，#25 还引用了 #32 和 #33。

其实当前的 #1、#2、……、#33 就是 符号引用，我们真正要去执行的就是根据符号引用找到对应的类，并且找到这个类中对应的方法。如果是直接找到了对应的类或方法的话，就是 直接引用。

这个就是解析阶段所要完成的事了，下面我们看一下初始化阶段。

3.5 初始化

在这里插入图片描述

初始化阶段，主要是对类的静态变量，静态代码块执行初始化操作。这里面有两项要求：

如果初始化一个类的时候，其父类尚未初始化，则优先初始化其父类。
如果同时包含多个静态变量或静态代码块，则按照自上而下的顺序依次执行。

下面我们来演示一下，代码如下：

public class Application {

    public static void main(String[] args) {
        // 1.首次访问这个类的静态变量或静态方法时
        System.out.println(Animal.num);
        // 2.子类初始化，如果父类还没初始化，会引发父类先初始化
//        System.out.println(Cat.sex);
        // 3.子类访问父类静态变量，只触发父类初始化
//        System.out.println(Cat.num);
    }
}

class Animal {
    static int num = 55;
    static {
        System.out.println("Animal 静态代码块...");
    }
}

class Cat extends Animal {
    static boolean sex = false;
    static {
        System.out.printf("Cat 静态代码块...1");
    }

    static {
        System.out.printf("Cat 静态代码块...2");
    }
}