JVM类加载机制

谁践踏了优雅 2021-11-29 13:48 469阅读 0赞

### JVM类加载机制 ###

*  概述
 *  类加载的时机
 *  类的加载
 *  类的验证
 *   *  文件格式验证
     *  元数据验证
     *  字节码验证
     *  符号引用验证
 *  类的准备
 *  类的解析
 *  类的初始化
 *  类加载器
 *   *  双亲委派模型
 *  总结

类加载这里单看《深入理解JVM》感觉有很多不清楚的地方，只有一个模模糊糊的大致感觉，无法形成一个整体而系统的认识。找了点资料，学习了一下，下面是整理的笔记。

内容整理自：  
[https://www.bilibili.com/video/av47756459][https_www.bilibili.com_video_av47756459]  
《深入理解JVM》

# 概述 #

Java源码经过编译后就变成了.class文件（字节码），在字节码中描述的各种信息最终都需要加载到虚拟机中之后才能运行和使用。JVM如何加载这些.class文件？而这些.class文件中的信息进入到JVM中会发生什么变化？

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

在Java代码中，**类型**的加载、连接与初始化过程都是在**程序运行期间**完成的。  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Rhcmxpbmd3b29kMjAxMw_size_16_color_FFFFFF_t_70][]  
上图展示的是**类的生命周期**，对其简单描述如下：

*  类型的加载：最常见的情景就是，将已经编译好的class文件从**磁盘**上加载到**内存**里。
 *  连接：将类与类的关系确立好，并且完成字节码相关的处理。  
    字节码文件是可能被修改的。
 *  初始化：对类型里的静态变态赋初始值。

**类的加载、连接与初始化**

*  加载：查找并加载类的二进制数据
 *  连接  
    – 验证：确保被加载的类的正确性  
    – 准备：为类的**静态变量**分配内存，并将其初始化为**默认值**  
    – 解析：把类中的符号引用转换为直接引用
 *  初始化：为类的静态变量赋予正确的初始值

对于下面这段代码，静态变量a经过准备阶段后，值为0；经过初始化阶段后，值为1。

class Test {
        
    	public static int a = 1;
    }

**类的使用与卸载**

*  使用：指程序去使用这个类，例如用这个类去创建对象，调用类的相关方法。
 *  卸载：类加载的时候，把类加载到内存中了，卸载就是把类从内存中销毁，类一旦卸载完后，就不能使用这个类再去创建对象。

Java虚拟机本身是一个进程。在如下几种情况下，JVM将结束生命周期：

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

# 类加载的时机 #

类从被加载到JVM内存中开始，到卸载出内存位置，其整个生命周期包括：加载、验证、准备、解析、初始化、使用和卸载7个阶段。其中验证、准备、解析3个阶段统称为连接。

其中，加载、验证、准备、初始化和卸载这5个阶段的顺序是确定的，类的加载过程必须按照这种顺序按部就班的开始。但解析阶段在某些情况下可以在初始化阶段之后再开始，这是为了支持Java语言的运行时绑定。（为什么）  
这些阶段通常是互相交叉地混合式进行的，通常会在一个阶段执行过程中调用、激活另外一个阶段。

JVM规范中并没有进行强制约束什么情况下需要开始类加载过程的第一个阶段，即加载。但是对于初始化阶段严格规定了：

> 所有JVM实现必须在每个类或接口被Java程序“**首次主动使用**”时才初始化他们。

**Java程序对类的使用方式可分为两种**

*  主动使用
 *  被动使用

**主动使用（七种）**

*  创建类的实例
 *  访问某个类或接口的静态变量（getstatic），或者对该静态变量赋值（putstatic）
 *  调用类的静态方法（invokestatic）
 *  反射（如Class.forName(“com.test.Test”)）
 *  初始化一个类的子类
 *  JVM启动时被标明为启动类的类（即包含main方法的类）
 *  JDK1.7开始提供的动态语言支持：  
    java.lang.invoke.MethodHandle实例的解析结果REF\_getStatic，REF\_putStatic，REF\_invokeStatic句柄对应的类没有初始化，则初始化

