【Java虚拟机】JVM类加载机制和双亲委派模型

文章目录

- - - 1.JVM虚拟机类加载子系统
    - 2.双亲委派机制和JDK9模块化系统
    - 3.ClassLoader源码解读和自定义类加载器场景
    - 4.自定义ClassLoader类加载器案例实战
    - 5.不同类加载器加载同个class类

1.JVM虚拟机类加载子系统

（1）什么是类加载子系统

是Java虚拟机的一个重要子系统，主要负责将类的字节码加载到JVM内存的方法区，并将其转换为JVM内部的数据结构。

在这里插入图片描述

（2）类加载器的三大特点

双亲委派模型
- Java虚拟机采用双亲委派模型来加载类，即先从父类加载器中查找类，如果找到了就直接返回
- 否则再由自己的加载器加载，这种模型可以避免类的重复加载，提高系统的安全性。
延迟加载
- Java虚拟机采用延迟加载的策略，即只有在需要使用某个类时才进行加载
- 这种策略可以减少系统启动时间，提高系统的性能
动态加载
- Java虚拟机支持动态加载类，即可以在程序运行时动态地加载和卸载类
- 这种特性可以使Java程序更加灵活和可扩展

（3）类加载子系统由三个模块组成

加载器（ClassLoader）
- 加载器负责将类的字节码加载到JVM中
- 三种类型的加载器
  - 启动类加载器（Bootstrap ClassLoader）
    - c/c++实现，加载核心类库使用，不继承ClassLoader，没父加载器
  - 平台类加载器（Platform ClassLoader）
    - 注意：JDK9之前是扩展类加载器 Extension ClassLoader
  - 应用程序类加载器（Application ClassLoader）
    - 程序的默认加载器，我们写的代码基本都是由这个加载器负责加载
  - 类加载器用父类加载器、子类加载器这样的名字，虽然看似是继承关系，实际上是组合（Composition）关系
链接器（Linker）
- 负责将Java类的二进制代码链接到Java虚拟机中，并生成可执行的Java虚拟机代码，包括 验证、准备和解析 等
- 验证操作主要是验证类的字节码是否符合JVM规范
- 准备操作主要是为类的静态变量分配内存并设置默认值
- 解析操作主要是将符号引用转换为直接引用
初始化器（Initializer）
- 负责执行Java类的静态初始化，包括静态变量的赋值、静态代码块的执行等
- 初始化器是类加载子系统的最后一个阶段

2.双亲委派机制和JDK9模块化系统

（1）为啥需要这个双亲委派模型

比如java.lang.Object 这些存放在rt.jar中的类，无论使用哪个类加载器加载，最终都会委派给最顶端的启动类加载器加载
不同加载器加载的Object类都是同一个，如果没有使用双亲委派模型，各个类加载器自行去加载的话,就会出现问题
比如用户编写了一个称为java.lang.Object或String的类，并放在classpath下
那系统将会出现多个不同的Object类，Java类型体系中最基础的行为也就无法保证

（2）什么是双亲委派模型

是一种类加载机制，类加载器之间形成了一条类加载器链，每个类加载器都有一个父类加载器，形成了从下到上的一条继承链
如果所有的类加载器都无法加载该类，则会抛出 ClassNotFoundException 异常
加载流程
- 一个类的加载请求首先会被委派给其父类加载器进行处理
- 如果父类加载器无法加载该类，则会将加载请求委派给其自身进行加载
- 如果自身也无法加载该类，则会将加载请求委派给其子类加载器进行处理，直到找到能够加载该类的类加载器为止
优点
- 可以保证类的唯一性和安全性。由于每个类加载器都只能加载自己的命名空间中的类
- 由于类加载器之间形成了一条继承链，因此可以保证类的安全性，防止恶意代码的注入

在这里插入图片描述

（3）什么是JDK9模块化系统

是一种新的Java平台的组织方式，将Java SE分成多个模块，每个模块都有自己的API和实现
每个模块都有一个唯一的标识符和版本号，可以独立地进行开发、测试、部署和维护
模块之间的依赖关系通过模块描述文件（module-info.java）来声明
这个文件包含模块的名称、版本号、导出的包、依赖的模块等信息
在编译和运行时，模块系统会根据模块描述文件来加载和链接模块，确保模块之间的依赖关系正确

