Welcome to Hexo! This is your very first post. Check documentation for more info. If you get any problems when using Hexo, you can find the answer in troubleshooting or you can ask me on GitHub.

Quick Start

Create a new post

1
2

$ hexo new "新文章"
# 验证action

More info: Writing

Run server

1

$ hexo server

More info: Server

Generate static files

1

$ hexo generate

More info: Generating

Deploy to remote sites

1

$ hexo deploy

More info: Deployment

思维导图

类加载简述

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

类加载，卸载时机

一个类型从被加载到虚拟机内存中开始，到卸载出内存为止，它的整个生命周期将会经历加载 （Loading）、验证（Verification）、准备（Preparation）、解析（Resolution）、初始化 （Initialization）、使用（Using）和卸载（Unloading）七个阶段，其中验证、准备、解析三个部分统称 为连接（Linking）。
加载、验证、准备、初始化和卸载这五个阶段的顺序是确定的，类型的加载过程必须按照这种顺序按部就班地开始，而解析阶段则不一定,它是一个可选的操作：它在某些情况下可以在初始化阶段之后再开始， 这是为了支持 Java 语言的运行时绑定特性（也称为动态绑定或晚期绑定）。

关于在什么情况下需要开始类加载过程的第一个阶段“加载”，《Java 虚拟机规范》中并没有进行 强制约束，这点可以交给虚拟机的具体实现来自由把握。但是《Java 虚拟机规范 5.5》约定，在发生下列行为时，类或接口将会被初始化(可以称为类的主动引用)：code

1. 在执行下列需要引用类或接口的 Java 虚拟机指令时：new，getstatic，putstatic 或 invokestatic。这些指令通过字段或方法引用来直接或间接地引用其它类。能够生成这四条指令的典型 Java 代码场景有：

• 使用 new 关键字实例化对象的时候。
• 读取或设置一个类型的静态字段（被 final 修饰、已在编译期把结果放入常量池的静态字段除外）的时候。
• 调用一个类型的静态方法的时候。

1. 在调用 java.lang.invoke.MethodHandle 实例时，它的执行结果为通过 Java 虚拟机解析出类型是 2（REF_getStatic）、4（REF_putStatic）、6（REF_invokeStatic）,或者 8 (REF_newInvokeSpecial)的方法句柄。这个方法句柄对应的类没有进行过初始化，则需要先触发其初始化。
2. 在调用 JDK 核心类库中的反射方法时，例如，Class 类或 java.lang.reflect 包，如果类型没有进行过初始化，则需要先触发其初始化。
3. 当初始化类的时候，如果发现其父类还没有进行过初始化，则需要先触发其父类的初始化。
4. 当虚拟机启动时，用户需要指定一个要执行的主类（包含 main()方法的那个类），虚拟机会先初始化这个主类。
5. 当一个接口中定义了 JDK 8 新加入的默认方法（被 default 关键字修饰的接口方法）时，如果有这个接口的实现类发生了初始化，那该接口要在其之前被初始化。

除此之外，所有引用类型的方式都不会触发初始化(不代表不会触发加载操作)，称为被动引用，如

1. 当访问一个静态域时，只有真正声明这个域的类才会被初始化。如：当通过子类引用父类的静态变量，不会导致子类初始化；
2. 通过数组定义类引用，不会触发此类的初始化；
3. 引用常量不会触发此类的初始化，对于加载行为也不会触发（常量在链接阶段就存入调用类的常量池中了）

类的卸载(java 语言规范 12.7)也需要满足一些条件：code

• 该类所有的实例已经被回收
• 加载该类的 ClassLoder 已经被回收
• 该类对应的 java.lang.Class 对象没有任何对方被引用

因此，由 java 虚拟机自带的三种类加载加载的类在虚拟机的整个生命周期中是不会被卸载的，因为引用始终存在，由用户自定义的类加载器所加载的类才可以被卸载。本质上类的卸载就是对方法区进行 gc 的过程。HotSpot 虚拟机提供了-Xnoclassgc 参数进行控制是否回收。

类加载各个阶段

概述:

java 语言规范 12.2

加载

在加载阶段，Java 虚拟机需要完成以下三件事情：

