JVM-01-类加载子系统

类加载子系统

翻译自–>尚硅谷_宋红康讲解的JVM课程

这里讲的是HotSpot虚拟机！

---

内存的概述

这图是JVM架构，接下来这篇文章讲的类加载器子系统那部分！

---

概述类的加载器及类加载过程

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

public class HelloLoader {
    public static void main(String[] args) {
        System.out.println("谢谢ClassLoader加载我....");
        System.out.println("你的大恩大德，我下辈子再报！");
    }
}

谢谢ClassLoader加载我....
你的大恩大德，我下辈子再报！

一个小学生都能看得懂的代码。要执行main方法，首先要判断HelloLoader是否已经被加载到方法区了，否就进行加载（加载对应的class文件），加载失败就抛出异常（对应的class文件不合法，比如恶意的修改class文件）。装载好class类后就有对应的class对象，进行下面的链接和初始化，再调用main方法。

---

类的加载过程一：Loading

类的加载过程是个宏观的描述，包括加载、链接、初始化，第一步刚好叫加载（Loading），注意分清！

加载：

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

---

类的加载过程二：Linking

链接：

1. 验证（Verify）： 为了防止恶意修改二进制文件导致程序的崩溃。

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

2. 准备（Prepare）：

   • 为类变量分配内存并且设置类变量的默认初始值。

   public class HelloApp {
       private static int a = 1;//prepare(准备)：a = 0 ---> initial(初始化) : a = 1
   
       public static void main(String[] args) {
           System.out.println(a);
       }
   }
   

   • 这里不包含用final修饰的static，因为final在编译的时候就会分配了，准备阶段会显式初始化。
   • 这里不会为实例化变量分配初始化，类变量会分配在方法区中，而实例变量是会随着对象一起分配到Java堆中。

3. 解析（Resolve）：

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

---

类的加载过程三：Initialization

初始化：

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

下面我们需要用到一个软件jclasslib，也可以在idea中下载一个jclasslib插件（这里使用idea的jclasslib插件），用于查看字节码指令（我们在idea中看到的class文件内容是经过idea反编译过来的）。我们也可以使用命令行的javap去查看字节码指令，这里不演示（本人比较懒…）。

安装好插件后，打开需要查看字节码的Java文件，到View下打开jclasslib插件，（注意！！！Java代码记得编译！！！）

jclasslib界面，在idea的右侧工具栏，看见Methods了吗，这个就是查看方法的地方，再看里面的<clinit>，这个就是我们现在需要查看的文件。

---

构造器方法中指令按语句在源文件中出现的顺序执行 --> 代码演示

public class ClassInitTest {
   private static int num = 1;

   static{
       num = 2;
       number = 20;
       System.out.println(num);
       //System.out.println(number);//报错：非法的前向引用。在变量定义前不能调用，但可以赋值。
   }

   private static int number = 10;  //linking之prepare: number = 0 --> initial: 20 --> 10

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

变量num：在链接的准备阶段为num赋值为0（int类型），到初始化阶段，先赋值为1，再执行static{}代码块，把变量赋值为2，所以num最终结果为2。

变量number：在链接的准备阶段也为number赋值为0（int类型），到初始化阶段，先执行static{}代码块，把变量赋值为20，再使用10覆盖20，number最终结果为10。（在字节码指令中可以看出，先执行20，再执行10，如果看不懂也不要着急，我们这里先不讲字节码指令，后面才需要用到，这里先知道有这样一个东西）

---

此方法不需定义，是javac编译器自动收集类中的所有类变量的赋值动作和静态代码块中的语句合并而来 --> 代码演示

public class ClinitTest {
    private int a = 1;
    public static void main(String[] args) {
        int b = 2;
    }
}

可以看到，这里没有<clinit>，因为代码没有类变量和静态代码块（使用static修饰的成员变量是类变量，属于该类本身；没有使用static修饰的成员变量是实例变量，属于该类的实例）

---

构造器 --> 代码演示

public class ClinitTest {
    //任何一个类声明以后，内部至少存在一个类的构造器
    private int a = 1;
    public static void main(String[] args) {
        int b = 2;
    }
}

public class ClinitTest {
    //任何一个类声明以后，内部至少存在一个类的构造器
    private int a = 1;
    public static void main(String[] args) {
        int b = 2;
    }