（4）新版本的JDK9后的类加载器

模块化系统中的类加载器可以分为两种类型
- 应用程序类加载器，加载器用于加载应用程序中的模块；平台类加载器，加载器用于加载 JDK 中的模块
- 当平台及应用程序类加载器收到类加载请求，在委派给父加载器加载前，要先判断该类是否能够归属到某一个系统模块中
- 如果findLoadedModule 可以找到这样的归属关系，就要优先委派给负责那个模块的加载器完成加载
在模块化系统中，每个模块都有一个类加载器，它根据模块的依赖关系来加载模块中的类和依赖的模块中的类
在模块化系统中，类加载器的原理与传统的类加载器相似，都是采用双亲委派模型
当一个类被加载时，类加载器首先会检查自己是否已经加载过该类，如果没有，则会将该类的加载请求委托给其父加载器
直到达到顶层的 Bootstrap ClassLoader 为止，如果所有的父加载器都无法加载该类，则由当前加载器自己来加载该类

（5）新版本的JDK9后的类加载器

模块化系统中的类加载器可以分为两种类型
- 应用程序类加载器，加载器用于加载应用程序中的模块；平台类加载器，加载器用于加载 JDK 中的模块
- 当平台及应用程序类加载器收到类加载请求，在委派给父加载器加载前，要先判断该类是否能够归属到某一个系统模块中
- 如果findLoadedModule 可以找到这样的归属关系，就要优先委派给负责那个模块的加载器完成加载
在模块化系统中，每个模块都有一个类加载器，它根据模块的依赖关系来加载模块中的类和依赖的模块中的类
在模块化系统中，类加载器的原理与传统的类加载器相似，都是采用双亲委派模型
当一个类被加载时，类加载器首先会检查自己是否已经加载过该类，如果没有，则会将该类的加载请求委托给其父加载器
直到达到顶层的 Bootstrap ClassLoader 为止，如果所有的父加载器都无法加载该类，则由当前加载器自己来加载该类

在这里插入图片描述

关键类BuiltinClassLoader
- BuiltinClassLoader 是 jdk9 中代替 URLClassLoader 的加载器，是 PlatformClassLoader 与 AppClassLoader 的父类

3.ClassLoader源码解读和自定义类加载器场景

（1）为什么需要用到自定义类加载器

为 Java 应用程序提供更加灵活和可定制的类加载机制
场景案例
- 拓展加载源
  - 从网络，数据库等地方加载类
- 防止源码泄漏
  - 自定义类加载器可以加载加密的类文件，保护类的安全性
- 实现类隔离（tomcat里面大量应用）
  - 自定义类加载器可以实现类隔离，避免类之间的冲突和干扰
  - 注意
    - 比较两个类是否相等，只有两个类是由同一个类加载器加载的前提下才有意义
    - 否则即使两个类来自同一个class文件，但是由于加载他们的类加载器不同，那这两个类就不相等
    - 不同类加载器加载同一个class文件得到的类型是不同的

（2）ClassLoader核心源码解读

