【Java虚拟机】JVM类加载机制和双亲委派模型-阿里云开发者社区

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());

在 JVM 中，不同类加载器加载同一个类时，可能会出现重复加载的情况

当不同类加载器加载同一个类时，每个类加载器都会在自己的命名空间中创建一个新的 Class 对象

即使这些 Class 对象的字节码是一样的，也会被认为是不同的类

重复加载同一个类会导致一些问题，例如类的静态变量和代码块会被多次执行，导致出现意料之外的行为

JVM 采用了类的双亲委派模型来避免重复加载同一个类

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

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

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

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

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

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

热门文章

最新文章

相关课程

相关电子书

相关实验场景