    public ClinitTest(){
        a = 10;
        int d = 20;
    }
}

结合字节码可以看出，无论自己没有没显式的定义构造器，每个类都会至少存在一个构造器（自动生成的是无参构造器）。

---

若该类具有父类，JVM会保证子类的<clinit>()执行前，父类的<clinit>()已经执行完毕 --> 代码演示

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) {
        //加载Father类，其次加载Son类。
        System.out.println(Son.B);//2
    }
}

上图是Son类，可以看到<clinit>中先要有Son.A的变量，A变量是在父类Father中，说明先执行父类的<clinit>再执行子类的<clinit>

---

虚拟机必须保证一个类的<clinit>()方法在多线程下被同步加锁 --> 代码演示

public class DeadThreadTest {
    public static void main(String[] args) {
        Runnable r = () -> {
            System.out.println(Thread.currentThread().getName() + "开始");
            DeadThread dead = new DeadThread();
            System.out.println(Thread.currentThread().getName() + "结束");
        };

        Thread t1 = new Thread(r,"线程1");
        Thread t2 = new Thread(r,"线程2");

        t1.start();
        t2.start();
    }
}

class DeadThread{
    static{
        if(true){
            System.out.println(Thread.currentThread().getName() + "初始化当前类");
            while(true){
				// 模拟已经被加载了
            }
        }
    }
}

可以看到，当DeadThread类被加载了，其他线程就被锁在外面了。也得出类只会被加载一次。

---

类加载器的分类

• JVM支持两种类型的类加载器，分别为引导类加载器（Bootstrap ClassLoader）和自定义加载器（User-Defined ClassLoader）。
• 从概念上来讲，自定义加载器一般指的是程序中由开发人员自定义的一类加载器，但是Java虚拟机规范却没有这么定义，而是将所有派生于抽象类（ClassLoader）的类加载器都划分为自定义加载器。

Extension ClassLoader 和System ClassLoader（App ClassLoader）间接的继承了ClassLoader。

jdk1.8下

ExtClassLoader间接继承ClassLoader

App ClassLoader间接继承ClassLoader

---

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@154617c

        //获取其上层：获取不到引导类加载器,因为引导类加载器是由c/c++编写的，所以这里拿不到对象
        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
    }
}

sun.misc.Launcher$AppClassLoader@b4aac2
sun.misc.Launcher$ExtClassLoader@154617c
null
sun.misc.Launcher$AppClassLoader@b4aac2
null

---

虚拟机自带的加载器

• 启动类加载器（引导类加载器，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等开头的类
• 扩展类加载器（Extension ClassLoader）
  • Java语言编写，由sun.misc.Launcher$ExtClassLoader实现
  • 派生于ClassLoader类
  • 父类加载器为启动类加载器
  • 从java.ext.dirs系统属性所指定的目录中加载类库，或从JDK的安装目录的jre/lib/ext子目录（扩展目录）下加载类库。如果用户创建的JAR放在此目录下，也会自动由扩展类加载器加载
• 应用程序类加载器（系统类加载器，AppClassLoader）
  • Java语言编写，由sun.misc.Launcher$AppClassLoader实现
  • 派生于ClassLoader类
  • 父类加载器为扩展类加载器
  • 它负责加载环境变量classpath或系统属性java.class.path指定路径下的类库
  • 该类加载是程序中默认的类加载器，一般来说，Java应用的类都是由它来完成加载
  • 通过ClassLoader的getSystemClassLoader()方法可以获取到该类加载器

import sun.security.ec.CurveDB;
import java.net.URL;
import java.security.Provider;

/**
 * jdk:1.8
 */
