Java类加载过程

一、类加载子系统概述

1、图解

英文结构图

中文结构图

2、类加载器子系统作用

• 类加载器子系统负责从文件系统或者网络中加载Class文件，Class文件在文件开头有特定的文件标识。
• ClassLoader只负责Class文件的加载，至于它是否可以运行，则由Execution Engine决定。
• 加载的类信息存放于一块称为方法区的内存空间。除了类的信息外，方法区中还会存放运行时常量池信息，可能还包括字符串字面量和数字常量（这部分常量信息是Class文件中常量池部分的内存映射）。

字节码文件（Class File）存在于本地硬盘上，可以当成一个模板，而最终这个模板在执行的时候是要加载到JVM中，根据这个文件实例化N个一模一样的实例。
Class File加载到JVM中，被称为DNA元数据模板，放在方法区。
在.class文件 -> JVM -> 最终成为元数据模板，此过程就要一个运输工具（类装载器Class Loader），扮演一个快递员的角色。

二、类加载过程

1、概述

public class HelloLoader {
    public static void main(String[] args) {
        System.out.println("加载~~~");
    }
}

类加载过程：一个类型从被加载到虚拟机内存中开始，到卸载出内存为止，它的整个生命周期将会经历加载 （Loading）、验证（Verification）、准备（Preparation）、解析（Resolution）、初始化 （Initialization）、使用（Using）和卸载（Unloading）七个阶段，其中验证、准备、解析三个部分统称为连接（Linking）

上述代码加载过程如下图：

原理：当Java程序需要使用某个类时，JVM会确保这个类已经被加载、 连接（验证、准备和解析）和初始化。类的加载是指把类的.class文件中的数据读入到内存中，通常是创建一个字节数组读入.class文件，然后产生与所加载类对应的Class对象。加载完成后，Class对象还不完整，所以此时的类还不可用。当类被加载后就进入连接阶段，这一阶段包括验证、准备（为静态变量分配内存并设置默认的初始值）和解析（将符号引用替换为直接引用）三个步骤。最后JVM对类进行初始化。如果类存在直接的父类并且这个类还没有被初始化，那么就先初始化父类；如果类中存在初始化语句，就依次执行这些初始化语句。

2、加载阶段（Loading）

加载阶段完成的事情：

1、通过一个类的全限定名获取定义此类的二进制字节流。

2、将这个字节流所代表的静态存储结构转化为方法区的运行时数据结构。

3、在内存中生成一个代表这个类的java.lang.Class对象，作为方法区这个类的各种数据访问的入口。

加载class文件的方式：

• 从本地系统中直接加载
• 通过网络获取，典型场景：Web Applet
• 从zip压缩包中读取，成为日后jar、war格式的基础
• 运行时计算生成，使用最多的是：动态代理技术
• 由其他文件生成，典型场景：JSP应用从专有数据库中提取.class文件，比较少见
• 从加密文件中获取，典型的防Class文件被反编译的保护措施

3、链接阶段的验证（Verify）

验证（Verify）：

• 目的在于确保Class文件的字节流中包含信息符合当前虚拟机要求，保证被加载类的正确性，不会危害虚拟机自身安全。如果出现不合法的字节码文件，那么将会验证不通过
• 主要包括四种验证，文件格式验证，元数据验证，字节码验证，符号引用验证。

查看字节码工具：

• 下载并安装Binary Viewer查看
• 安装IDEA的插件jclass，安装完成后，我们编译完一个class文件后，点击view中Show Bytecode With Jclasslib即可使用安装的插件来查看字节码方法了

4、链接阶段的准备（Prepare）

准备（Prepare）：

为类变量分配内存并设置该类变量的默认初始值，即零值（根据变量的类型设置默认值）。
这里不包含用final修饰的static，因为final在编译的时候就会分配了，准备阶段会显式初始化。
这里不会为实例变量（及方法中的变量）分配初始化，类变量会分配在方法区中，而实例变量是会随着对象一起分配到Java堆中。

public class HelloLoader {
    //在准备阶段给类变量a赋初始值a=0，到初始化阶段才为a=1
    private static int a = 1;

    public static void main(String[] args) {
        System.out.println(a);
    }
}

5、链接阶段的解析（Resolve）

解析（Resolve）：

• 将常量池内的符号引用转换为直接引用的过程。
• 事实上，解析操作往往会伴随着JVM在执行完初始化之后再执行。
• 符号引用就是一组符号来描述所引用的目标。符号引用的字面量形式明确定义在Class文件格式中。直接引用就是直接指向目标的指针、相对偏移量或一个间接定位到目标的句柄。
• 解析动作主要针对类或接口、字段、类方法、接口方法、方法类型等。对应常量池中的CONSTANT_Class_info、CONSTANT_Fieldref_info、CONSTANT_Methodref_info等。

6、初始化阶段（Initialization）

• 初始化阶段就是执行类构造器方法<clinit>()的过程。
• 此方法不需定义，是javac编译器自动收集类中的所有类变量的赋值动作和静态代码块中的语句合并而来
• 构造器方法中指令按语句在源文件中出现的顺序执行。
• <clinit>()不同于类的构造器。（关联：构造器是虚拟机视角下的<init>()）。
• 若该类具有父类，JVM会保证子类的<clinit>()执行前，父类的<clinit>()已经执行完毕。
• 虚拟机必须保证一个类的<clinit>()方法在多线程下被同步加锁。

注意：以下几种情况不会执行类初始化：

• 通过子类引用父类的静态字段，只会触发父类的初始化，而不会触发子类的初始化。
• 定义对象数组，不会触发该类的初始化。
• 常量在编译期间会存入调用类的常量池中，本质上并没有直接引用定义常量的类，不会触发定义常量所在的类。
• 通过类名获取Class对象，不会触发类的初始化。
• 通过Class.forName加载指定类时，如果指定参数initialize为false时，也不会触发类初始化，其实这个参数是告诉虚拟机，是否要对类进行初始化。
• 通过ClassLoader默认的loadClass方法，也不会触发初始化动作。

