详解JVM类加载机制

详解JVM类加载机制

笔者的笔记都记录在有道云里面，因为公司原因办公电脑无法使用有道云，正好借此机会整理下以前的笔记顺便当做巩固复习了，也因为记笔记的时候不会记录这些知识来源何地，所以如果发现原创后可找我，我会在后面加上原创链接。

我们都知道Java是可以跨平台的语言。而JVM是可以跨语言的平台。
首先我们要知道Java虚拟机怎么才做到这么多语言都可以在上面跑呢，关键的原因就是class这个东西，任何语言只要能编译成class文件，符合class文件的规范你就可以在java虚拟机上执行。所以，从jvm的角度来讲，它是不看你是什么语言写的，只关系class文件，只要你能编译成class文件并且符合规范，那么就可以运行。

1.类加载机制

一个类型从被加载到虚拟机内存中开始，到卸载出内存为止，它的整个生命周期将会经历加载（Loading）、验证（Verification）、准备（Preparation）、解析（Resolution）、初始化（Initialization）、使用（Using）和卸载（Unloading）七个阶 段，其中验证、准备、解析三个部分统称为连接（Linking）。这七个阶段的发生顺序如图所示。
图中，加载、验证、准备、初始化和卸载这五个阶段的顺序是确定的，类型的加载过程必须按照这种顺序按部就班地开始，而解析阶段则不一定：它在某些情况下可以在初始化阶段之后再开始，这是为了支持Java语言的运行时绑定特性（也称为动态绑定或晚 期绑定）。请注意，这里写的是按部就班地**“开始”**，而不是按部就班地“进行”或按部就班地“完成”，强调这点是因为这些阶段通常都是互相交叉地混合进行的，会在一个阶段执行的过程中调用、激活另一个阶段。

2.类加载的过程

接下来我们会详细了解Java虚拟机中类加载的全过程，即加载、验证、准备、解析和初始化这五个阶段所执行的具体动作。

加载 验证 准备 解析 初始化

1.加载

“加载”（Loading）阶段是整个“类加载”（Class Loading）过程中的一个阶段。在加载阶段，Java虚拟机需要完成以下三件事情：

• 通过一个类的全限定名来获取定义此类的二进制字节流。
• 将这个字节流所代表的静态存储结构转化为方法区的运行时数据结构。
• 在内存中生成一个代表这个类的java.lang.Class对象，作为方法区这个类的各种数据的访问入口。

注意这⾥不⼀定⾮得要从⼀个Class⽂件获取，这⾥既可以从ZIP包中读取(⽐如从jar包和war包中读取)，也可以在运⾏时计算⽣成（动态代理），也可以由其它⽂件⽣成（⽐如将JSP⽂件转换成对应的Class类）

2.验证

验证是连接阶段的第一步，这一阶段的目的是确保Class文件的字节流中包含的信息符合《Java虚拟机规范》的全部约束要求，保证这些信息被当作代码运行后不会危害虚拟机自身的安全。Class文件并不一定只能由Java源码编译而来，它可以使用包括靠键盘0和1直接在二进制编辑器中敲出Class文件在内的任何途径产生。前言中也说了，JVM是可以跨语言的平台。Java虚拟机如果不检查输入的字节流，对其完全信任的话，很可能会因为载入了有错误或有恶意企图的字节码流而导致整个系统受攻击甚至崩溃，所以验证字节码是Java虚拟机保护自身的一项必要措施。

验证阶段是非常重要的，这个阶段是否严谨，直接决定了Java虚拟机是否能承受恶意代码的攻击，从代码量和耗费的执行性能的角度上讲，验证阶段的工作量在虚拟机的类加 载过程中占了相当大的比重。从整体上看，验证阶段大致上会完成下面四个阶段的检验动作：文件格式验证、元数据验证、字节码验证和符号引用验证。

a.文件格式验证

第一阶段要验证字节流是否符合Class文件格式的规范，并且能被当前版本的虚拟机处理。这一阶段可能包括下面这些验证点：