1. 通过一个类的全限定名来获取定义此类的二进制字节流。
   这里并没有指明“二进制字节流”要从一个’.class’文件中获取，准确地说是根本没有指明要从哪里获取、怎样获取。
   通常可以通过如下方式获取类的二进制字节流：
   [1] 从本地系统中直接加载
   [2] 从网络中获取，这种场景最典型的应用就是 Applet。
   [3] 从 zip，jar 等归档文件中加载’.class’文件
   [4] 从专有数据库中读取。
   [5] 运行时计算生成，这种场景使用得最多的就是动态代理技术，在 java.lang.reflect.Proxy 中，就是用了 ProxyGenerator.generateProxyClass 来为特定接口生成形式为“*$Proxy”的代理类的二进制字节流。
   [6] 其他，。。。。。。
   ② 将这个字节流所代表的静态存储结构转化为方法区的运行时数据结构。（在 JDK 8 中 Class 对象会被放在“元空间”）
   ③ 在内存中生成一个代表这个类的 java.lang.Class 对象，作为方法区这个类的各种数据的访问入口。
2. 将这个字节流所代表的静态存储结构转化为方法区的运行时数据结构。
3. 在内存中生成一个代表这个类的 java.lang.Class 对象，作为方法区这个类的各种数据的访问入口，数组类是由 jvm 动态生成的。

可能抛出的异常：

相对于类加载过程的其他阶段，非数组类型的加载阶段（准确地说，是加载阶段中获取类的二进 制字节流的动作）是开发人员可控性最强的阶段。加载阶段既可以使用 Java 虚拟机里内置的引导类加 载器来完成，也可以由用户自定义的类加载器去完成，开发人员通过定义自己的类加载器去控制字节 流的获取方式（重写一个类加载器的 findClass()或 loadClass()方法），实现根据自己的想法来赋予应用 程序获取运行代码的动态性。
对于数组类而言，情况就有所不同，数组类本身不通过类加载器创建，它是由 Java 虚拟机在运行时直接创建的（‘数组’的父类是’Object’）。但数组类与类加载器仍然有很密切的关系，因为数组类的元素类型（Element Type，指的是数组去掉所有维度的类型）最终是要靠类加载器去创建。

加载阶段结束后，Java 虚拟机外部的二进制字节流就按照虚拟机所设定的格式存储在方法区之中 了，方法区中的数据存储格式完全由虚拟机实现自行定义。类型数据妥善安置在方法区之后，会在Java 堆内存中实例化一个 java.lang.Class 类的对象， 这个对象将作为程序访问方法区中的类型数据的外部接口。

https://www.zhihu.com/question/50258991

验证

验证是连接阶段的第一步，这一阶段的目的是确保 Class 文件的字节流中包含的信息符合《Java 虚 拟机规范》的全部约束要求，保证这些信息被当作代码运行后不会危害虚拟机自身的安全 。验证过程可能会导致某些额外的类和接口被加载进来 ，但不会导致它们也需要验证或准备 。此阶段的验证过程可能包含在其他阶段 ，验证大致分为 4 个方面：

1. 文件格式验证
   第一阶段要验证字节流是否符合 Class 文件格式的规范(如魔数校验，版本号校验，字符串编码校验等)，并且能被当前版本的虚拟机处理 。这阶段的验证是基于二进制字节流进行的，只有通过了这个阶段的 验证之后，这段字节流才被允许进入 Java 虚拟机内存的方法区中进行存储，所以后面的三个验证阶段 全部是基于方法区的存储结构上进行的，不会再直接读取、操作字节流了 。
2. 元数据验证
   此阶段对字节码描述的信息进行语义分析，以保证其描述的信息符合《Java 语言规范》的要求，如类是否存在父类、父类是否可以继承等
3. 字节码验证
   此阶段主要目的是通过数据流分析和控制流分析，确定 程序语义是合法的、符合逻辑的。在第二阶段对元数据信息中的数据类型校验完毕以后，这阶段就要对类的方法体（Class 文件中的 Code 属性）进行校验分析，保证被校验类的方法在运行时不会做出危害 虚拟机安全的行为 。
4. 符号引用验证
   此阶段校验行为发生在虚拟机将符号引用转化为直接引用的时候，这个转化动作将在连接的第三阶段——解析阶段中发生。符号引用验证可以看作是对类自身以外（常量池中的各种符号引用）的各类信息进行匹配性校验，通俗来说就是，该类是否缺少或者存在被禁止访问它依赖的某些外部类、方法、字段等资源。符号引用

验证的目的是确保解析动作能正常执行，可能抛出的异常

对于虚拟机的类加载机制来说，验证阶段是一个非常重要的、但不是一定必要（因为对程序运行期没有影响）的阶段。如果所运行的全部代码（包括自己编写的及第三方包中的代码）都已经被反复使用和验证过，那么在实施阶段就可以考虑使用-Xverify：none 参数来关闭大部分的类验证措施，以缩短虚拟机类加载的时间。

准备