public class ClassInitTest {
    private static int num = 1;

    static {
        num = 2;
        number = 20;
        System.out.println(num);//2
        System.out.println(number);//报错，非法的前向引用
    }

    //在链接阶段的准备时，number=0，到初始化阶段为20，因为先执行静态代码块，最后又为10
    private static int number = 10;

    public static void main(String[] args) {
        System.out.println(ClassInitTest.num);//2
        System.out.println(ClassInitTest.number);//10
    }
}

注：如果一个类中没有对静态变量赋值也没有静态语句块，那么编译器可以不为这个类生成<client>()方法

涉及到父类时候的变量赋值过程

public class ClinitTest1 {
    static class Father {
        public static int A = 1;
        static {
            A = 2;
        }
    }

    static class Son extends Father {
        public static int b = A;
    }

    public static void main(String[] args) {
        System.out.println(Son.b);//2
    }
}

上述代码结果为 2，也就是说首先加载ClinitTest1的时候，会找到main方法，然后执行Son的初始化，但是Son继承了Father，因此还需要执行Father的初始化，同时将A赋值为2。我们通过反编译得到Father的加载过程，首先我们看到原来的值被赋值成1，然后又被赋值成2，最后返回

涉及到多个线程时候的变量赋值过程

public class DeadThreadTest {
    public static void main(String[] args) {
        new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "\t 线程t1开始");
            new DeadThread();
        }, "t1").start();

        new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "\t 线程t2开始");
            new DeadThread();
        }, "t2").start();
    }
}

class DeadThread {
    static {
        if (true) {
            System.out.println(Thread.currentThread().getName() + "\t 初始化当前类");
            while (true) {

            }
        }
    }
}

/**
 * 运行结果
 * t1	 线程t1开始
 * t1	 初始化当前类
 * t2	 线程t2开始
 * 从上面可以看出初始化后，只能够执行一次初始化，这也就是同步加锁的过程
 */

三、类加载器

1、分类

JVM支持两种类型的类加载器 。分别为引导类加载器（Bootstrap ClassLoader）和自定义类加载器（User-Defined ClassLoader）。
从概念上来讲，自定义类加载器一般指的是程序中由开发人员自定义的一类类加载器，但是Java虚拟机规范却没有这么定义，而是将所有派生于抽象类ClassLoader的类加载器都划分为自定义类加载器。
无论类加载器的类型如何划分，在程序中我们最常见的类加载器始终只有3个，如下所示：

这里的四者之间是包含关系，不是上层和下层，也不是子系统的继承关系。

public class ClassLoaderTest {
    public static void main(String[] args) {
        //获取系统类加载器
        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
        System.out.println(systemClassLoader);//sun.misc.Launcher$AppClassLoader@18b4aac2

        //获取其上层：扩展类加载器
        ClassLoader extClassLoader = systemClassLoader.getParent();
        System.out.println(extClassLoader);//sun.misc.Launcher$ExtClassLoader@1b6d3586

        //获取其上层：获取不到引导类加载器
        ClassLoader bootstrapClassLoader = extClassLoader.getParent();
        System.out.println(bootstrapClassLoader);//null

        //对于用户自定义类来说：默认使用系统类加载器进行加载
        ClassLoader classLoader = ClassLoaderTest.class.getClassLoader();
        System.out.println(classLoader);//sun.misc.Launcher$AppClassLoader@18b4aac2

        //String类使用引导类加载器进行加载的，Java的核心类库都是使用引导类加载器进行加载的
        ClassLoader classLoader1 = String.class.getClassLoader();
        System.out.println(classLoader1);//null
    }
}

说明：从结果可以看出引导类加载器无法直接通过代码获取，同时目前用户代码所使用的加载器为系统类加载器。同时通过获取String类型的加载器，发现是null，那么说明String类型是通过引导类加载器进行加载的，也就是说Java的核心类库都是使用引导类加载器进行加载的。

2、启动类加载器（引导类加载器，Bootstrap ClassLoader）

• 这个类加载器使用C/C++语言实现的，嵌套在JVM内部。
• 用来加载Java的核心库（JAVA_HOME/jre/lib/rt.jar、resources.jar或sun.boot.class.path路径下的内容），用于提供JVM自身需要的类。
• 并不继承自java.lang.ClassLoader，没有父加载器。
• 加载扩展类和应用程序类加载器，并指定为他们的父类加载器。
• 出于安全考虑，Bootstrap启动类加载器只加载包名为java、javax、sun等开头的类。

3、扩展类加载器（Extension ClassLoader）

• Java语言编写，由sun.misc.Launcher$ExtClassLoader实现。
• 派生于ClassLoader类。
• 父类加载器为启动类加载器。
• 从java.ext.dirs系统属性所指定的目录中加载类库，或从JDK的安装目录的jre/lib/ext子目录（扩展目录）下加载类库。如果用户创建的JAR放在此目录下，也会自动由扩展类加载器加载。

4、应用程序类加载器（系统类加载器，AppClassLoader）

• java语言编写，由sun.misc.LaunchersAppClassLoader实现。
• 派生于ClassLoader类。
• 父类加载器为扩展类加载器。
• 它负责加载环境变量classpath或系统属性java.class.path指定路径下的类库。
• 该类加载是程序中默认的类加载器，一般来说，Java应用的类都是由它来完成加载。
• 通过classLoader.getSystemclassLoader()方法可以获取到该类加载器。

/**
 * 查看加载器所能够加载的目录
 */
public class ClassLoaderTest1 {
    public static void main(String[] args) {
        System.out.println("********************启动类加载器********************");
        //获取BootstrapClassLoader能够加载的api路径
        URL[] urLs = Launcher.getBootstrapClassPath().getURLs();
        for (URL url : urLs) {
            System.out.println(url);
        }
        //从上面路径中随便找一个类，获取它的加载器，得到的是null，说明是引导类加载器
        ClassLoader classLoader = Provider.class.getClassLoader();
        System.out.println(classLoader);
        System.out.println("********************扩展类加载器********************");
        String extDirs = System.getProperty("java.ext.dirs");
        for (String path : extDirs.split(";")) {
            System.out.println(path);
        }
        //从上面路径中随便找一个类，获取它的加载器，得到的是sun.misc.Launcher$ExtClassLoader@4b67cf4d，说明是扩展类加载器
        ClassLoader classLoader1 = CurveDB.class.getClassLoader();
        System.out.println(classLoader1);
    }
}
/**
 * 运行结果
 */