loadClass
- 用于加载指定名称的类，双亲委派模型核心实现，一般不建议重写相关方法，直接由ClassLoader自己实现
- 遵循双亲委派模型，首先委派给父类加载器进行加载，如果父类加载器无法加载该类，则自身进行加载
findClass
- 是用于查找类的方法，它通常由子类加载器实现，用于查找自身命名空间中的类
- 由于历史JDK1.2之前版本兼容问题，自定义类加载器则推荐重写这个方法
- findClass()方法是在loadClass()方法中调用，当loadClass()方法中加载失败后，则调用自己的findClass()方法来完成类加载
- 但是ClassLoader的findClass没有实现，需要自己实现具体逻辑，findClass方法通常是和defineClass方法一起使用的
defindClass
- 是用于定义类的方法，它将字节数组转换为 Class 对象，并将其添加到类加载器的命名空间中
- ClassLoader方法里面已经实现，findClass方法通常是和defineClass方法一起使用的
resolveClass
- 是用于解析类的方法，它将类的引用转换为实际的类，并进行链接和初始化

		protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
        synchronized (getClassLoadingLock(name)) {
            //首先检查这个class是否已经加载过了

            Class<?> c = findLoadedClass(name);
            //c==null表示没有加载
            if (c == null) {
                long t0 = System.nanoTime();
                try {
                    // 如果有父类的加载器则让父类加载器加载
                    if (parent != null) {
                        c = parent.loadClass(name, false);
                    } else {
                    //如果父类的加载器为空 则递归到bootStrapClassloader，这里就是双亲委派模型的实现
                        c = findBootstrapClassOrNull(name);
                    }
                } catch (ClassNotFoundException e) {
                    // ClassNotFoundException thrown if class not found
                    // from the non-null parent class loader
                }

                if (c == null) {
                  /如果bootstrapClassLoader 仍然没有加载过，则自己去加载class
                    long t1 = System.nanoTime();
                  //是一个空方法，返回内容为class，方法其中没有任何内容，只抛出了个异常，说明这个方法需要开发者自己去实现
                    c = findClass(name);

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

注意两个方法区别
- findClass( ) 用于写类加载逻辑
- loadClass( )方法的逻辑里，如果父类加载器加载失败则会调用自己的findClass( )方法完成加载，保证了双亲委派规则
  - 如果不想打破双亲委派模型，那么只需要重写findClass方法即可
  - 如果想打破双亲委派模型，多数情况下需要重写整个loadClass方法

4.自定义ClassLoader类加载器案例实战

自定义类加载器流程
- 继承ClassLoader类
- 重写loadClass方法(会破坏双亲委派机制,不推荐)
- 重写findClass方法 (推荐)
先定义User类，将User.java定义成User.class

@Data
public class User {

    private String name;

    private int age;

}

javac User.java

在这里插入图片描述

编码实战
- 自定义类加载器

public class MyClassLoader extends ClassLoader{

    private String codePath;

    public MyClassLoader(String codePath){
        this.codePath = codePath;
    }

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        String fileName = codePath + name + ".class";
        System.out.println(fileName);
        //获取输入流
        try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream(fileName));
             ByteArrayOutputStream bos = new ByteArrayOutputStream();) {
            int len;
            byte[] data = new byte[1024];
            while ((len = bis.read(data)) != -1) {
                bos.write(data, 0, len);
            }
            //获取内存中字节数组
            byte[] byteCode = bos.toByteArray();
            //执行 defineClass 将字节数组转成Class对象
            Class<?> defineClass = defineClass(null, byteCode, 0, byteCode.length);
            return defineClass;
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }
}

public class Main {
    public static void main(String[] args) throws Exception {
        //测试自定义类加载器
        MyClassLoader myClassLoader = new MyClassLoader("/Users/mac/IdeaProjects/jvm-test/src/main/java/com/lixiang/");
        //加载指定类
        Class<?> clazz = myClassLoader.loadClass("User");
        //创建对像
        Object obj = clazz.getDeclaredConstructor().newInstance();
        System.out.println( "当前类："+obj.getClass().getName());
        System.out.println( "当前类加载器："+obj.getClass().getClassLoader().getClass().getName());
    }

}

在这里插入图片描述

使用自定义的类加载器进行加载。

5.不同类加载器加载同个class类

问题：两个不同的类加载器加载同一个class类，JVM是否认为它们相同

编码验证

public static void main(String[] args) throws Exception {
        //测试不同classloader加载同个class
        MyClassLoader myClassLoader = new MyClassLoader("/Users/mac/IdeaProjects/jvm-test/src/main/java/com/lixiang/");
        //用自定义的类加载器加载User.class
        Class<?> clazz = myClassLoader.loadClass("User");
        //创建对象
        Object obj = clazz.getDeclaredConstructor().newInstance();
        //判断创建的对象是否是User对象
        System.out.println("判断创建的对象是否是User对象:"+(obj instanceof User));
    }

在这里插入图片描述

				//打印相应的类加载器
        System.out.println("obj 的 类加载器："+obj.getClass().getClassLoader().getClass().getName());
        System.out.println("User 的 类加载器："+User.class.getClassLoader().getClass().getName());