准备阶段是正式为类中定义的变量（即静态变量，被 static 修饰的变量）分配内存并设置类变量初始值的阶段，注意这里的初始值是 JVM 默认初始值，是固定的，不是代码中定义时的那个初始值，不过如果是常量值，jvm 会直接置为指定值。 这个阶段不会执行任何的虚拟机字节码指令。code

解析(可选)

解析阶段是 Java 虚拟机将常量池内的符号引用替换为直接引用的过程，即是根据运行时常量池的符号引用来动态决定具体的值的过程。

• 符号引用（Symbolic References）：符号引用以一组符号来描述所引用的目标，符号可以是任何 形式的字面量，只要使用时能无歧义地定位到目标即可。符号引用与虚拟机实现的内存布局无关，引用的目标并不一定是已经加载到虚拟机内存当中的内容。各种虚拟机实现的内存布局可以各不相同， 但是它们能接受的符号引用必须都是一致的，因为符号引用的字面量形式明确定义在《Java 虚拟机规范》的 Class 文件格式中。
• 直接引用（Direct References）：直接引用是可以直接指向目标的指针、相对偏移量或者是一个能间接定位到目标的句柄。直接引用是和虚拟机实现的内存布局直接相关的，同一个符号引用在不同虚拟机实例上翻译出来的直接引用一般不会相同。如果有了直接引用，那引用的目标必定已经在虚拟机的内存中存在。