********************启动类加载器********************
file:/D:/program/JDK/jre/lib/resources.jar
file:/D:/program/JDK/jre/lib/rt.jar
file:/D:/program/JDK/jre/lib/sunrsasign.jar
file:/D:/program/JDK/jre/lib/jsse.jar
file:/D:/program/JDK/jre/lib/jce.jar
file:/D:/program/JDK/jre/lib/charsets.jar
file:/D:/program/JDK/jre/lib/jfr.jar
file:/D:/program/JDK/jre/classes
null
********************扩展类加载器********************
D:\program\JDK\jre\lib\ext
C:\WINDOWS\Sun\Java\lib\ext
sun.misc.Launcher$ExtClassLoader@4b67cf4d

5、用户自定义类加载器

在Java的日常应用程序开发中，类的加载几乎是由上述3种类加载器相互配合执行的，在必要时，我们还可以自定义类加载器，来定制类的加载方式。

为什么要自定义类加载器？

• 隔离加载类
• 修改类加载的方式
• 扩展加载源
• 防止源码泄漏

用户自定义类加载器实现步骤：

• 可以通过继承抽象类java.lang.ClassLoader类的方式，实现自己的类加载器，以满足一些特殊的需求。
• 在JDK1.2之前，在自定义类加载器时，总会去继承ClassLoader类并重写loadClass()方法，从而实现自定义的类加载类，但是在JDK1.2之后已不再建议用户去覆盖loadClass()方法，而是建议把自定义的类加载逻辑写在findClass()方法中。
• 在编写自定义类加载器时，如果没有太过于复杂的需求，可以直接继承URLClassLoader类，这样就可以避免自己去编写findClass()方法及其获取字节码流的方式，使自定义类加载器编写更加简洁。

6、ClassLoader介绍

ClassLoader类，它是一个抽象类，其后所有的类加载器都继承自ClassLoader（不包括启动类加载器）
常见的方法：

法名称	描述
getParent()	返回该类加载器的父类加载器
loadClass(String name)	加载名称为name的类，返回结果为java.lang.Class类的实例
findClass(String name)	查找名称为name的类，返回结果为java.lang.Class类的实例
findLoadedClass(String name)	加载名称为name的已经被加载过的类，返回结果为java.lang.Class类的实例
defineClass(String name, byte[] b, int off, int len)	把字节数组b中的内容转换为一个Java类，返回结果为java.lang.Class类的实例
resolveClass(Class<?> c)	连接指定的一个Java类

获取ClassLoader的途径：

• 获取当前类的ClassLoader：clazz.getClassLoader()
• 获取当前线程上下文的ClassLoader：Thread.currentThread().getContextClassLoader()
• 获取系统的ClassLoader：ClassLoader.getSystemClassLoader()
• 获取调用者的ClassLoader：DriverManager.getCallerClassLoader()

四、双亲委派机制

1、概述

Java虚拟机对class文件采用的是按需加载的方式，也就是说当需要使用该类时才会将它的class文件加载到内存生成class对象。而且加载某个类的class文件时，Java虚拟机采用的是双亲委派模式，即把请求交由父类处理，它是一种任务委派模式。

2、工作原理

如果一个类加载器收到了类加载请求，它并不会自己先去加载，而是把这个请求委托给父类的加载器去执行；
如果父类加载器还存在其父类加载器，则进一步向上委托，依次递归，请求最终将到达顶层的启动类加载器；
如果父类加载器可以完成类加载任务，就成功返回，倘若父类加载器无法完成此加载任务，子加载器才会尝试自己去加载，这就是双亲委派模式。

3、双亲委派机制举例

当加载jdbc.jar用于实现数据库连接的时候，首先我们需要知道的是jdbc.jar是基于SPI接口进行实现的，所以在加载的时候，会进行双亲委派，最终从根加载器中加载SPI核心类，然后在加载SPI接口类，接着在进行反向委派，通过线程上下文类加载器进行实现类jdbc.jar的加载。

4、沙箱安全机制

自定义String类，但是在加载自定义String类的时候会率先使用引导类加载器加载，而引导类加载器在加载的过程中会先加载jdk自带的文件（rt.jar包中java\lang\String.class），报错信息说没有main方法，就是因为加载的是rt.jar包中的String类。这样可以保证对java核心源代码的保护，这就是沙箱安全机制。

5、双亲委派机制优势

• 避免类的重复加载
• 保护程序安全，防止核心API被随意篡改
  • 自定义类：java.lang.String
  • 自定义类：java.lang.ShkStart（报错：阻止创建 java.lang开头的类）

public class String {
    //错误: 在类 java.lang.String 中找不到 main 方法
    public static void main(String[] args) {
        System.out.println("自定义String");
    }
}

public class ShkStart {
    //java.lang.SecurityException: Prohibited package name: java.lang
    public static void main(String[] args) {
        System.out.println("自定义");
    }
}

五、其他

1、如何判断两个class对象是否相同

在JVM中表示两个Class对象是否为同一个类存在两个必要条件：

• 类的完整类名必须一致，包括包名。
• 加载这个类的ClassLoader（指ClassLoader实例对象）必须相同。

换句话说，在JvM中，即使这两个类对象（Class对象）来源同一个Class文件，被同一个虚拟机所加载，但只要加载它们的ClassLoader实例对象不同，那么这两个类对象也是不相等的。
JVM必须知道一个类型是由启动加载器加载的还是由用户类加载器加载的。如果一个类型是由用户类加载器加载的，那么JVM会将这个类加载器的一个引用作为类型信息的一部分保存在方法区中。当解析一个类型到另一个类型的引用的时候，JVM需要保证这两个类型的类加载器是相同的。