• 是否以魔数0xCAFEBABE开头。
• 主、次版本号是否在当前Java虚拟机接受范围之内。
• 常量池的常量中是否有不被支持的常量类型（检查常量tag标志）。
• 指向常量的各种索引值中是否有指向不存在的常量或不符合类型的常量。
• CONSTANT_Utf8_info型的常量中是否有不符合UTF-8编码的数据。
• Class文件中各个部分及文件本身是否有被删除的或附加的其他信息。

b.元数据验证

第二阶段是对字节码描述的信息进行语义分析，以保证其描述的信息符合《Java语言规范》的要求，这个阶段可能包括的验证点如下：

• 这个类是否有父类（除了java.lang.Object之外，所有的类都应当有父类）。
• 这个类的父类是否继承了不允许被继承的类（被final修饰的类）。
• 如果这个类不是抽象类，是否实现了其父类或接口之中要求实现的所有方法。
• 类中的字段、方法是否与父类产生矛盾（例如覆盖了父类的final字段，或者出现不符合规则的方法重载，例如方法参数都一致，但返回值类型却不同等）。

第二阶段的主要目的是对类的元数据信息进行语义校验，保证不存在与《Java语言规范》定义相悖的元数据信息。

c.字节码验证

第三阶段是整个验证过程中最复杂的一个阶段，主要目的是通过数据流分析和控制流分析，确定程序语义是合法的、符合逻辑的。在第二阶段对元数据信息中的数据类型校验完毕以后，这阶段就要对类的方法体（Class文件中的Code属性）进行校验分析，保证被校验类的方法在运行时不会做出危害虚拟机安全的行为，例如：

• 保证任意时刻操作数栈的数据类型与指令代码序列都能配合工作，例如不会出现类似于“在操作栈放置了一个int类型的数据，使用时却按long类型来加载入本地变量表中”这样的情况。
• 保证任何跳转指令都不会跳转到方法体以外的字节码指令上。
• 保证方法体中的类型转换总是有效的，例如可以把一个子类对象赋值给父类数据类型，这是安全的，但是把父类对象赋值给子类数据类型，甚至把对象赋值给与它毫无继承关系、完全不相干的一个数据类型，则是危险和不合法的。

注意：如果一个类型中有方法体的字节码没有通过字节码验证，那它肯定是有问题的；但如果一个方法体通过了字节码验证，也仍然不能保证它一定就是安全的。

d.符号引用验证

最后一个阶段的校验行为发生在虚拟机将符号引用转化为直接引用 的时候，这个转化动作将在连接的第三阶段——解析阶段中发生。符号引用验证可以看作是对类自身以外（常量池中的各种符号引用）的各类信息进行匹配性校验，通俗来说就是，该类是否缺少或者被禁止访问它依赖的某些外部类、方法、字段等资源。本阶段通常需要校验下列内容：

• 符号引用中通过字符串描述的全限定名是否能找到对应的类。
• 在指定类中是否存在符合方法的字段描述符及简单名称所描述的方法和字段。
• 符号引用中的类、字段、方法的可访问性（private、protected、public、）是否可被当前类访问。

符号引用验证的主要目的是确保解析行为能正常执行，如果无法通过符号引用验证，Java虚拟机将会抛出一个java.lang.IncompatibleClassChangeError的子类异常，典型的如：java.lang.IllegalAccessError、java.lang.NoSuchFieldError、java.lang.NoSuchMethodError等。
验证阶段对于虚拟机的类加载机制来说，是一个非常重要的、但却不是必须要执行的阶段，因为验证阶段只有通过或者不通过的差别，只要通过了验证，其后就对程序运行期没有任何影响了。

3.准备

准备阶段是正式为类中定义的变量（即静态变量，被static修饰的变量）分配内存并设置类变量初始值的阶段，从概念上讲，这些变量所使用的内存都应当在方法区中进行分配，但必须注意到方法区本身是一个逻辑上的区域，在JDK 7及之前，HotSpot使用永久代来实现方法区时，实现是完全符合这种逻辑概念的；而在JDK 8及之后，类变量则会随着Class对象一起存放在Java堆中，这时候“类变量在方法区”就完全是一种对逻辑概念的表述了。