• 静态解析
• 符号引用就是假如类 A 引用了类 B，加载阶段是静态解析，这时候 B 还没有被放到 JVM 内存中，这时候 A 引用的只是代表 B 的符号，这是符号引用。
• 直接引用就是类 A 在解析阶段发现自己引用了 B，如果这个时候 B 还没被加载。就是直接触发 B 的类加载，之后 B 的符号引用会被替换成实际地址。这被称为直接引用。
• 动态解析
  如果代码使用了多态。B 是一个抽象类或者接口，A 就不能知道究竟要用哪个来替换，只能等到实际发生调动时在进行实际地址的替换。这就是为什么有的解析发生在初始化之后。

  《Java 虚拟机规范》之中并未规定解析阶段发生的具体时间，只要求了在执行 anewarray 、checkcast、getfield、getstatic、instanceof、invokedynamic、invokeinterface、invoke-special、 invokestatic、invokevirtual、ldc、ldc_w、ldc2_w、multianewarray、new、putfield 和 putstatic 这 17 个用于操作符号引用的字节码指令之前，先对它们所使用的符号引用进行解析。所以虚拟机实现可以根据需要来自行判断，到底是在类被加载器加载时就对常量池中的符号引用进行解析，还是等到一个符号引用将要被使用前才去解析它。
  解析动作主要针对类或接口、字段、类方法、接口方法、方法类型、方法句柄和调用点限定符这 7 类符号引用进行，分别对应于常量池的 CONSTANT_Class_info、CONSTANT_Fieldref_info、 CONSTANT_Methodref_info、CONSTANT_InterfaceMethodref_info、 CONSTANT_MethodType_info、CONSTANT_MethodHandle_info、CONSTANT_Dynamic_info 和 CONSTANT_InvokeDynamic_info 8 种常量类型。

  1. 类或接口的解析
     假设当前代码所处的类为 D，如果要把一个从未解析过的符号引用 N 解析为一个类或接口 C 的直接引用，那虚拟机完成整个解析的过程需要包括以下 3 个步骤：

  如果 C 不是一个数组类型，那虚拟机将会把代表 N 的全限定名传递给 D 的类加载器去加载这个 类 C。在加载过程中，由于元数据验证、字节码验证的需要，又可能触发其他相关类的加载动作，例如加载这个类的父类或实现的接口。
  如果 C 是一个数组类型，并且数组的元素类型为对象，也就是 N 的描述符会是类
  似“ [Ljava/lang/Integer”的形式，那将会按照第一点的规则加载数组元素类型。如果 N 的描述符如前面所假设的形式，需要加载的元素类型就是“java.lang.Integer”，接着由虚拟机生成一个代表该数组维度和元素的数组对象。
  如果上面两步没有出现任何异常，那么 C 在虚拟机中实际上已经成为一个有效的类或接口了， 但在解析完成前还要进行符号引用验证，确认 D 是否具备对 C 的访问权限。如果发现不具备访问权限，将抛出 java.lang.IllegalAccessError 异常。 2. 字段解析
  要解析一个未被解析过的字段符号引用，首先将会对字段表内 class_index 项中索引的 CONSTANT_Class_info 符号引用进行解析，也就是字段所属的类或接口的符号引用。如果解析成功完成，那把这个字段所属的类或接口用 C 表示，《Java 虚拟机规范》要求按照如下步骤对 C 进行后续字段的搜索：

  如果 C 本身就包含了简单名称和字段描述符都与目标相匹配的字段，则返回这个字段的直接引用，查找结束。
  否则，如果在 C 中实现了接口，将会按照继承关系从下往上递归搜索各个接口和它的父接口， 如果接口中包含了简单名称和字段描述符都与目标相匹配的字段，则返回这个字段的直接引用，查找结束。
  否则，如果 C 不是 java.lang.Object 的话，将会按照继承关系从下往上递归搜索其父类，如果在父类中包含了简单名称和字段描述符都与目标相匹配的字段，则返回这个字段的直接引用，查找结束。
  否则，查找失败，抛出 java.lang.NoSuchFieldError 异常。
  如果查找过程成功返回了引用，将会对这个字段进行权限验证，如果发现不具备对字段的访问权限，将抛出 java.lang.IllegalAccessError 异常。 3. 方法解析
  方法解析的第一个步骤与字段解析一样，也是需要先解析出方法表的 class_index 项中索引的方法所属的类或接口的符号引用，如果解析成功，那么我们依然用 C 表示这个类，接下来虚拟机将会按照如下步骤进行后续的方法搜索：

  由于 Class 文件格式中类的方法和接口的方法符号引用的常量类型定义是分开的，如果在类的 方法表中发现 class_index 中索引的 C 是个接口的话，那就直接抛出 java.lang.Incomp atibleClassChangeError 异常。
  如果通过了第一步，在类 C 中查找是否有简单名称和描述符都与目标相匹配的方法，如果有则 返回这个方法的直接引用，查找结束。
  否则，在类 C 的父类中递归查找是否有简单名称和描述符都与目标相匹配的方法，如果有则返回这个方法的直接引用，查找结束。
  否则，在类 C 实现的接口列表及它们的父接口之中递归查找是否有简单名称和描述符都与目标相匹配的方法，如果存在匹配的方法，说明类 C 是一个抽象类，这时候查找结束，抛出 java.lang.AbstractMethodError 异常。
  否则，宣告方法查找失败，抛出 java.lang.NoSuchMethodError。
  最后，如果查找过程成功返回了直接引用，将会对这个方法进行权限验证，如果发现不具备对此方法的访问权限，将抛出 java.lang.IllegalAccessError 异常。 4. 接口方法解析
  接口方法也是需要先解析出接口方法表的 class_index 项中索引的方法所属的类或接口的符号引用，如果解析成功，依然用 C 表示这个接口，接下来虚拟机将会按照如下步骤进行后续的接口方法搜索:

  与类的方法解析相反，如果在接口方法表中发现 class_index 中的索引 C 是个类而不是接口，那 么就直接抛出 java.lang.IncompatibleClassChangeError 异常。
  否则，在接口 C 中查找是否有简单名称和描述符都与目标相匹配的方法，如果有则返回这个方法的直接引用，查找结束。
  否则，在接口 C 的父接口中递归查找，直到 java.lang.Object 类（接口方法的查找范围也会包括 Object 类中的方法）为止，看是否有简单名称和描述符都与目标相匹配的方法，如果有则返回这个方法的直接引用，查找结束。
  否则，宣告方法查找失败，抛出 java.lang.NoSuchMethodError 异常。

初始化

初始化阶段是类加载过程的最后一个步骤，之前介绍的几个类加载的动作里，除了在加载阶段用户应用程序可以通过自定义类加载器的方式局部参与外，其余动作都完全由 Java 虚拟机来主导控 制。直到初始化阶段，Java 虚拟机才真正开始执行类中编写的 Java 程序代码，将主导权移交给应用程 序。同一个类加载器下，一个类型只会被初始化一次，初始化（Initialization）对于类或接口来说，就是执行它的初始化方法（__ ）。
关于 ：

• ()方法是由编译器自动收集类中的所有类变量的赋值动作和静态语句块（static{}块）中的语句合并产生的，编译器收集的顺序是由语句在源文件中出现的顺序决定的。
• ()方法与类的构造函数不同，它不需要显式地调用父类构造器，Java 虚拟机会保证在子类的()方法执行前，父类的()方法已经执行完毕。因此在 Java 虚拟机中第一个被执行的()方法的类型肯定是 java.lang.Object。
• ()方法对于类或接口来说并不是必需的，如果一个类中没有静态语句块，也没有对变量的赋值操作，那么编译器可以不为这个类生成()方法。
• 接口中不能使用静态语句块，但仍然有变量初始化的赋值操作，因此接口与类一样都会生成()方法。但接口与类不同的是，执行接口的()方法不需要先执行父接口的()方法，因为只有当父接口中定义的变量被使用时，父接口才会被初始化。此外，接口的实现类在初始化时也一样不会执行接口的()方法。
• Java 虚拟机必须保证一个类的()方法在多线程环境中被正确地加锁同步，如果多个线程同时去初始化一个类，那么只会有其中一个线程去执行这个类的()方法，其他线程都需要阻塞等待，直到活动线程执行完毕()方法。如果在一个类的()方法中有耗时很长的操作，那就可能造成多个线程阻塞，不过在某个线程执行完()后，其他线程都不会再执行()方法。

可能抛出的异常： NoClassDefFoundError，ExceptionInInitializerError ，OutOfMemoryError
关于 java 代码块的执行顺序(同一类加载器命名空间下首次加载)：code
父类静态代码块>子类类静态代码块>父类构造块>父类构造方法>子类构造块>子类构造方法

类加载器与双亲委派机制

类加载器与类

Java 类加载器是用户程序和 JVM 虚拟机之间的桥梁， 用于实现类的加载动作。对于任意一个类，都必须由加载它的类加载器和这个类本身一起共同确立其在 Java 虚拟机中的唯一性，每 一个类加载器，都拥有一个独立的类名称空间。这句话可以表达得更通俗一些：比较两个类是否“相 等”，只有在这两个类是由同一个类加载器加载的前提下才有意义，否则，即使这两个类来源于同一个 Class 文件，被同一个 Java 虚拟机加载，只要加载它们的类加载器不同，那这两个类就必定不相等。 这里所指的“相等”，包括代表类的 Class 对象的 equals()方法、isAssignableFrom()方法、isInstance() 方法的返回结果，也包括了使用 instanceof 关键字做对象所属关系判定等各种情况。
在 jvm 角度来看，只存在两种不同的类加载器：一种是启动类加载器（BootstrapClassLoader），这个类加载器使用 C++语言实现，是虚拟机自身的一部分；另外一种就是其他所有的类加载器，这些类加载器由 Java 语言实现，独立存在于虚拟机外部，并且全都继承自抽象类 java.lang.ClassLoader。站在 Java 开发人员的角度来看，Java 则有着三层类加载器、双亲委派的类加载架构。

命名空间
每个类加载器都有自己的命名空间，命名空间由该加载器及所有父加载器所加载的类组成。
在同一个命名空间中，不会出现类的完整名字（包括类的包名）相同的两个类
在不同的命名空间中，有可能会出现类的完整名字（包括类的包名）相同的两个类
可见性:
a）同一个命名空间内的类是相互可见的。
b）子加载器的命名空间包含所有父加载器的命名空间,因此由子加载器加载的类能看见父加载器加载的类。例如，系统类加载器加载的类能 看见根类加载器加载的类。
c）由父加载器加载的类不能看见子加载器加载的类。
如果两个加载器之间没有直接或间接的父子关系，那么它们各自加载的类相互不可见。

由类加载器不同及是否是数组类型引出的 jvm 三种类生成方式：

三层类加载器与双亲委派

java9 之前的类加载器与双亲委派依赖

• Bootstrap ClassLoader/启动类加载器
  c++实现，位于 jvm 内部，主要负责 jdk_home/lib 目录下的核心 api 或 -Xbootclasspath 选项指定的 jar 包装入工做，如果某个类 xxxClass.getClassLoader()==null，表示该类由启动类加载器加载，如果某个类加载器 xxxClassLoader.getParent()==null,表示该类加载器的父加载器是启动类加载器。
• Extension ClassLoader/扩展类加载器
  这个类加载器是在类 sun.misc.Launcher$ExtClassLoader 中以 Java 代码的形式实现的，主要负责 jdk_home/lib/ext 目录下的 jar 包或 -Djava.ext.dirs 指定目录下的 jar 包装入工做。
• System ClassLoader/应用类加载器
  这个类加载器由 sun.misc.Launcher$AppClassLoader 来实现。 主要负责 java -classpath/-Djava.class.path 所指的目录下的类与 jar 包装入工做。
• User Custom ClassLoader/用户自定义类加载器(java.lang.ClassLoader 的子类)
  用户可以自定义实现类加载器，满足更灵活类加载需求。

上图中类加载器之间的层次关系被称为类加载器的“双亲委派模型（Parents Delegation Model）”。双亲委派模型要求除了顶层的启动类加载器外，其余的类加载器都应有自己的父类加载器，其中父加载器默认由 ClassLoader 类中的 parent 成员变量存储，可以通过构造方法设置。
双亲委派模型的工作过程是：如果一个类加载器收到了类加载的请求，它首先不会自己去尝试加载这个类，而是把这个请求委派给父类加载器去完成，每一个层次的类加载器都是如此，因此所有的加载请求最终都应该传送到最顶层的启动类加载器中，只有当父加载器反馈自己无法完成这个加载请求（它的搜索范围中没有找到所需的类）时，子加载器才会尝试自己去完成加载。
使用双亲委派模型来组织类加载器之间的关系，一个好处就是 Java 中的类随着它的类加载器一起具备了一种带有优先级的层次关系。例如类 java.lang.Object，它存放在 rt.jar 之中，无论哪一个类加载器要加载这个类，最终都是委派给处于模型最顶端的启动类加载器进行加载，因此 Object 类在程序的各种类加载器环境中都能够保证是同一个类。反之，如果没有使用双亲委派模型，都由各个类加载器自行去加载的话，如果用户自己也编写了一个名为 java.lang.Object 的类，并放在程序的 ClassPath 中，那系统中就会出现多个不同的 Object 类，Java 类型体系中最基础的行为也就无从保证，应用程序将会变得一片混乱。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

protected Class<?> loadClass(String name, boolean resolve)throws ClassNotFoundException{
    synchronized (getClassLoadingLock(name)) {
        // 首先检查类是否已加载
        Class<?> c = findLoadedClass(name);
        if (c == null) {
            long t0 = System.nanoTime();
            try {
                ////父加载器不为空，调用父加载器loadClass()方法处理
                if (parent != null) {
                    c = parent.loadClass(name, false);
                } else {
                    //父加载器不为空，调用父加载器loadClass()方法处理
                    c = findBootstrapClassOrNull(name);
                }
            } catch (ClassNotFoundException e) {
                // 抛出此异常表示父类加载器无法找到目标类
            }

            if (c == null) {
                // 父类加载器无法加载，则自身加载
                long t1 = System.nanoTime();
                // 实现自定义类加载器时，一般需要实现findClass方法
                c = findClass(name);

                // this is the defining class loader; record the stats
                sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
                sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
                sun.misc.PerfCounter.getFindClasses().increment();
            }
        }
        if (resolve) {
            resolveClass(c);
        }
        return c;
    }
}

// 其他一些方法
//用于将 byte字节流解析成 JVM 能够识别的 Class 对象。有了这个方法意味着我们不仅可以通过 .class文件实例化对象，还可以通过其他方式实例化对象，例如通过网络接收到一个类的字节码。,一般在重写findClass方法时加载完字节码后再调用defineClass
defineClass()

//通常和 defineClass()一起使用，我们需要直接覆盖 ClassLoader 父类的 findClass()方法来实现类的加载规则，从而取得要加载类的字节码。
findClass()

//用于对 Class 进行 链接，也就是把单一的 Class 加入到有继承关系的类树中。如果你想在类被加载到 JVM 中时就被链接（Link），那么可以在调用 defineClass()之后紧接着调用一个 resolveClass()方法，当然你也可以选择让 JVM 来解决什么时候才链接这个类（通常是真正被实实例化的时候)，默认不调用，代码验证，观察TODO
resolveClass()

//类命名空间
// The classes loaded by this class loader. The only purpose of this table
// is to keep the classes from being GC'ed until the loader is GC'ed.
private final Vector<Class<?>> classes = new Vector<>();
// Invoked by the VM to record every loaded class with this loader.
void addClass(Class<?> c) {
    classes.addElement(c);
}

protected final Class<?> findLoadedClass(String name) {
   if (!checkName(name))
       return null;
   return findLoadedClass0(name);
}

private native final Class<?> findLoadedClass0(String name);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

protected Class<?> findClass(final String name)throws ClassNotFoundException{
    final Class<?> result;
    try {
        result = AccessController.doPrivileged(
            new PrivilegedExceptionAction<Class<?>>() {
                public Class<?> run() throws ClassNotFoundException {
                    String path = name.replace('.', '/').concat(".class");
                    Resource res = ucp.getResource(path, false);
                    if (res != null) {
                        try {
                            return defineClass(name, res);
                        } catch (IOException e) {
                            throw new ClassNotFoundException(name, e);
                        }
                    } else {
                        return null;
                    }
                }
            }, acc);
    } catch (java.security.PrivilegedActionException pae) {
        throw (ClassNotFoundException) pae.getException();
    }
    if (result == null) {
        throw new ClassNotFoundException(name);
    }
    return result;
}

自定义类加载器的一些场景

code

• 隔离加载类。在某些框架内进行中间件与应用的模块隔离，把类加载器到不同的环境。比如，flink 的插件机制 jar 包不会影响到中间件运行时使用的 jar 包。
• 扩展加载源。比如从数据库、网络，甚至是电视机顶盒进行加载。
• 防止源码泄露。Java 代码容易被编译和篡改，可以进行编译加密。那么类加载器也需要自定义，还原加密的字节码。
• 热加载及类的卸载
• …

破坏双亲委派机制的几种场景

双亲委派模型的第一次“被破坏”其实发生在双亲委派模型出现之前——即 JDK 1.2 面世以前的“远古”时代。由于双亲委派模型在 JDK 1.2 之后才被引入，但是类加载器的概念和抽象类 java.lang.ClassLoader 则在 Java 的第一个版本中就已经存在，面对已经存在的用户自定义类加载器的代码，Java 设计者们引入双亲委派模型时不得不做出一些妥协，为了兼容这些已有代码，无法再以技术手段避免 loadClass()被子类覆盖的可能性，只能在 JDK 1.2 之后的 java.lang.ClassLoader 中添加一个新的 protected 方法 findClass()，并引导用户编写的类加载逻辑时尽可能去重写这个方法，而不是在 loadClass()中编写代码。上节我们已经分析过 loadClass()方法，双亲委派的具体逻辑就实现在这里面，按照 loadClass()方法的逻辑，如果父类加载失败，会自动调用自己的 findClass()方法来完成加载，这样既不影响用户按照自己的意愿去加载类，又可以保证新写出来的类加载器是符合双亲委派规则的

线程上下文类加载器

此类加载器可以通过 java.lang.Thread 类的 setContextClassLoader()方 法进行设置，如果创建线程时还未设置，它将会从父线程中继承一个，如果在应用程序的全局范围内 都没有设置过的话，那这个类加载器默认就是应用程序类加载器 AppClassLoader。 为了实现 SPI 等双亲委派无法实现的类加载场景引入。如 java.sql.DriverManager 用于实现驱动加载使用 java.util.ServiceLoader._load()。_java.sql.DriverManager.class 由启动类加载器加载 code

Tomcat 类加载器

Tomcat 类加载器的设计，作为一个 web 容器可能需要部署多个应用程序，不同的应用程序可能会依赖同一个第三方类库的不同版本，不能要求同一个类库在同一个服务器只有一份，因此要保证每个应用程序的类库都是独立的，保证相互隔离。如果使用默认加载器是无法完成加载两个相同类库的不同版本的，如果全限定类名相同则只会加载一份；作为 web 容器还需要支持 jsp 文件的热加载，如果我们改了 jsp 的内容，但是类名相同默认类加载器会直接查找方法区已经存在的，修改后的 jsp 是不会重新加载的。为了完成这个需求，Tomcat 通过一个新的 classloader 再次装载了该 jsp，每个 jsp 文件都对应一个唯一的类加载器。

类加载的一些异常

• 类加载死锁code
• ClassNotFoundException 和 NoClassDefFoundError code
  
• java.lang.VerifyError: Bad return type (f248 flume 程序 hadoop 依赖异常)

模块化与类加载

模块与层

JDK 9 为了模块化的支持，对双亲委派模式做了一些改动：

1. 扩展类加载器被平台类加载器（Platform ClassLoader）取代。
   JDK 9 时基于模块化进行构建（原来的 rt.jar 和 tools.jar 被拆分成数十个 JMOD 文件）， 其中的 Java 类库就已天然地满足了可扩展的需求，那自然无须再保留 \lib\ext 目录，此前使用这个目录或者 java.ext.dirs 系统变量来扩展 JDK 功能的机制已经没有继续存在的价值了
2. 平台类加载器和应用程序类加载器都不再继承自 java.net.URLClassLoader。
   现在启动类加载器、平台类加载器、应用程序类加载器全都继承 jdk.internal.loader.BuiltinClassLoader。
3. 启动类加载器现在是在 Java 虚拟机内部和 Java 类库共同协作实现的类加载器（以前是 C++实现）。
   为了与之前的代码保持兼容，所有在获取启动类加载器的场景（譬如 Object.class.getClassLoader）中仍然会返回 null 来代替，而不会得到 BootClassLoader 的实例。
4. 类加载的委派关系也发生了变动。
   当平台及应用程序类加载器收到类加载请求，在委派给父加载器加载前，要先判断该类是否能够归属到某一个系统模块中，如果可以找到这样的归属关系，就要优先委派给负责那个模块的加载器完成加载。

code

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

private static final BootClassLoader BOOT_LOADER;
private static final PlatformClassLoader PLATFORM_LOADER;
private static final AppClassLoader APP_LOADER;


/**
 * The class loader that is used to find resources in modules defined to
 * the boot class loader. It is not used for class loading.
 */
private static class BootClassLoader extends BuiltinClassLoader {
    BootClassLoader(URLClassPath bcp) {
        super(null, null, bcp);
    }

    @Override
    protected Class<?> loadClassOrNull(String cn, boolean resolve) {
        return JLA.findBootstrapClassOrNull(cn);
    }
};


/**
 * The platform class loader, a unique type to make it easier to distinguish
 * from the application class loader.
 */
private static class PlatformClassLoader extends BuiltinClassLoader {
    static {
        if (!ClassLoader.registerAsParallelCapable())
            throw new InternalError();
    }

    PlatformClassLoader(BootClassLoader parent) {
        super("platform", parent, null);
    }
}

/**
 * The application class loader that is a {@code BuiltinClassLoader} with
 * customizations to be compatible with long standing behavior.
 */
private static class AppClassLoader extends BuiltinClassLoader {
    static {
        if (!ClassLoader.registerAsParallelCapable())
            throw new InternalError();
    }

    AppClassLoader(BuiltinClassLoader parent, URLClassPath ucp) {
        super("app", parent, ucp);
    }

    @Override
    protected Class<?> loadClass(String cn, boolean resolve)
        throws ClassNotFoundException
    {
        // for compatibility reasons, say where restricted package list has
        // been updated to list API packages in the unnamed module.
        @SuppressWarnings("removal")
        SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            int i = cn.lastIndexOf('.');
            if (i != -1) {
                sm.checkPackageAccess(cn.substring(0, i));
            }
        }

        return super.loadClass(cn, resolve);
    }

    @Override
    protected PermissionCollection getPermissions(CodeSource cs) {
        PermissionCollection perms = super.getPermissions(cs);
        perms.add(new RuntimePermission("exitVM"));
        return perms;
    }

    /**
     * Called by the VM to support dynamic additions to the class path
     *
     * @see java.lang.instrument.Instrumentation#appendToSystemClassLoaderSearch
     */
    void appendToClassPathForInstrumentation(String path) {
        appendClassPath(path);
    }

    /**
     * Called by the VM to support define package for AppCDS
     */
    protected Package defineOrCheckPackage(String pn, Manifest man, URL url) {
        return super.defineOrCheckPackage(pn, man, url);
    }

    /**
     * Called by the VM, during -Xshare:dump
     */
    private void resetArchivedStates() {
        setClassPath(null);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

protected Class<?> loadClassOrNull(String cn, boolean resolve) {
    synchronized (getClassLoadingLock(cn)) {
        // check if already loaded
        Class<?> c = findLoadedClass(cn);
        if (c == null) {
            // find the candidate module for this class
            //模块是否加载过
            LoadedModule loadedModule = findLoadedModule(cn);
            if (loadedModule != null) {
                // package is in a module
                //使用模块加载器加载
                BuiltinClassLoader loader = loadedModule.loader();
                if (loader == this) {
                    //如果模块加载器是自己，就直接加载
                    if (VM.isModuleSystemInited()) {
                        c = findClassInModuleOrNull(loadedModule, cn);
                    }
                } else {
                    // delegate to the other loader
                    c = loader.loadClassOrNull(cn);
                }
            } else {
                // check parent
                if (parent != null) {
                    c = parent.loadClassOrNull(cn);
                }
                // check class path
                if (c == null && hasClassPath() && VM.isModuleSystemInited()) {
                    c = findClassOnClassPathOrNull(cn);
                }
            }

        }
        if (resolve && c != null)
            resolveClass(c);
        return c;
    }
}

从 jvm 源码看 main 方法调用过程

_JAVA_LAUNCHER_DEBUG=1
//从 openjdk8 源码开始， java9 之后 checkAndLoadMain 方法还在
//sun.launcher.LauncherHelper#checkAndLoadMain
//ClassLoader.getSystemClassLoader() -> initSystemClassLoader() -> sun.misc.Launcher.getLauncher()

参考

java8 语言规范
java8 虚拟机规范
java 参数
java9 虚拟机规范

https://gorden5566.com/post/1060.html
https://blog.csdn.net/huangzhilin2015/article/details/114873607
https://www.jianshu.com/p/8e8a5a773648
https://www.codeboy.me/2020/07/25/java-class-not-def-found-error/
https://heapdump.cn/article/281539
https://segmentfault.com/a/1190000021292121

https://zhuanlan.zhihu.com/p/97650770
https://www.modb.pro/db/250061
https://developer.aliyun.com/article/518315

https://zhuanlan.zhihu.com/p/215684718
https://linling1.github.io/programming_blog/2019/11/09/%E6%B7%B1%E5%85%A5%E6%8E%A2%E7%B4%A2-JVM-%E6%96%87%E9%9B%86/