2、类的主动使用和被动使用

Java程序对类的使用方式分为：王动使用和被动使用。
主动使用，又分为七种情况：

• 创建类的实例
• 访问某个类或接口的静态变量，或者对该静态变量赋值
• 调用类的静态方法
• 反射（比如：Class.forName(“com.itan.Test”)）
• 初始化一个类的子类
• Java虚拟机启动时被标明为启动类的类
• JDK7开始提供的动态语言支持：java.lang.invoke.MethodHandle实例的解析结果REF_getStatic、REF_putStatic、REF_invokeStatic句柄对应的类没有初始化，则初始化

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

---

类加载过程详细说明

一、前言

在Java中数据类型分为基本数据类型和引用数据类型。基本数据类型由虚拟机预先定义，引用数据类型则需要进行类的加载。

二、加载阶段（Loading）

1、对加载的理解

1、加载（Loading）阶段是整个类加载（Class Loading）过程中的一个阶段。
2、加载就是将Java类的字节码文件加载到机器内存中，并在内存中构建出Java类的原型——类模板对象。
3、类模板对象其实就是Java类在JVM内存中的一个快照，JVM将从字节码文件中解析出的常量池、类字段、类方法等信息存储到模板中，这样JVM在运行期便能通过类模板而获取Java类中的任意信息，能够对Java类的成员变量进行遍历，也能进行Java方法的调用。
4、反射机制即基于这一阶段实现，如果JVM没有将Java类的声明信息存储起来，则JVM在运行期也无法反射。
5、加载阶段完成的事情：
通过一个类的全限定名获取定义此类的二进制字节流。
将这个字节流所代表的静态存储结构转化为方法区的运行时数据结构（Java类模型）。
在内存中生成一个代表这个类的java.lang.Class对象，作为方法区这个类的各种数据访问的入口。

2、二进制流获取方式

1、对于类的二进制数据流，虚拟机可以通过多种途径产生或获得。(只要所读取的字节码符合JVM规范即可)

• 虚拟机可能通过文件系统读入一个class后缀的文件（最常见）
• 读入jar、zip等归档数据包，提取类文件
• 事先存放在数据库中的类的二进制数据
• 使用类似于HTTP之类的协议通过网络进行加载
• 在运行时生成一段Class的二进制信息等

2、获取到类的二进制信息后，Java虚拟机就会处理这些数据，并最终转为一个java.lang.Class的实例
3、如果输入数据不是ClassFile的结构，则会抛出ClassFormatError

3、类模型与Class实例的位置

1、类模型的位置：加载的类在JVM中创建相应的类结构，类结构会存储在方法区（JDK 1.8之前在永久代；JDK1.8之后在元空间）。
2、Class实例的位置：类将.class文件加载至元空间后，会在堆中创建一个java.lang.Class对象，用来封装类位于方法区内的数据结构，该Class对象是在加载类的过程中创建的，每个类都对应有一个Class类型的对象。图示：外部可以通过访问代表Order类的Class对象来获取Order的类数据结构

3、注意：Class类的构造方法是私有的，只有JVM能够创建。
4、java.lang.Class实例是访问类型元数据的接口，也是实现反射的关键数据、入口。通过Class类提供的接口，可以获得目标类所关联的.class文件中具体的数据结构（方法、字段等信息）。

4、数组类的加载

1、创建数组类的情况稍微有些特殊，因为数组类本身并不是由类加载器负责创建，而是由JVM在运行时根据需要而直接创建的，但数组的元素类型仍然需要依靠类加载器去创建。创建数组类的过程：

• 如果数组的元素类型是引用类型，那么就遵循定义的加载过程递归加载和创建数组的元素类型。
• JVM使用指定的元素类型和数组维度来创建新的数组类。

2、如果数组的元素类型是引用类型，数组类的可访问性就由元素类型的可访问性决定。否则数组类的可访问性将被缺省定义为public。

三、链接阶段（Linking）

1、验证阶段（Verification）

1、当类加载到系统后，就开始链接操作，验证是链接操作的第一步。它的目的是保证加载的字节码是合法、合理并符合规范的。验证的步骤比较复杂，实际要验证的项目也很繁多，大体上Java虚拟机需要做以下检查，如图所示：

2、整体说明：验证的内容则涵盖了类数据信息的格式验证、语义检查、字节码验证，以及符号引用验证等

• 其中格式验证会和加载阶段一起执行。验证通过之后，类加载器才会成功将类的二进制数据信息加载到方法区中。
• 格式验证之外的验证操作将会在方法区中进行。

3、链接阶段的验证虽然拖慢了加载速度，但是它避免了在字节码运行时还需要进行各种检查。

2、验证的具体说明

1、格式检查：是否以魔数0xCAFEBABE开头，主版本和副版本号是否在当前Java虚拟机的支持范围内，数据中每一个项是否都拥有正确的长度等。
2、语义检查：Java虚拟机会进行字节码的语义检查，但凡在语义上不符合规范的，虚拟机也不会给予验证通过

• 是否所有的类都有父类的存在（在Java里，除了Object外，其他类都应该有父类）。
• 是否一些被定义为final的方法或者类被重写或继承了。
• 非抽象类是否实现了所有抽象方法或者接口方法。
• 是否存在不兼容的方法（比如方法的签名除了返回值不同，其他都一样，这种方法会让虚拟机无从下手调度；abstract情况下的方法，就不能是final的了）

3、字节码验证：它也是验证过程中最为复杂的一个过程。它试图通过对字节码流的分析，判断字节码是否可以被正确地执行

• 在字节码的执行过程中，是否会跳转到一条不存在的指令。
• 函数的调用是否传递了正确类型的参数。
• 变量的赋值是不是给了正确的数据类型等。
• 补充：栈映射帧（StackMapTable）就是在这个阶段，用于检测在特定的字节码处，其局部变量表和操作数栈是否有着正确的数据类型。但遗憾的是，100%准确地判断一段字节码是否可以被安全执行是无法实现的，因此，该过程只是尽可能地检查出可以预知的明显的问题。如果在这个阶段无法通过检查，虚拟机也不会正确装载这个类。但是，如果通过了这个阶段的检查，也不能说明这个类是完全没有问题的。