public class ClassLoaderTest1 {
    public static void main(String[] args) {
        System.out.println("**********启动类加载器**************");
        //获取BootstrapClassLoader能够加载的api的路径
        URL[] urLs = sun.misc.Launcher.getBootstrapClassPath().getURLs();
        for (URL element : urLs) {
            System.out.println(element.toExternalForm());
        }
        //从上面的路径中随意选择一个类,来看看他的类加载器是什么:引导类加载器
        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);
        }

        //从上面的路径中随意选择一个类,来看看他的类加载器是什么:扩展类加载器
        ClassLoader classLoader1 = CurveDB.class.getClassLoader();
        System.out.println(classLoader1);//sun.misc.Launcher$ExtClassLoader@1540e19d
    }
}

**********启动类加载器**************
file:/C:/Program%20Files%20(x86)/Java/jdk1.8.0_144/jre/lib/resources.jar
file:/C:/Program%20Files%20(x86)/Java/jdk1.8.0_144/jre/lib/rt.jar
file:/C:/Program%20Files%20(x86)/Java/jdk1.8.0_144/jre/lib/sunrsasign.jar
file:/C:/Program%20Files%20(x86)/Java/jdk1.8.0_144/jre/lib/jsse.jar
file:/C:/Program%20Files%20(x86)/Java/jdk1.8.0_144/jre/lib/jce.jar
file:/C:/Program%20Files%20(x86)/Java/jdk1.8.0_144/jre/lib/charsets.jar
file:/C:/Program%20Files%20(x86)/Java/jdk1.8.0_144/jre/lib/jfr.jar
file:/C:/Program%20Files%20(x86)/Java/jdk1.8.0_144/jre/classes
null
***********扩展类加载器*************
C:\Program Files (x86)\Java\jdk1.8.0_144\jre\lib\ext
C:\WINDOWS\Sun\Java\lib\ext
sun.misc.Launcher$ExtClassLoader@a987ac

---

用户自定义类加载器

• 在Java的日常应用程序开发中，类的加载几乎是由上述3种类加载器相互配合执行的，在必要时，我们还可以自定义类加载器，来定制类的加载器方式。
• 为什么要自定义类加载器？
  • 隔离加载类
  • 修改类加载的方式
  • 扩展加载源
  • 防止源码泄露

如何自定义就不说了（本人学识太浅…），自己度娘去…

---

关于ClassLoader

ClassLoader类，它是一个抽象类，其后所有的类加载器都继承自ClassLoader（不包括启动类加载器，它由c/c++实现的）

该类有超多的方法,还有部分没贴出来

这里简单了解了解几个方法