除了以上七种情况，其他使用Java类的方式都被看作是对类的**被动使用**，都不会导致类的**初始化**。

**下面演示几中关于主动使用和被动使用的例子：**

**例1**：输出"MyParent1 static block" “hello world”，即父类被初始化了。  
解释：  
**对静态字段来说，只有直接定义了该字段的类才会被初始化。**  
通过子类的名字调用父类的静态变量，并没有主动使用子类，所以子类的静态代码块没有被初始化和执行。

public class MyTest1 {
        
    	public static void main(String[] args) {
        
    		System.out.println(MyChild1.str);
    		// 输出
    		// MyParent1 static block
    		// hello world
    	}
    }
    
    class MyParent1 {
        
    	public static String str = "hello world";
    	static {
        
    		System.out.println("MyParent1 static block");
    	}
    }
    
    class MyChild1 extends MyParent1 {
        
    	static {
        
    		System.out.println("MyChild static block");
    	}
    }

在上面的代码执行中，虽然没有对子类进行初始化，但子类已经被加载了。可以通过设置虚拟机参数：-XX:+TraceClassLoading，打印类加载信息，可以看到子类被加载了。

**例2**：输出"MyParent1 static block" “MyChild static block” “welcome”，即父类、子类都被初始化了。  
解释：  
**当一个类在初始化时，要求其父类全部已经初始化完毕。**  
下例访问子类的静态变量，对子类来说是主动使用，对其父类来说也是主动使用，所以父类会初始化。

public class MyTest1 {
        
    	public static void main(String[] args) {
        
    		System.out.println(MyChild1.str2);
    		// 输出
    		// MyParent1 static block
    		// MyChild static block
    		// welcome
    	}
    }
    
    class MyParent1 {
        
    	public static String str = "hello world";
    	static {
        
    		System.out.println("MyParent1 static block");
    	}
    }
    
    class MyChild1 extends MyParent1 {
        
    	public static String str2 = "welcome;
    	static {
        
    		System.out.println("MyChild static block");
    	}
    }

**例3**：运行如下程序，只输出了"hello world"，而没有初始化MyParent2。  
解释：  
final关键字表示常量，即被其修饰的字段一旦被赋值就不能被改变了。在下面代码中，str是一个常量，常量在编译阶段会被存入调用该常量的方法所在类的常量池中（即**str被放在MyTest2的常量池中**），本质上，调用类并没有引用到定义常量的类，因此定义该常量的类的初始化不会被触发。

public class MyTest2 {
        
    	public static void main(String[] args) {
        
    		System.out.println(MyParent2.str);
    		// 输出
    		// hello world
    	}
    }
    
    class MyParent2 {
        
    	public static final String str = "hello world";
    	static {
        
    		System.out.println("MyParent2 static block");
    	}
    }

关于助记符的扩展：  
![20190722144008304.png][]  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Rhcmxpbmd3b29kMjAxMw_size_16_color_FFFFFF_t_70 1][]  
**例4**：**输出“MyParent3 static block”** 以及一个随机生成的字符串。  
解释：  
当一个常量的值**并非编译期间可以确定的**，那么其值就**不会被放到调用类的常量池中**。  
这时在程序运行时，会导致主动使用这个常量所在的类，显然会导致这个类被初始化。

public class MyTest3 {
        
    	public static void main(String[] args) {
        
    		System.out.println(MyParent3.str);
    	}
    }
    
    class MyParent3 {
        
    	public static final String str = UUID.randomUUID().toString();
    	static {
        
    		System.out.println("MyParent3 static block");
    	}
    }

**例5**：输出“MyParent4 static block”  
解释：  
创建类的实例就会主动使用这个类，而这里是**首次主动使用**，所以这个类被初始化。  
PS：如果再new一个MyParent4只会在第一次new的时候输出“MyParent4 static block”。