4、符号引用验证：Class文件在其常量池会通过字符串记录自己将要使用的其他类或者方法。因此，在验证阶段，虚拟机就会检查这些类或者方法确实是存在的，并且当前类有权限访问这些数据，如果一个需要使用类无法在系统中找到，则会抛出NoClassDefFoundError，如果一个方法无法被找到，则会抛出NoSuchMethdError，此阶段在解析环节才会执行。

3、准备阶段（Preparation）

1、准备阶段（Preparation）为类的静态变量分配内存，并将其初始化为默认值。
2、当一个类验证通过时，虚拟机就会进入准备阶段。在这个阶段，虚拟机就会为这个类分配相应的内存空间，并设置默认初始值。Java虚拟机为各类型变量默认的初始值如下所示：

3、注意：

• Java并不支持boolean类型，对于boolean类型，内部实现是int，由于int的默认值是0，故对应的，boolean的默认值就是false。
• 这里不包含基本数据类型的字段用static final修饰的情况，因为final在编译的时候就会分配了，准备阶段会显式赋值。
• 注意这里不会为实例变量分配初始化，类变量会分配在方法区中，而实例变量是会随着对象一起分配到 Java堆中。
• 在这个阶段不会像初始化阶段中那样会有初始化或者代码被执行。

4、解析阶段（Resolution）

1、在准备阶段完成后，就进入了解析阶段。解析阶段（Resolution），将类、接口、字段和方法的符号引用转为直接引用。
2、符号引用：就是一些字面量的引用，和虚拟机的内部数据结构和内存分布无关。就是在Class类文件中，通过常量池进行了大量的符号引用。但是在程序实际运行时，只有符号引用是不够的，比如当如下println()方法被调用时，系统需要明确知道该方法的位置。
Java虚拟机为每个类都准备了一张方法表，将其所有的方法都列在表中，当需要调用一个类的方法的时候，只要知道这个方法在方法表中的偏移量就可以直接调用该方法。通过解析操作，符号引用就可以转变为目标方法在类中方法表中的位置，从而使得方法被成功调用。

3、总结：

• 解析就是将符号引用转为直接引用，也就是得到类、字段、方法在内存中的指针或者偏移量。因此，可以说，如果直接引用存在，那么可以肯定系统中存在该类、方法或者字段。但只存在符号引用，不能确定系统中一定存在该结构。
• 不过Java虚拟机规范并没有明确要求解析阶段一定要按照顺序执行。在HotSpot VM中，加载、验证、准备和初始化会按照顺序有条不紊地执行，但链接阶段中的解析操作往往会伴随着JVM在执行完初始化之后再执行。

四、初始化阶段（Initialization）

1、概述

1、初始化阶段为类的静态变量赋予正确的初始值（显式赋值）。
2、类的初始化是类装载的最后一个阶段。如果前面的步骤都没有问题，那么表示类可以顺利装载到系统中。此时，类才会开始执行Java字节码。（即：到了初始化阶段，才真正开始执行类中定义的Java程序代码）
3、初始化阶段的重要工作是执行类的初始化方法：<clinit>()方法
该方法仅能由Java编译器生成并由JVM调用，程序开发者无法自定义一个同名的方法，更无法直接在Java程序中调用该方法，该方法也是由字节码指令所组成。
它是类静态成员的赋值语句以及static语句块合并产生的。

4、在加载一个类之前，虚拟机总是会试图加载该类的父类，因此父类的<clinit>总是在子类<clinit>之前被调用，也就是说，父类的static块优先级高于子类。由父及子，静态先行（静态先执行）。
5、Java编译器并不会为所有的类都产生<clinit>()初始化方法。以下情况类在编译为字节码后，字节码文件中将不会包含<clinit>()方法。

• 一个类中并没有声明任何的类变量，也没有静态代码块时。
• 一个类中声明类变量，但是没有明确使用类变量的初始化语句以及静态代码块来执行初始化操作时。
• 一个类中包含static final修饰的基本数据类型的字段，这些类字段初始化语句采用编译时常量表达式。
   

/**
 * @Date: 2021/12/22
 * 验证那些场景下，java编译器不会生成<clinit>()方法
 * 通过jclasslib查看字节码中的方法，发现没有<clinit>()方法
 */
public class InitializationTest1 {
    //场景1：对非静态的字段，不管是否进行了显示赋值，都不会生成<clinit>()方法
    public int num;

    public int num1 = 1;

    //场景2：静态的字段，没有显式的赋值，不会生成<clinit>()方法
    public static int num2;

    //场景3：声明为static final的基本数据类型的字段，不管是否进行了显示赋值，都不会生成<clinit>()方法
    public static final int num3 = 1;
}

2、static与final搭配的问题

/**
 * @Date: 2021/12/30
 * 使用static + final修饰的字段的显式赋值的操作，到底是在哪个阶段进行的赋值？
 * 情况1：在链接阶段的准备环节赋值
 * 情况2：在初始化阶段<clinit>()中赋值
 */
public class InitializationTest2 {
    public static int a = 1;//在初始化阶段<clinit>()中赋值
    public static final int b = 10;//在链接阶段的准备环节赋值

    public static final Integer c = Integer.valueOf(100);//在初始化阶段<clinit>()中赋值
    public static Integer d = Integer.valueOf(1000);//在初始化阶段<clinit>()中赋值

    public static final String e = "hello1";//在链接阶段的准备环节赋值
    public static final String f = new String("hello2");//在初始化阶段<clinit>()中赋值

    public static String g = "hello3";//在初始化阶段<clinit>()中赋值

    public static final int h = new Random().nextInt(10);//在初始化阶段<clinit>()中赋值
}

1、通过jclasslib查看字节码

2、在链接阶段的准备环节赋值的情况说明：