方法	作用
getParent()	返回该类加载器的超类加载器
loadClass(String name)	加载名称为name的类，返回结果为java.lang.Class类的实例
findClass(String name)	查找名称为name的类，返回结果为java.lang.Class类的实例
findLoadedClass(String name)	查找名称为name且已经被加载过的类，返回结果为java.lang.Class类的实例
defineClass(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

public class ClassLoaderTest2 {
    public static void main(String[] args) {
        try {
            //1.
            ClassLoader classLoader = Class.forName("java.lang.String").getClassLoader();
            System.out.println(classLoader);
            //2.
            ClassLoader classLoader1 = Thread.currentThread().getContextClassLoader();
            System.out.println(classLoader1);

            //3.
            ClassLoader classLoader2 = ClassLoader.getSystemClassLoader().getParent();
            System.out.println(classLoader2);

        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

null
sun.misc.Launcher$AppClassLoader@b4aac2
sun.misc.Launcher$ExtClassLoader@154617c

---

双亲委派机制

什么是双亲委派机制

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

讲原理前，我们去看看一块代码

/*
	测试类
*/
public class StringTest {
    public static void main(String[] args) {
        java.lang.String str = new java.lang.String();
        System.out.println("hello");
    }
}

/*
	自定义String，包为java.lang
*/
package java.lang;
public class String {
    static {
        System.out.println("我是自定义String静态代码块");
    }
}

结果：
hello

结论：
JVM并没有创建我们自定义的String，因为只用加载了自定义String，就会执行static{}代码块，显然在结果中看出并没有执行。说明JVM加载的String还是核心api里面的。其中使用的就是双亲委派机制。

双亲委派机制工作原理

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

说回刚刚那个自定义String，执行java.lang.String str = new java.lang.String()代码时（先当作是自定义类），应该使用的是系统类加载器，但其存在父类加载器，直到委托给引导类加载器，此时引导类加载器就尝试去加载任务，因为该类是在java开头的包下，引导类加载器就成功加载到了，成功返回。引导类加载器加载的java.lang包下的String是jdk中核心api，并不是我们自定义的类。

---

我们再看看一块代码

package com.atguigu.java1;
public class StringTest {
    public static void main(String[] args) {
        StringTest test = new StringTest();
		System.out.println(test.getClass().getClassLoader());
    }
}

结果：
sun.misc.Launcher$AppClassLoader@b4aac2

可以看出是系统类加载器去加载的。

流程是这样的：

1. 先到系统类加载器，但存在父类加载器，就向上委托给扩展类加载器
2. 扩展类加载器也存在父类加载器，就向上委托给引导类加载器
3. 引导类加载器无父类，此时就尝试去加载，发现该包（com.atguigu.java1）下的类不归它管，就向下委托给扩展类加载器
4. 扩展类加载器也发现该包（com.atguigu.java1）下的类不归它管，就向下委托给系统类加载器
5. 最终系统类加载器成功加载了该类

---

我们再看看一块代码

package java.lang;
public class String {
    static {
        System.out.println("我是自定义String静态代码块");
    }

    public static void main(String[] args) {
        
    }
}

结果：
错误: 在类 java.lang.String 中找不到 main 方法, 请将 main 方法定义为:
   public static void main(String[] args)
否则 JavaFX 应用程序类必须扩展javafx.application.Application

结合上述两个案列，很明显，引导类加载器了jdk的String类，并不是我们自定义的String类，jdk的String类自然没有main方法。

---

假如我们程序需要用到SPI接口，该SPI是核心API。引导类加载器把rt.jar的核心类加载过来，但里面会存在一些接口，会关系到具体的实现类，这些实现类又涉及到一些第三方jar包，所以最终需要加载到第三方jar包。因为第三方jar包不属于核心jar包，应该反向委托，最终给系统类加载器加载，此处用到的是反向委派。使用线程上下文类加载器（默认为AppClassLoader）去加载第三方jar包的实现类。

---

双亲委派机制优势

• 避免类的重复加载（有加载器加载了，就不会反向委托）
• 保护程序安全，防止核心API被随意篡改
  • 自定义类：java.lang.String（自定义String的案例，并不会加载我们自定义的String，保护了jdk自带的String）
  • 自定义类：java.lang.ShkStart（java开头的，引导类加载器尝试加载，马上报出SecurityException错误，因为访问java.lang包是需要权限的，JVM阻止我们使用java.lang包名去定义类）

---

沙箱安全机制

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

---

类的主动使用和被动使用

Java程序对类的使用方式分为：主动使用和被动使用

• 主动使用，又分为七种情况：
  • 创建类的实例
  • 访问某个类或接口的静态变量，或者对该静态变量赋值
  • 调用类的静态方法
  • 反射
  • Java虚拟机启动时被标明为启动类的类
  • JDK 7 开始提供的动态语言支持：java.lang.invoke.MethodHandle实例的解析结果REF_getStatic、REF_putStatic、REF_invokeStatic句柄对应类没有初始化，则初始化
• 除了以上七种情况，其它使用Java类的方式都被看作是对类的被动使用，都不会导致类的初始化。

---

其他

• 在JVM中表示两个class对象是否为同一个类存在的两个必要条件。
  • 类的完整类名必须一致，包括包名
  • 加载这个类的ClassLoader（指ClassLoader实例对象）必须相同
• 换句话说，在JVM中，即便这两个类对象（class对象）来源同一个Class文件，被同一个虚拟机所加载，但是只要加载它们的ClassLoader实例对象不一样，那么这两个对象也是不相等的。

---

JVM必须知道一个类型是由类启动加载器加载还是由用户类加载器加载的。如果一个类型是由用户类加载器加载的，那么JVM会将这个类加载器的一个引用作为类型信息的一部分保存在方法区中。当解析一个类型到另一个类型的引用时，JVM需要保证这两个类型的类加载器是相同的。

---