public class MyTest4 {
        
    	public static void main(String[] args) {
        
    		MyParent4 myParent4 = new MyParent4();
    	}
    }
    
    class MyParent4 {
        
    	static {
        
    		System.out.println("MyParent4 static block");
    	}
    }

**例6**：不会输出"MyParent4 static block"  
![20190722151239894.png][]  
解释：  
没有主动使用MyParent4类，所以它不会初始化。  
对于数组实例来说，其类型是**由JVM在运行期动态生成的**。动态生成的类型，其父类型就是Object。  
对于数组来说，JavaDoc经常将构成数组的元素称为Component，实际上就是将数组降低一个维度后的类型。

public class MyTest4 {
        
    	public static void main(String[] args) {
        
    		MyParent4[] myParent4s = new MyParent4[1];
    		System.out.println(myParent4s.getClass());
    		
    		MyParent4[][] myParent4s1 = new MyParent4[1][1];
    		System.out.println(myParent4s1.getClass());
    		
    		System.out.println(myParent4s.getClass().getSuperclass());
    		System.out.println(myParent4s1.getClass().getSuperclass());
    	
    		int[] ints = new int[1];
    		System.out.println(ints.getClass());
    		System.out.println(ints.getClass().getSuperclass());
    		
    	}
    }
    
    class MyParent4 {
        
    	static {
        
    		System.out.println("MyParent4 static block");
    	}
    }

关于助记符的扩展：  
![20190722151807695.png][]

# 类的加载 #

类的加载的最终产品：**位于内存中的Class对象**。

*  Class对象**封装了类在方法区内的数据结构**，并且向Java程序员提供了访问方法区内的数据结构的接口。

类的加载指的是将类的.class文件中的二进制数据**读入到内存**中，将其放在运行时数据区的**方法区**内（规范没说放哪，只是HotSpot将它放在方法区），然后在内存中创建一个**java.lang.Class对象**用来封装类在方法区内的数据结构。

**加载.class文件的方式：**

*  从本地系统中直接加载
 *  通过网络下载.class文件
 *  从zip,jar等归档文件中加载.class文件
 *  从专有数据库中提取.class文件
 *  **将Java源文件动态编译为.class文件 （动态代理、JSP文件）**

**有两种类型的类加载器**：

*  JVM自带的加载器  
    – 根类加载器（Bootstrap）  
    – 扩展类加载器（Extension）  
    – 系统（应用）类加载器（System）
 *  用户自定义的类加载器  
    – java.lang.ClassLoader的子类  
    – 用户可以定制类的加载方式

**关于类加载的时机：**  
类加载器并**不需要等到某个类被“首次主动使用”时再加载它**。

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

类被加载后，就进入连接阶段。连接阶段就是将已经读入到内存的类的二进制数据合并到JVM的运行时环境中去。

# 类的验证 #

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

**类的验证内容：**

*  文件格式验证（类文件的结构检查）
 *  元数据验证（语义分析）
 *  字节码验证（对类的方法体校验分析）
 *  符号引用验证
 *

## 文件格式验证 ##

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

**这阶段是基于二进制字节流进行：**

*  通过这个阶段验证后，字节码才会进入内存的方法区中进行存储。
 *  后面3个验证阶段全部是**基于方法区的存储结构**进行的。

## 元数据验证 ##

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

## 字节码验证 ##

此阶段目的：通过数据流和控制流分析，确定程序语义是合法的、符合逻辑的。  
在元数据验证中对元数据信息中的数据类型做完校验后，此阶段对**类的方法体**进行校验分析，保证被校验类的方法在运行时不会做出危害JVM安全的事件。

## 符号引用验证 ##

此阶段目的：确保解析动作能正常执行。

这个阶段的校验发生在JVM将符号引用转化为直接引用的时候（即解析阶段）。符号引用验证可以看做是**对类自身以外（常量池中的各种符号引用）的信息**进行匹配性校验。

# 类的准备 #