• 对于基本数据类型的字段来说，如果使用static final来修饰，则显示赋值（直接赋值常量情况，而非调用方法）通常是在链接阶段的准备环节进行的。
• 对于String来说，如果使用字面量的方式赋值，并且使用了static final修饰，则显示赋值通常是在链接阶段的准备环节进行的。

3、在初始化阶段<clinit>()中赋值的情况：
排除上面的在准备环节赋值的情况之外的情况。
4、最终结论：使用static + final修饰，且显式赋值中不涉及到方法或构造器调用的基本数据类型或String类型的显式赋值，是在链接阶段的准备环节进行的；其他的情况都是在初始化阶段<clinit>()中赋值。

3、clinit方法的线程安全性

1、对于<clinit>() 方法的调用，也就是类的初始化，虚拟机会在内部确保其多线程环境中的安全性
2、虚拟机会保证一个类的<clinit>()方法在多线程环境中被正确地加锁、同步，如果多个线程同时去初始化一个类，那么只会有一个线程去执行这个类的<clinit>()方法，其他线程都需要阻塞等待，直到活动线程执行<clinit>()方法完毕。
3、正是因为函数<clinit>()带锁线程安全的，因此，如果一个在类的<clinit>()方法中有耗时很长的操作，就可能造成多个线程阻塞，引发死锁。并且这种死锁是很难发现的，因为看起来它们并没有可用的锁信息。
4、如果之前的线程成功加载了类，则等在队列中的线程就没有机会再执行<clinit>()方法了。那么，当需要使用这个类时，虚拟机会直接返回给它已经准备好的信息。
 

/**
 * @Date: 2021/12/31
 * 出现死锁问题
 */
public class StaticDeadLockTest extends Thread {
    private char flag;

    public StaticDeadLockTest(char flag) {
        this.flag = flag;
        this.setName("Thread" + flag);
    }

    @Override
    public void run() {
        try {
            Class.forName("com.itan.middle.day3.Static" + flag);
        } catch (ClassNotFoundException e) {

        }
        System.out.println(getName() + "over");
    }

    public static void main(String[] args) {
        StaticDeadLockTest loadA = new StaticDeadLockTest('A');
        loadA.start();
        StaticDeadLockTest loadB = new StaticDeadLockTest('B');
        loadB.start();
    }
}

class StaticA {
    static {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {

        }
        try {
            Class.forName("com.itan.middle.day3.StaticB");
        } catch (ClassNotFoundException e) {

        }
        System.out.println("StaticA init ok");
    }
}

class StaticB {
    static {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {

        }
        try {
            Class.forName("com.itan.middle.day3.StaticA");
        } catch (ClassNotFoundException e) {

        }
        System.out.println("StaticB init ok");
    }
}

4、类的主动使用

1、Java程序对类的使用分为两种：主动使用（会调用类的<clinit>()方法，执行了类的初始化阶段）和被动使用。

2、Class只有在必须要首次使用的时候才会被装载，Java虚拟机不会无条件的装载Class类型。Java虚拟机规定，一个类或者接口在初次使用前，必须要进行初始化。这里指的是“使用”，是指主动使用，主动使用只有以下几种情况（即：如果出现以下的情况，则会对类进行初始化操作，而初始化操作之前的加载、验证、准备已经完成）。

• 当创建一个类的实例时，使用new关键字、或者反射、克隆、反序列化。
• 当调用类的静态方法时，也就是使用了字节码指令invokestatic 。
• 当使用类、接口的静态字段时（final修饰特殊考虑），比如，使用字节码指令getstatic或putstatic（访问变量、赋值变量的操作）。
• 当使用java.lang.reflect包中的方法反射类的方法时。比如：Class.forname(“com.itan.java.Test1”)。
• 当初始化子类时，如果发现其父类还没有进行过初始化，则需要先触发其父类的初始化。
• 如果一个接口定义了default方法，那么直接实现或者间接实现该接口的类的初始化，该接口要在其之前被初始化。
• 当虚拟机启动时，用户需要指定一个要执行的主类（包含main()方法的那个类），虚拟机会先初始化这个主类。
• 当初次调用MethodHandle实例时，初始化该MethodHandle指向的方法所在的类。（涉及解析REF_getStatic、REF_putStatic、REF_invokeStatic方法句柄对应的类）。

/**
 * @Date: 2021/12/31
 * 测试类的主动使用：即会调用类的<clinit>()方法，执行了类的初始化阶段
 * 1. 当创建一个类的实例时，使用new关键字、或者反射、克隆、反序列化。
 * 2. 当调用类的静态方法时，也就是使用了字节码指令invokestatic 。
 */
public class ActiveUse1 {
    public static void main(String[] args) throws InterruptedException {
        //执行此代码之后会打印出Order init，通过字节码查看，Order类中生成了<clinit>()方法
        Order order = new Order();
    }