关于准备阶段，还有两个容易产生混淆的概念笔者需要着重强调，首先是这时候进行内存分配的仅包括类变量，而不包括实例变量，实例变量将会在对象实例化时随着对象一起分配在Java堆中。其次是这里所说的初始值“通常情况”下是数据类型的零值，假设一个类变量的定义为： public static int value = 123; 那变量value在准备阶段过后的初始值为0而不是123，因为这时尚未开始执行任何Java方法，而把value赋值为123的putstatic指令是程序被编译后，存放于类构造器()方法之中，所以把value赋值为123的动作要到类的初始化阶段才会被执行。

4.解析

解析阶段是Java虚拟机将常量池内的符号引用替换为直接引用的过程：

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

解析动作主要针对类或接口、字段、类方法、接口方法、方法类型、方法句柄和调用限定符这7类符号引用进行，分别对应于常量池的CONSTANT_Class_info、CON-STANT_Fieldref_info、CONSTANT_Methodref_info、CONSTANT_InterfaceMethodref_info、CONSTANT_MethodType_info、CONSTANT_MethodHandle_info、CONSTANT_Dyna-mic_info和CONSTANT_InvokeDynamic_info 8种常量类型。

举两个例子：

a.类或接口的解析

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

1. 如果C不是一个数组类型，那虚拟机将会把代表N的全限定名传递给D的类加载器去加载这个类C。在加载过程中，由于元数据验证、字节码验证的需要，又可能触发其他相关类的加载动作，例如加载这个类的父类或实现的接口。一旦这个加载过程出现了任何异常，解析过程就将宣告失败。
2. 如果C是一个数组类型，并且数组的元素类型为对象，也就是N的描述符会是类似“[Ljava/lang/Integer”的形式，那将会按照第一点的规则加载数组元素类型。如果N的描述符如前面所假设的形式，需要加载的元素类型就是“java.lang.Integer”，接着由虚拟机生成一个代表该数组维度和元素的数组对象。
3. 如果上面两步没有出现任何异常，那么C在虚拟机中实际上已经成为一个有效的类或接口了，但在解析完成前还要进行符号引用验证，确认D是否具备对C的访问权限。如果发现不具备访问权限，将抛出java.lang.IllegalAccessError异常。针对上面第3点访问权限验证，在JDK9引入了模块化以后，一个public类型也不再意味着程序任何位置都有它的访问权限，我们还必须检查模块间的访问权限。如果我们说一个D拥有C的访问权限，那就意味着以下3条规则中至少有其中一条成立：
4. 被访问类C是public的，并且与访问类D处于同一个模块。
5. 被访问类C是public的，不与访问类D处于同一个模块，但是被访问类C的模块允许被访问类D的模块进行访问。
6. 被访问类C不是public的，但是它与访问类D处于同一个包中。

b.方法解析

方法解析的第一个步骤与字段解析一样，也是需要先解析出方法表的class_index 项中索引的方法所属的类或接口的符号引用，如果解析成功，那么我们依然用C表示这个 类，接下来虚拟机将会按照如下步骤进行后续的方法搜索：

1. 由于Class文件格式中类的方法和接口的方法符号引用的常量类型定义是分开的，如果在类的方法表中发现class_index中索引的C是个接口的话，那就直接抛出java.lang.IncompatibleClassChangeError异常。
2. 如果通过了第一步，在类C中查找是否有简单名称和描述符都与目标相匹配的方法，如果有则返回这个方法的直接引用，查找结束。
3. 否则，在类C的父类中递归查找是否有简单名称和描述符都与目标相匹配的方法，如果有则返回这个方法的直接引用，查找结束。
4. 否则，在类C实现的接口列表及它们的父接口之中递归查找是否有简单名称和描述符都与目标相匹配的方法，如果存在匹配的方法，说明类C是一个抽象类，这时候查找结束，抛出java.lang.AbstractMethodError异常。
5. 否则，宣告方法查找失败，抛出java.lang.NoSuchMethodError。最后，如果查找过程成功返回了直接引用，将会对这个方法进行权限验证，如果发现不具备对此方法的访问权限，将抛出java.lang.IllegalAccessError异常

5.初始化

类的初始化阶段是类加载过程的最后一个步骤，之前介绍的几个类加载的动作里，除了在加载阶段用户应用程序可以通过自定义类加载器的方式局部参与外，其余动作都完全由Java虚拟机来主导控制。直到初始化阶段，Java虚拟机才真正开始执行类中编写的Java程序代码，将主导权移交给应用程序。

进行准备阶段时，变量已经赋过一次系统要求的初始零值，而在初始化阶段，则会根据程序员通过程序编码制定的主观计划去初始化类变量和其他资源。我们也可以从另外一种更直接的形式来表达：初始化阶段就是执行类构造器()方法的过程。()并不是程序员在Java代码中直接编写的方法，它是Javac编译器的自动生成物，但我们非常有必要了解这个方法具体是如何产生的，以及()方法执行过程中各种可能会影响程序运行行为的细节，这部分比起其他类加载过程更贴近于普通的程序开发人员的实际工作。

3.类加载器

虚拟机设计团队把加载动作放到JVM外部实现，以便让应⽤程序决定如何获取所需的类。实现这个动作的代码被称为类加载器ClassLoader，JVM所有的class都是被类加载器加载到内存的。

类加载器虽然只用于实现类的加载动作，但它在Java程序中起到的作用却远超类加载阶段。对于任意一个类，都必须由加载它的类加载器和这个类本身一起共同确立其在Java虚拟机中的唯一性，每一个类加载器，都拥有一个独立的类名称空间。这句话可以表达得更通俗一些：比较两个类是否“相等”，只有在这两个类是由同一个类加载器加载的前提下才有意义，否则，即使这两个类来源于同一个Class文件，被同一个Java虚拟机加载，只要加载它们的类加载器不同，那这两个类就必定不相等。

1.类加载器的四种不同层次

类加载器的加载过程是分成不同的层次来加载的，不同的类加载器加载不同的class，下面来看下总共如下的从高到低的四种类加载器:

 - 启动类加载器(Bootstrap ClassLoader)：负责加载 JAVA_HOME\lib ⽬录中的，或通过- Xbootclasspath参数指定路径中的，且被虚拟机认可（按⽂件名识别，如rt.jar）的类。
 - 扩展类加载器(Extension ClassLoader)：负责加载 JAVA_HOME\lib\ext ⽬录中的，或通过java.ext.dirs系统变量指定路径中的类库。
 - 应⽤程序类加载器(Application ClassLoader)：负责加载⽤户路径（classpath）上的类库。
 - ⾃定义的类加载器(Custom ClassLoader):会在后面的文章详细说明如何实现自定义类加载器

其中**启动类加载器(Bootstrap ClassLoader)**是最为顶层的加载器，他是来加载lib里jdk里最核心的内容，比如rt.jar.charset.jar等核心类。所以说什么时候调用getClassLoader()拿到的加载器的结果是一个空值的时候就代表改类已经到达了最顶层的加载器。比如String.class.getClassLoader()拿到的这个加载器的结果是一个空值。

package testloader;

public class T001_ClassLoaderLevel {
    public static void main(String[] args) {
    	//Bootstrap是用C++实现的，java里并没有class和他对应，所有打印为null
        System.out.println(String.class.getClassLoader());
        System.out.println(sun.awt.HKSCS.class.getClassLoader());
        System.out.println(sun.net.spi.nameservice.dns.DNSNameService.class.getClassLoader());
        System.out.println(T001_ClassLoaderLevel.class.getClassLoader());

        System.out.println(sun.net.spi.nameservice.dns.DNSNameService.class.getClassLoader().getClass().getClassLoader());
        System.out.println(T001_ClassLoaderLevel.class.getClassLoader().getClass().getClassLoader());
		//自己实现的ClassLoader加载器
        System.out.println(new T002_CustClassLoader().getParent());
        System.out.println(ClassLoader.getSystemClassLoader());
    }
}

运行结果为

null
null
sun.misc.Launcher$ExtClassLoader@3339ad8e
sun.misc.Launcher$AppClassLoader@18b4aac2
null
null
sun.misc.Launcher$AppClassLoader@18b4aac2
sun.misc.Launcher$AppClassLoader@18b4aac2

2.双亲委派模型

图中展示的各种类加载器之间的层次关系被称为类加载器的“双亲委派模型（Parents Delegation Model）”。双亲委派模型要求除了顶层的启动类加载器外，其余的类加载器都应有自己的父类加载器。不过这里类加载器之间的父子关系一般不是以继承（Inheritance）的关系来实现的，而是通常使用组合（Composition）关系来复用父加载器的代码。

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

需要注意的是，父加载器不是“类加载器的加载器”，也不是“类加载器的父类加载器”。如下小程序可见他们的ClassLoader到底是谁。

package testloader;

public class T004_ParentAndChild {
    public static void main(String[] args) {
        System.out.println(T004_ParentAndChild.class.getClassLoader());
        System.out.println(T004_ParentAndChild.class.getClassLoader().getClass().getClassLoader());
        System.out.println(T004_ParentAndChild.class.getClassLoader().getParent());
        System.out.println(T004_ParentAndChild.class.getClassLoader().getParent().getParent());
        //System.out.println(T004_ParentAndChild.class.getClassLoader().getParent().getParent().getParent());

    }
}

运行结果为

sun.misc.Launcher$AppClassLoader@18b4aac2
null
sun.misc.Launcher$ExtClassLoader@4554617c
null

那么为什么JVM要弄一个双亲委派？安全
使用双亲委派模型来组织类加载器之间的关系，一个显而易见的好处就是Java中的类随着它的类加载器一起具备了一种带有优先级的层次关系。例如类java.lang.Object，它存放在rt.jar之中，无论哪一个类加载器要加载这个类，**最终都是委派给处于模型最顶端的启动类加载器进行加载，因此Object类在程序的各种类加载器环境中都能够保证是同一个类。**反之，如果没有使用双亲委派模型，都由各个类加载器自行去加载的话，如果用户自己也编写了一个名为java.lang.Object的类，并放在程序的ClassPath中，那系统中就会出现多个不同的Object类，Java类型体系中最基础的行为也就无从保证，应用程序将会变得一片混乱。如果读者有兴趣的话，可以尝试去写一个与rt.jar类库中已有类重名的Java类，将会发现它可以正常编译，但永远无法被加载运行 。

3.类加载器范围

由上述两个代码例子不难看出，所有的ClassLoader都是在sun.misc.Launcher里的。其中Launcher就是ClassLoader一个包装类启动类，在这个类中可以看到很多东西，比如之前说的三个层次的类加载器他们指定的类加载路径就是在这里指定的。截取部分代码:

public class Launcher {
    private static URLStreamHandlerFactory factory = new Launcher.Factory();
    private static Launcher launcher = new Launcher();
    private static String bootClassPath = System.getProperty("sun.boot.class.path");
    private ClassLoader loader;
    private static URLStreamHandler fileHandler;

	private static File[] getExtDirs() {
	    String var0 = System.getProperty("java.ext.dirs");
	    File[] var1;
	    if (var0 != null) {
	        StringTokenizer var2 = new StringTokenizer(var0, File.pathSeparator);
	        int var3 = var2.countTokens();
	        var1 = new File[var3];
	
	        for(int var4 = 0; var4 < var3; ++var4) {
	            var1[var4] = new File(var2.nextToken());
	        }
	    } else {
	        var1 = new File[0];
	    }
	
	    return var1;
	}

	static class AppClassLoader extends URLClassLoader {
	    final URLClassPath ucp = SharedSecrets.getJavaNetAccess().getURLClassPath(this);
	
	    public static ClassLoader getAppClassLoader(final ClassLoader var0) throws IOException {
	        final String var1 = System.getProperty("java.class.path");
	        final File[] var2 = var1 == null ? new File[0] : Launcher.getClassPath(var1);
	        return (ClassLoader)AccessController.doPrivileged(new PrivilegedAction<Launcher.AppClassLoader>() {
	            public Launcher.AppClassLoader run() {
	                URL[] var1x = var1 == null ? new URL[0] : Launcher.pathToURLs(var2);
	                return new Launcher.AppClassLoader(var1x, var0);
	            }
	        });
	    }
	}
}

或者我们也可以通过如下代码看出Launcher的加载路径

package testloader;

public class T003_ClassLoaderScope {
    public static void main(String[] args) {
        String pathBoot = System.getProperty("sun.boot.class.path");
        System.out.println(pathBoot.replaceAll(";", System.lineSeparator()));

        System.out.println("--------------------");
        String pathExt = System.getProperty("java.ext.dirs");
        System.out.println(pathExt.replaceAll(";", System.lineSeparator()));

        System.out.println("--------------------");
        String pathApp = System.getProperty("java.class.path");
        System.out.println(pathApp.replaceAll(";", System.lineSeparator()));
    }
}

其结果如下：

C:\Program Files\Java\jdk1.8.0_141\jre\lib\resources.jar
C:\Program Files\Java\jdk1.8.0_141\jre\lib\rt.jar
C:\Program Files\Java\jdk1.8.0_141\jre\lib\sunrsasign.jar
C:\Program Files\Java\jdk1.8.0_141\jre\lib\jsse.jar
C:\Program Files\Java\jdk1.8.0_141\jre\lib\jce.jar
C:\Program Files\Java\jdk1.8.0_141\jre\lib\charsets.jar
C:\Program Files\Java\jdk1.8.0_141\jre\lib\jfr.jar
C:\Program Files\Java\jdk1.8.0_141\jre\classes
--------------------
C:\Program Files\Java\jdk1.8.0_141\jre\lib\ext
C:\Windows\Sun\Java\lib\ext
--------------------
C:\Program Files\Java\jdk1.8.0_141\jre\lib\charsets.jar
C:\Program Files\Java\jdk1.8.0_141\jre\lib\deploy.jar
C:\Program Files\Java\jdk1.8.0_141\jre\lib\ext\access-bridge-64.jar
C:\Program Files\Java\jdk1.8.0_141\jre\lib\ext\cldrdata.jar
C:\Program Files\Java\jdk1.8.0_141\jre\lib\ext\dnsns.jar
C:\Program Files\Java\jdk1.8.0_141\jre\lib\ext\jaccess.jar
C:\Program Files\Java\jdk1.8.0_141\jre\lib\ext\jfxrt.jar
C:\Program Files\Java\jdk1.8.0_141\jre\lib\ext\localedata.jar
C:\Program Files\Java\jdk1.8.0_141\jre\lib\ext\nashorn.jar
C:\Program Files\Java\jdk1.8.0_141\jre\lib\ext\sunec.jar
C:\Program Files\Java\jdk1.8.0_141\jre\lib\ext\sunjce_provider.jar
C:\Program Files\Java\jdk1.8.0_141\jre\lib\ext\sunmscapi.jar
C:\Program Files\Java\jdk1.8.0_141\jre\lib\ext\sunpkcs11.jar
C:\Program Files\Java\jdk1.8.0_141\jre\lib\ext\zipfs.jar
C:\Program Files\Java\jdk1.8.0_141\jre\lib\javaws.jar
C:\Program Files\Java\jdk1.8.0_141\jre\lib\jce.jar
C:\Program Files\Java\jdk1.8.0_141\jre\lib\jfr.jar
C:\Program Files\Java\jdk1.8.0_141\jre\lib\jfxswt.jar
C:\Program Files\Java\jdk1.8.0_141\jre\lib\jsse.jar
C:\Program Files\Java\jdk1.8.0_141\jre\lib\management-agent.jar
C:\Program Files\Java\jdk1.8.0_141\jre\lib\plugin.jar
C:\Program Files\Java\jdk1.8.0_141\jre\lib\resources.jar
C:\Program Files\Java\jdk1.8.0_141\jre\lib\rt.jar
D:\study\msb\JVM\out\production\JVM
D:\IntelliJ IDEA 2019.2.4\lib\idea_rt.jar

文章到此就结束了，其后自定义类加载机制会在后面的文章出现。