在准备阶段，JVM为**类的静态变量分配内存**，并**设置默认的初始值**。

*  这个时候进行内存分配的**仅包括静态变量**，不包括实例变量。实例变量将会在**对象实例化**时随着对象一起分配在Java堆中。
 *  这里所说的初始值一般情况下指数据类型的**零值**。
 *  如果该静态变量被**final修饰**（具有ConstantValue属性），那在准备阶段**直接初始化为ConstantValue指定的值**。

# 类的解析 #

解析阶段是JVM将**常量池内**的**符号引用**替换为**直接引用**的过程。

**符号引用和直接引用**

*  符号引用以一组符号描述所引用的目标。  
    – 符号可以是任何形式的字面量，只要使用时能**无歧义地定位到目标**即可。  
    – 符号引用**与JVM实现的内存布局无关**，引用的目标并**不一定已经加载到内存中**。
 *  直接引用可以是**指向目标的指针、相对偏移量或是一个能间接定位到目标的句柄**。  
    – 直接引用是和**JVM实现的内存布局相关的**，同一个符号引用在不同虚拟机实例上翻译出来的直接引用一般不会相同。  
    – 如果有了直接引用，那引用目标**必定已经在内存中存在**。

解析动作主要针对**类或接口、字段、类方法、接口方法、方法类型、方法句柄和调用点限定符**7类符号引用进行。

# 类的初始化 #

在初始化阶段，JVM执行类的初始化语句，为类的静态变量赋予初始值。在程序中，**静态变量的初始化有两种途径**：

1.  在**静态变量的声明处**进行初始化
2.  在**静态代码块中**进行初始化

在以下代码中，静态变量a和b被显示初始化，而静态变量c没有被显示初始化，c将保持默认值0。

public class Sample {
        
    	private static int a = 1; // 在静态变量的声明处进行初始化
    	public static long b; 
    	public static long c;
    
    	static {
        
    		b = 2; // 在静态代码块中进行初始化
    	}
    }

静态变量的声明语句，以及静态代码块都被看做类的初始化语句，JVM会按照初始化语句在类文件中的先后顺序来依次执行他们。  
例如在以下Sample类被初始化后，其静态变量a的取值为4。

public class Sample {
        
    	static int a = 1;
    	static {
         a = 2; }
    	static {
         a = 2; }
    	public static void main(String args[]) {
        
    		System.out.println("a=", a);
    	}
    }

**类的初始化步骤**

*  假如这个类还没有被加载和连接，那就先进行加载和连接。
 *  假如类存在直接父亲，并且这个父亲还没有被初始化，那就先初始化直接父类。
 *  假如类中存在初始化语句，那就依次执行这些初始化语句。

**类的初始化时机**

所有JVM实现必须在每个类或接口被Java程序“**首次主动使用**”时才初始化他们。

**主动使用：**

除了以上七种情况，其他使用Java类的方式都被看作是对类的**被动使用**，都不会导致类的**初始化**。

**接口的初始化**

当JVM初始化一个类时，**要求它的所有父类都已经被初始化**，但是这条规则并不适用于接口。

*  在初始化一个类时，并不会先初始化它所实现的接口。
 *  在初始化一个接口时，并不会先初始化它的父接口。

因此，**一个父接口并不会因为它的子接口或者实现类的初始化而初始化**。只有当程序**首次使用特定接口的静态变量时**，才会导致该接口的初始化。

只有当程序访问的静态变量或静态方法确实在当前类或当前接口中定义时，才可以认为是对类或接口的主动使用。

调用ClassLoader类的loadClass方法加载一个类，并不是对类的主动使用，不会导致类的初始化。

**一个理解类加载顺序、初始化顺序的例子：**

public class MyTest6 {
        