    //序列化的过程，通过序列化生成一个文件，便于反序列化测试
    @Test
    public void test1() {
        ObjectOutputStream oss = null;
        try {
            oss = new ObjectOutputStream(new FileOutputStream("order.dat"));
            oss.writeObject(new Order());
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (oss != null) {
                    oss.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    
    //反序列化的过程，也打印出Order init
    @Test
    public void test2() {
        ObjectInputStream ois = null;
        try {
            ois = new ObjectInputStream(new FileInputStream("order.dat"));
            Order order = (Order) ois.readObject();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            try {
                if (ois != null) {
                    ois.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 针对第二点测试类的主动使用
     */
    @Test
    public void test3() {
        Order.method1();
    }
}

class Order implements Serializable {
    static {
        System.out.println("Order init");
    }

    public static void method1() {
        System.out.println("Order static method()");
    }
}

/**
 * @Date: 2021/12/31
 * 测试类的主动使用：即会调用类的<clinit>()方法，执行了类的初始化阶段
 * 3. 当使用类、接口的静态字段时（final修饰特殊考虑），比如，使用字节码指令getstatic或putstatic（访问变量、赋值变量的操作）。
 */
public class ActiveUse2 {
    @Test
    public void test1() {
        // System.out.println(User.num1);//会输出User init
        // System.out.println(User.num2);//不会输出User init
        System.out.println(User.num3);//会输出User init
    }

    @Test
    public void test2() {
        // System.out.println(InterfaceA.num1);//不会输出interfaceA init
        System.out.println(InterfaceA.num2);//会输出interfaceA init
    }
}

class User {
    //静态字段，有显式的赋值，因此会调用类的<clinit>()方法
    public static int num1 = 1;
    //final修饰，且直接赋值常量，因此不会调用类的<clinit>()方法
    public static final int num2 = 1;
    //final修饰，但是后面的赋值涉及到方法的调用，因此会调用类的<clinit>()方法
    public static final int num3 = new Random().nextInt(10);

    static {
        System.out.println("User init");
    }
}

interface InterfaceA {
    //static final修饰的实例，因为是通过调用方法进行赋值，会生成<clinit>()方法，因此只要输出了InterfaceA init就表示执行了类的初始化
    public static final Object t = new Object() {
        //构造代码块
        {
            System.out.println("InterfaceA init");
        }
    };
    //final修饰，且直接赋值常量，因此不会调用类的<clinit>()方法；
    public static final int num1 = 1;
    //final修饰，但是后面的赋值涉及到方法的调用，因此会调用类的<clinit>()方法；
    public static final int num2 = new Random().nextInt(10);
}

/**
 * @Date: 2021/12/31
 * 测试类的主动使用：即会调用类的<clinit>()方法，执行了类的初始化阶段
 * 4. 当使用java.lang.reflect包中的方法反射类的方法时。比如：Class.forname("com.itan.java.Test1")。
 * 5. 当初始化子类时，如果发现其父类还没有进行过初始化，则需要先触发其父类的初始化。
 * 针对5的补充说明：
 * 当Java虚拟机初始化一个类时，要求它的所有父类都已经被初始化，但是这条规则并不适用于接口
 * - 在初始化一个类时，并不会先初始化它所实现的接口
 * - 在初始化一个接口时，并不会先初始化它的父接口
 * - 因此，一个父接口并不会因为它的子接口或者实现类的初始化而初始化，只有当程序首次使用特定接口的静态字段时，才会导致该接口的初始化
 */
public class ActiveUse3 {
    @Test
    public void test1() throws ClassNotFoundException {
        //会输出Order init
        Class clazz = Class.forName("com.itan.middle.day4.Order");
    }

    @Test
    public void test2() {
        //Son.num会触发Son类的初始化，不过在初始化之前会触发Father类的初始化
        System.out.println(Son.num);//输出Father init和Son init
    }

    @Test
    public void test3() {
        /**
         * Father类实现了接口，但是在初始化Father类时，并没有输出InterfaceB init，
         * 因此说明：在初始化一个类时，并不会先初始化它所实现的接口
         */
        System.out.println(Father.num);
    }

    @Test
    public void test4() {
        /**
         * InterfaceC继承了InterfaceB接口，但是在初始化InterfaceC时，并没有输出InterfaceB init，
         * 因此说明：在初始化一个接口时，并不会先初始化它的父接口
         */
        System.out.println(InterfaceC.num);
    }
}

class Father {
    static {
        System.out.println("Father init");
    }

    public static int num = 1;
}

class Son extends Father {
    static {
        System.out.println("Son init");
    }

    public static int num = 2;
}

interface InterfaceB {
    public static final Object t = new Object() {
        //构造代码块
        {
            System.out.println("InterfaceB init");
        }
    };
}

interface InterfaceC extends InterfaceB {
    public static final Object t = new Object() {
        //构造代码块
        {
            System.out.println("InterfaceC init");
        }
    };

    public static final int num = new Random().nextInt(10);
}

/**
 * @Date: 2021/12/31
 * 测试类的主动使用：即会调用类的<clinit>()方法，执行了类的初始化阶段
 * 6. 如果一个接口定义了default方法，那么直接实现或者间接实现该接口的类的初始化，该接口要在其之前被初始化。
 * 7. 当虚拟机启动时，用户需要指定一个要执行的主类（包含main()方法的那个类），虚拟机会先初始化这个主类。
 * 针对7的补充说明：
 * - JVM启动的时候通过引导类加载器加载一个初始类。这个类在调用main方法之前被链接和初始化。这个方法的执行将依次导致所需的类的加载、链接和初始化
 */
public class ActiveUse4 {
    static {
        System.out.println("ActiveUse4 init");
    }
    @Test
    public void test1() {
        /**
         * Father1实现了InterfaceB1接口，InterfaceB1接口中有一个默认的方法，因此Father1初始化时会导致接口也初始化
         * 因此证明：如果一个接口定义了default方法，那么直接实现或者间接实现该接口的类的初始化，该接口要在其之前被初始化。
         */
        System.out.println(Father1.num);
    }

    public static void main(String[] args) {
        /**
         * 会输出ActiveUse4 init
         * 因此证明：当虚拟机启动时，指定一个要执行的主类（包含main()方法的那个类），虚拟机会先初始化这个主类。
         */
        System.out.println("main");
    }
}

class Father1 implements InterfaceB1 {
    static {
        System.out.println("Father init");
    }

    public static int num = 1;
}

interface InterfaceB1 {
    public final static Object t = new Object() {
        //构造代码块
        {
            System.out.println("InterfaceB1 init");
        }
    };

    public default void method() {
        System.out.println("Interface default method");
    }
}

5、类的被动使用

1、除了以上的情况属于主动使用，其他的情况均属于被动使用。被动使用不会引起类的初始化，也不会调用<clinit>()方法，也就是说：并不是在代码中出现的类，就一定会被加载或者初始化。如果不符合主动使用的条件，类就不会初始化。
2、几种情况：

• 当访问一个静态字段时，只有真正声明这个字段的类才会被初始化。即当通过子类引用父类的静态变量，不会导致子类初始化。
• 通过数组定义类引用，不会触发此类的初始化。
• 引用常量不会触发此类或接口的初始化。因为常量在链接阶段就已经被显式赋值了
• 调用ClassLoader类的loadClass()方法加载一个类，并不是对类的主动使用，不会导致类的初始化

/**
 * @Date: 2022/1/2
 * 测试类的被动使用：即不会调用类的<clinit>()方法，不会执行类的初始化阶段
 * 1. 当访问一个静态字段时，只有真正声明这个字段的类才会被初始化，当通过子类引用父类的静态变量，不会导致子类初始化。
 * 2. 通过数组定义类引用，不会触发此类的初始化。
 *    Parent[] parents = new Parent[10]; //不会触发Parent类的初始化，但会加载Parent类
 *    parents[0] = new Parent();  //给数组元素赋值时，才会初始化
 */
public class PassiveUse1 {
    @Test
    public void test1() {
        //通过子类引用父类的静态变量，不会导致子类被加载，因此不会输出Child init
        System.out.println(Child.num);
    }

    @Test
    public void test2() {
        //通过数组定义类引用，不会触发此类的初始化，但是会加载Parent类，因此不会输出Parent init
        Parent[] parents = new Parent[10];
    }

    @Test
    public void test3() {
        Parent[] parents = new Parent[10];
        //给数组元素赋值时，才会初始化，因此会输出Parent init
        parents[0] = new Parent();
        //不会再次输出Parent init，因为<clinit>()方法只会被执行一次
        parents[1] = new Parent();
    }
}

class Parent {
    static {
        System.out.println("Parent init");
    }

    public static int num = 1;
}

class Child extends Parent {
    static {
        System.out.println("Child init");
    }
}

/**
 * @Date: 2022/1/2
 * 测试类的被动使用：即不会调用类的<clinit>()方法，不会执行类的初始化阶段
 * 3. 引用常量不会触发此类或接口的初始化。因为常量在链接阶段的准备环节就已经被显式赋值了
 * 4. 调用ClassLoader类的loadClass()方法加载一个类，并不是对类的主动使用，不会导致类的初始化
 */
public class PassiveUse2 {
    @Test
    public void test1() {
        //不会输出Parent1 init
        System.out.println(Parent1.num);
    }

    @Test
    public void test2() {
        //不会输出Parent1 init
        System.out.println(InterfaceC1.num);
    }

    @Test
    public void test3() throws ClassNotFoundException {
        /**
         * 不会输出Parent1 init
         * 因此证明：调用ClassLoader类的loadClass()方法加载一个类，并不是对类的主动使用，不会导致类的初始化
         */
        Class clazz = ClassLoader.getSystemClassLoader().loadClass("com.itan.middle.day4.Parent1");
    }
}

class Parent1 {
    static {
        System.out.println("Parent1 init");
    }

    public static final int num = 1;//在链接阶段的准备环节就被赋值为1了
}

interface InterfaceC1 {
    public final static Object t = new Object() {
        //构造代码块
        {
            System.out.println("InterfaceC1 init");
        }
    };

    public static final int num = 1;//在链接阶段的准备环节就被赋值为1了
}

五、类的使用与卸载阶段

1、类的使用（Using）

1、任何一个类型在使用之前都必须经历过完整的加载、链接和初始化3个类加载步骤。一旦一个类型成功经历过这3个步骤之后，便“万事俱备，只欠东风”，就等着使用了。
2、我们就可以在程序中访问和调用它的静态类成员信息（比如：静态字段、静态方法），或者使用new关键字为其创建对象实例。

2、必要说明

1、类、类的加载器、类的实例之间的引用关系

• 在类加载器的内部实现中，用一个Java集合来存放所加载类的引用。另一方面，一个Class对象总是会引用它的类加载器，调用Class对象的getClassLoader()方法，就能获得它的类加载器。由此可见，代表某个类的Class实例与其类的加载器之间为双向关联关系。
• 一个类的实例总是引用代表这个类的Class对象。在Object类中定义了getClass()方法，这个方法返回代表对象所属类的Class对象的引用。此外，所有的Java类都有一个静态属性Class，它引用代表这个类的Class对象。

2、类的生命周期

• 当Sample类被加载、链接和初始化后，它的生命周期就开始了。当代表Sample类的Class对象不再被引用，即不可触及时，Class对象就会结束生命周期，Sample类在方法区内的数据也会被卸载，从而结束Sample类的生命周期。
• 一个类何时结束生命周期，取决于代表它的Class对象何时结束生命周期。

3、具体示例

• loader1变量和obj变量间接引用代表Sample类的Class对象，而objClass变量则直接引用它。
• 如果程序运行过程中，将左侧三个引用变量都置为null，此时Sample对象结束生命周期，MyClassLoader对象结束生命周期，代表Sample类的Class对象也结束生命周期，Sample类在方法区内的二进制数据被卸载。
• 当再次有需要时，会检查Sample类的Class对象是否存在，如果存在会直接使用，不再重新加载；如果不存在Sample类会被重新加载，在Java虚拟机的堆区会生成一个新的代表Sample类的Class实例（可以通过哈希码查看是否是同一个实例）。

3、类的卸载（Unloading）

• 1、启动类加载器加载的类型在整个运行期间是不可能被卸载的（JVM和JSL规范）。
• 2、被系统类加载器和扩展类加载器加载的类型在运行期间不太可能被卸载，因为系统类加载器实例或者扩展类的实例基本上在整个运行期间总能直接或者间接的访问的到，其达到unreachable的可能性极小。
• 3、自定义的类加载器实例加载的类型只有在很简单的上下文环境中才能被卸载，而且一般还要借助于强制调用虚拟机的垃圾收集功能才可以做到。可以预想，稍微复杂点的应用场景（比如：很多时候用户在开发自定义类的加载器实例的时候采用缓存的策略以提高系统性能），被加载的类型在运行期间也是几乎不太可能被卸载的（至少卸载的时间是不确定的）。
• 4、综合以上三点，一个已经加载的类型被卸载的几率很小至少被卸载的时间是不确定的。同时我们可以看的出来，开发者在开发代码时候，不应该以虚拟机的类型卸载为前提，去实现系统中的特定功能。