    	public static void main(String[] args) {
        
    		Singleton singleton = Singleton.getInstance();
    		System.out.println("counter1:" + Singleton.counter1);
    		System.out.println("counter2:" + Singleton.counter2);
    	}
    }
    
    class Singleton {
        
    	public static int counter1;
    	private static Singleton singleton = new Singleton();
    	private Singleton() {
        
    		counter1++;
    		counter2++; //准备阶段的重要意义
    		System.out.println(counter1);
    		System.out.println(counter2);
    	}
    	public static int counter2 = 0;
    	public static Singleton getInstance() {
        
    		return singleton;
    	}
    }

程序输出：

1
    1
    counter1:1
    counter2:0

解释：  
在main方法中调用Singleton类的静态方法，导致Singleton类被初始化。  
Singleton类先被加载，在准备阶段为类变量分配内存并设置初始值，所以经过准备阶段以后各个类变量初始值如下：

counter1: 0
    singleton: null
    counter2: 0

初始化阶段需要根据程序员写的代码去对类变量赋值，经过初始化阶段后各类变量值如下：

counter1: 1
    singleton: Singleton实例
    counter2: 0

在new Singleton实例时，私有构造方法会执行，counter1的自增操作使用的是counter1初始化之后的值，也就是0；counter2的自增操作使用的是counter2准备阶段之后的值，也就是0（这个时候counter2还没有初始化）。所以在私有构造方法内部可以看到，counter1和counter2都变成了1。  
接着对counter2进行初始化，赋值为0。所以main中看到的counter2是0。

# 类加载器 #

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

**类在JVM中的唯一性**

*  对于任意一个类，都需要由**加载它的类加载器**和**这个类本身**一同确立其在JVM中的唯一性。
 *  每一个类加载器都有一个**独立的类名称空间**。
 *  要比较两个类是否“相等”，只有在这两个类是由**同一个类加载器加载的前提下**才有意义。
 *  这里所说的“相等”包括equals()方法、isAssignableFrom()方法、isInstance()方法的返回结果。

## 双亲委派模型 ##

双亲委派模型要求除了顶层的启动类加载器外，其余的类加载器都应当有自己的父类加载器。  
这里的类加载器之间的父子关系一般**不会以继承关系实现**，而都是**使用组合关系**来复用父加载器的代码。

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

**双亲委派模型的优点：**

*  Java类随着它的类加载器一起举杯了一种带有优先级的层次关系。  
    – 例如类java.lang.Object，它存放在tr.jar中，无论哪一个类加载器要加载这个类，最终都是委派给处于模型最顶端的启动类加载器进行加载，因此Object类在程序的各种类加载器环境中都是同一个类。
 *  对于保证Java程序的稳定运作很重要。

# 总结 #

**加载**：就是把二进制形式的java类型读入JVM中

**验证**  
**准备**：为类变量分配内存，设置默认值，但是在到达初始化之前，类变量都没有初始化为真正的初始值。  
**解析**：解析过程就是在类型的常量池中寻找类、接口、字段和方法的符号引用，把这些符号引用替换成直接引用的过程。

**初始化**：为类变量赋予正确的初始值。

**类实例化**：  
为新的对象分配内存  
为实例变量赋默认值  
为实例变量赋正确的初始值  
java编译器为它编译的每一个类都至少生成一个实例初始化方法，在java的class文件中，这个实例初始方法被称为“< init >”，针对源代码中每一个类的构造方法，java编译器都产生一个< init >方法。

[https_www.bilibili.com_video_av47756459]: https://www.bilibili.com/video/av47756459
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Rhcmxpbmd3b29kMjAxMw_size_16_color_FFFFFF_t_70]: /images/20211129/a2ad99b651f744a1a1dc885c9625d594.png
[20190722144008304.png]: /images/20211129/07eec14c92104b2dabd9853ecd6599a0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Rhcmxpbmd3b29kMjAxMw_size_16_color_FFFFFF_t_70 1]: /images/20211129/9c21f066ed134fb593a6e8448d3724a8.png
[20190722151239894.png]: /images/20211129/6bbc1ba4a75a4157849adc12677e7803.png
[20190722151807695.png]: /images/20211129/8d6f7ffef2314afda620f4c59bd6a923.png