T01类加载机制

类加载机制

类加载运行全过程

当我们用java命令运行某个类的main函数启动程序时，首先需要通过类加载器把主类加载到JVM

public class Math {public static final int initData = 666;public static User user = new User();public int compute() {int a = 1;int b = 2;int c = (a + b) * 10;return c;}public static void main(String[] args) {Math math = new Math();math.compute();}
}

通过Java命令执行代码的大体流程如下:

image-20240112212329370

loadClass的类加载过程有如下几步：

加载 -> 验证 -> 准备 -> 解析 -> 初始化 -> 使用 -> 卸载

  • 加载:在硬盘上查找并通过IO读入字节码文件，使用到类时才会加载，例如调用类的main()方法，new对象等等，在加载阶段会在内存中生成一个代表整个类的java.lang.Class对象，作为方法区整个类的各种数据的访问接口

  • 验证：校验字节码文件的正确性

  • 准备:给类的静态变量分配内存，并赋予默认值

  • 解析：将符号引用替换为直接引用，该阶段会把一下静态方法(符号引用、比如main（）方法)替换成指向数据所存内存的指针或句柄等(直接引用)

  • 初始化：对类的静态变量初始化为指定的值，执行静态代码块

    image-20240112213203211

类被加载到方法区后主要包含运行时常量池、类型信息、字段信息、方法信息、类加载器的引用、对应class实例的引用等消息。

类加载器的引用:这个类到类加载器实例的引用

对应class实例的引用:类加载器在加载类信息放到方法区中后，会创建一个对应的Class类型的对象实例放入堆（Heap）中，作为开发人员访问方法区中类定义的入口和切点

主类在运行过程中如果使用到其他类，会逐步加载这些类

jar包或war包里的类不是一次性全部加载的，是使用时才加载

public class TestDynamicLoad {static {System.out.println("************* load TestDynamicLoad *******************");}public static void main(String[] args) {new A();B b = null;}
}class A {static {System.out.println("******* load A *****************");}public A() {System.out.println("******** initial A ****************");}
}class B {static {System.out.println("************** load B *******************");}public B() {System.out.println("********** initial B **********");}
}// 运行结果
************* load TestDynamicLoad *******************
******* load A *****************
******** initial A ****************

类加载器和双亲委派机制

上面的类加载的过程主要是通过类加载器来实现的，Java里有如下的类加载器

  • 引导类加载器:负责加载支撑JVM运行的位于JRE的lib目录下的核心类库，比如rt.jar、charsets.jar等
  • 扩展类加载器:负责加载和支撑JVM运行的位于JRE的lib目录下的ext扩展目录中的JAR类包
  • 应用程序类加载器:负责加载ClassPath路径下的类包，
  • 自定义加载器:负责加载用户自定义路径下的类包
public class TestJDKClassLoader {public static void main(String[] args) {System.out.println(String.class.getClassLoader());System.out.println(com.sun.crypto.provider.DESKeyFactory.class.getClassLoader().getClass().getName());System.out.println(TestJDKClassLoader.class.getClassLoader().getClass().getName());System.out.println();ClassLoader appClassLoader = ClassLoader.getSystemClassLoader();ClassLoader extClassLoader = appClassLoader.getParent();ClassLoader bootstrapLoader = extClassLoader.getParent();System.out.println("the bootstrapLoader : " + bootstrapLoader);System.out.println("the extClassLoader : " + extClassLoader);System.out.println("the appClassLoader : " + appClassLoader);System.out.println();System.out.println("bootstrapLoader加载以下文件");URL[] urLs = Launcher.getBootstrapClassPath().getURLs();for (int i = 0; i < urLs.length; i++) {System.out.println(urLs[i]);}System.out.println();System.out.println("extClassLoader加载以下文件");System.out.println(System.getProperty("java.ext.dirs"));System.out.println();System.out.println("appClassLoader加载以下文件");System.out.println(System.getProperty("java.class.path"));}
}// 运行结果
null
sun.misc.Launcher$ExtClassLoader
sun.misc.Launcher$AppClassLoaderthe bootstrapLoader : null
the extClassLoader : sun.misc.Launcher$ExtClassLoader@38af3868
the appClassLoader : sun.misc.Launcher$AppClassLoader@18b4aac2bootstrapLoader加载以下文件
file:/D:/javaJdk/java1.8.0_301/jdk1.8.0_301/jre/lib/resources.jar
file:/D:/javaJdk/java1.8.0_301/jdk1.8.0_301/jre/lib/rt.jar
file:/D:/javaJdk/java1.8.0_301/jdk1.8.0_301/jre/lib/sunrsasign.jar
file:/D:/javaJdk/java1.8.0_301/jdk1.8.0_301/jre/lib/jsse.jar
file:/D:/javaJdk/java1.8.0_301/jdk1.8.0_301/jre/lib/jce.jar
file:/D:/javaJdk/java1.8.0_301/jdk1.8.0_301/jre/lib/charsets.jar
file:/D:/javaJdk/java1.8.0_301/jdk1.8.0_301/jre/lib/jfr.jar
file:/D:/javaJdk/java1.8.0_301/jdk1.8.0_301/jre/classesextClassLoader加载以下文件
D:\javaJdk\java1.8.0_301\jdk1.8.0_301\jre\lib\ext;C:\Windows\Sun\Java\lib\extappClassLoader加载以下文件
D:\javaJdk\java1.8.0_301\jdk1.8.0_301\jre\lib\charsets.jar;D:\javaJdk\java1.8.0_301\jdk1.8.0_301\jre\lib\deploy.jar;D:\javaJdk\java1.8.0_301\jdk1.8.0_301\jre\lib\ext\access-bridge-64.jar;D:\javaJdk\java1.8.0_301\jdk1.8.0_301\jre\lib\ext\cldrdata.jar;D:\javaJdk\java1.8.0_301\jdk1.8.0_301\jre\lib\ext\dnsns.jar;D:\javaJdk\java1.8.0_301\jdk1.8.0_301\jre\lib\ext\jaccess.jar;D:\javaJdk\java1.8.0_301\jdk1.8.0_301\jre\lib\ext\jfxrt.jar;D:\javaJdk\java1.8.0_301\jdk1.8.0_301\jre\lib\ext\localedata.jar;D:\javaJdk\java1.8.0_301\jdk1.8.0_301\jre\lib\ext\nashorn.jar;D:\javaJdk\java1.8.0_301\jdk1.8.0_301\jre\lib\ext\sunec.jar;D:\javaJdk\java1.8.0_301\jdk1.8.0_301\jre\lib\ext\sunjce_provider.jar;D:\javaJdk\java1.8.0_301\jdk1.8.0_301\jre\lib\ext\sunmscapi.jar;D:\javaJdk\java1.8.0_301\jdk1.8.0_301\jre\lib\ext\sunpkcs11.jar;D:\javaJdk\java1.8.0_301\jdk1.8.0_301\jre\lib\ext\zipfs.jar;D:\javaJdk\java1.8.0_301\jdk1.8.0_301\jre\lib\javaws.jar;D:\javaJdk\java1.8.0_301\jdk1.8.0_301\jre\lib\jce.jar;D:\javaJdk\java1.8.0_301\jdk1.8.0_301\jre\lib\jfr.jar;D:\javaJdk\java1.8.0_301\jdk1.8.0_301\jre\lib\jfxswt.jar;D:\javaJdk\java1.8.0_301\jdk1.8.0_301\jre\lib\jsse.jar;D:\javaJdk\java1.8.0_301\jdk1.8.0_301\jre\lib\management-agent.jar;D:\javaJdk\java1.8.0_301\jdk1.8.0_301\jre\lib\plugin.jar;D:\javaJdk\java1.8.0_301\jdk1.8.0_301\jre\lib\resources.jar;D:\javaJdk\java1.8.0_301\jdk1.8.0_301\jre\lib\rt.jar;E:\myproject\tuling\jvm\jvm\out\production\jvm;D:\devtools\IntelliJ IDEA Community Edition 2023.2.5\lib\idea_rt.jar

类加载器初始化过程

创建JVM启动器实例sun.misc.Launcher

在Launcher构造器方法内部，其创建了两个类加载器，分别是sun.misc.Launcher.ExtClassLoader（扩展类加载器）和sun.misc.Launcher.AppClassLoader（应用类加载器）

JVM默认使用Launcher的getClassLoader()方法返回的类加载器AppClassLoader的实例加载我们的应用程序

//Launcher的构造方法
public Launcher() {Launcher.ExtClassLoader var1;try {//构造扩展类加载器，在构造的过程中将其父加载器设置为nullvar1 = Launcher.ExtClassLoader.getExtClassLoader();} catch (IOException var10) {throw new InternalError("Could not create extension class loader", var10);}try {//构造应用类加载器，在构造的过程中将其父加载器设置为ExtClassLoader，//Launcher的loader属性值是AppClassLoader，我们一般都是用这个类加载器来加载我们自己写的应用程序this.loader = Launcher.AppClassLoader.getAppClassLoader(var1);} catch (IOException var9) {throw new InternalError("Could not create application class loader", var9);}Thread.currentThread().setContextClassLoader(this.loader);String var2 = System.getProperty("java.security.manager");。。。 。。。 //省略一些不需关注代码}

双亲委派机制

image-20240116225107964

加载某个类的时会先为委托父加载器寻找目标类，找不到再委托上层父加载器加载，如果所有父加载器在自己的加载类路径下都找不到目标类，则在自己的类路径下查找并载入目标类

应用程序类加载器AppClassLoader加载类的双亲委派机制源码，AppClassLoader的loadClass方法最终会调用其父类ClassLoader的loadClass方法，该方法的大体逻辑如下（java.lang.ClassLoader）:

  • 首先，检查以下指定名称的类是否已经被加载过，如果加载过了，就不需要再加载，直接返回
  • 如果此类没有加载过，那么再判断一下是否有父加载器，如果有父加载器，(即调用parent.loadclass(name, false))或者是调用bootstrap类加载器来加载
  • 如果父加载器及bootstrap类加载器都没有找到指定的类，那么调用当前类加载器的findClass方法来完成类加载
//ClassLoader的loadClass方法，里面实现了双亲委派机制
protected Class<?> loadClass(String name, boolean resolve)throws ClassNotFoundException
{synchronized (getClassLoadingLock(name)) {// 检查当前类加载器是否已经加载了该类Class<?> c = findLoadedClass(name);if (c == null) {long t0 = System.nanoTime();try {if (parent != null) {  //如果当前加载器父加载器不为空则委托父加载器加载该类c = parent.loadClass(name, false);} else {  //如果当前加载器父加载器为空则委托引导类加载器加载该类c = findBootstrapClassOrNull(name);}} catch (ClassNotFoundException e) {// ClassNotFoundException thrown if class not found// from the non-null parent class loader}if (c == null) {// If still not found, then invoke findClass in order// to find the class.long t1 = System.nanoTime();//都会调用URLClassLoader的findClass方法在加载器的类路径里查找并加载该类c = findClass(name);// this is the defining class loader; record the statssun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);sun.misc.PerfCounter.getFindClasses().increment();}}if (resolve) {  //不会执行resolveClass(c);}return c;}
}

为什么要设计双亲委派机制

  • 沙箱安全机制：自己写的java.lang.String.class类不会被加载，这样便可以防止核心API库被随意篡改
  • 避免类的重复加载：当父亲已经加载了该类的时候，就没有必要子ClassLoader再加载一次，保证被加载类的唯一性

全盘负责委托机制

“全盘负责”是指当一个ClassLoader装载一个类时，除非显式的使用另外一个ClassLoader，该类所依赖及引用的类也由这个ClassLoader载入

自定义类记载器实例

自定义类加载器只需要继承 java.lang.ClassLoader类，该类有两个核心方法，一个是loadClass（String，boolean)，实现了双亲委派机制，还有一个方法是findClass，默认实现是空方法，所以外面自定义类加载器主要是重写findClass方法

public class MyClassLoaderTest {static class MyClassLoader extends ClassLoader {private String classPath;public MyClassLoader(String classPath) {this.classPath = classPath;}private byte[] loadByte(String name) throws Exception {name = name.replaceAll("\\.", "/");FileInputStream fis = new FileInputStream(classPath + "/" + name+ ".class");int len = fis.available();byte[] data = new byte[len];fis.read(data);fis.close();return data;}@Overrideprotected Class<?> findClass(String name) throws ClassNotFoundException {try {byte[] data = loadByte(name);//defineClass将一个字节数组转为Class对象，这个字节数组是class文件读取后最终的字节数组。return defineClass(name, data, 0, data.length);} catch (Exception e) {e.printStackTrace();throw new ClassNotFoundException();}}}public static void main(String[] args) throws Exception {//初始化自定义类加载器，会先初始化父类ClassLoader，其中会把自定义类加载器的父加载器设置为应用程序类加载器AppClassLoaderMyClassLoader classLoader = new MyClassLoader("D:/test");//D盘创建 test/com/tuling/jvm 几级目录，将User类的复制类User1.class丢入该目录Class clazz = classLoader.loadClass("com.tuling.jvm.User1");Object obj = clazz.newInstance();Method method = clazz.getDeclaredMethod("sout", null);method.invoke(obj, null);System.out.println(clazz.getClassLoader().getClass().getName());}
}

打破双亲委派机制

    static class MyClassLoader extends ClassLoader {private String classPath;public MyClassLoader(String classPath) {this.classPath = classPath;}private byte[] loadByte(String name) throws Exception {name = name.replaceAll("\\.", "/");FileInputStream fis = new FileInputStream(classPath + "/" + name+ ".class");int len = fis.available();byte[] data = new byte[len];fis.read(data);fis.close();return data;}@Overrideprotected Class<?> findClass(String name) throws ClassNotFoundException {try {byte[] data = loadByte(name);return defineClass(name, data, 0, data.length);} catch (Exception e) {e.printStackTrace();throw new ClassNotFoundException();}}/*** 重写类加载方法，实现自己的加载逻辑，不委派给双亲加载* @param name* @param resolve* @return* @throws ClassNotFoundException*/@Overrideprotected Class<?> loadClass(String name, boolean resolve)throws ClassNotFoundException {synchronized (getClassLoadingLock(name)) {// First, check if the class has already been loadedClass<?> c = findLoadedClass(name);if (c == null) {// If still not found, then invoke findClass in order// to find the class.long t1 = System.nanoTime();c = findClass(name);// this is the defining class loader; record the statssun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);sun.misc.PerfCounter.getFindClasses().increment();}if (resolve) {resolveClass(c);}return c;}}}public static void main(String args[]) throws Exception {MyClassLoader classLoader = new MyClassLoader("D:/test");//尝试用自己改写类加载机制去加载自己写的java.lang.String.classClass clazz = classLoader.loadClass("java.lang.String");Object obj = clazz.newInstance();Method method= clazz.getDeclaredMethod("sout", null);method.invoke(obj, null);System.out.println(clazz.getClassLoader().getClass().getName());}
Tomcat打破双亲委派机制

为什么Tomcat要打破双亲委派机制

  • 一个web容器可能需要部署两个应用程序，不同的应用程序可能会依赖同一个第三方类库的不同版本，不能要求同一个类库在同一个服务器只有一份，因此要保证每个应用程序的类库都是独立的，保证相互隔离。
  • 部署在同一个web容器中相同的类库相同的版本可以共享。否则，如果服务器有10个应用程序，那么要有10份相同的类库加载进虚拟机。
  • web容器也有自己依赖的类库，不能与应用程序的类库混淆。基于安全考虑，应该让容器的类库和程序的类库隔离开来。
  • web容器要支持jsp的修改，我们知道，jsp 文件最终也是要编译成class文件才能在虚拟机中运行，但程序运行后修改jsp已经是司空见惯的事情， web容器需要支持 jsp 修改后不用重启。

Tomcat使用默认的双亲委派类加载机制行不行

  • 如果使用默认的类加载器机制，那么是无法加载两个相同类库的不同版本的，默认的类加器是不管你是什么版本的，只在乎你的全限定类名，并且只有一份。
  • 默认的类加载器是能够实现的，因为他的职责就是保证唯一性。
  • 我们再看第四个问题，我们想我们要怎么实现jsp文件的热加载，jsp 文件其实也就是class文件，那么如果修改了，但类名还是一样，类加载器会直接取方法区中已经存在的，修改后的jsp是不会重新加载的。那么怎么办呢？我们可以直接卸载掉这jsp文件的类加载器，所以你应该想到了，每个jsp文件对应一个唯一的类加载器，当一个jsp文件修改了，就直接卸载这个jsp类加载器。重新创建类加载器，重新加载jsp文件。

image-20240306205804185

Tomcat的几个主要类加载器

  • commonLoader：Tomcat最基本的类加载器，加载路径中的class可以被Tomcat容器本身以及各个Webapp访问
  • catalinaLoader：Tomcat容器私有的类加载器，加载路径中的class对于Webapp不可见
  • sharedLoader：各个Webapp共享的类加载器，加载路径中的class对于所有Webapp可见，但是对于Tomcat容器不可见；
  • WebappClassLoader：各个Webapp私有的类加载器，加载路径中的class只对当前Webapp可见，比如加载war包里相关的类，每个war包应用都有自己的WebappClassLoader，实现相互隔离，比如不同war包应用引入了不同的spring版本，这样实现就能加载各自的spring版本；

从图中的委派关系中可以看出：

CommonClassLoader能加载的类都可以被CatalinaClassLoader和SharedClassLoader使用，从而实现了公有类库的共用，而CatalinaClassLoader和SharedClassLoader自己能加载的类则与对方相互隔离。

WebAppClassLoader可以使用SharedClassLoader加载到的类，但各个是WebAppClassLoader实例之间相互隔离。

而JasperLoader的加载范围仅仅是这个JSP文件所编译出来的那一个.Class文件，它出现的目的就是为了被丢弃：当Web容器检测到JSP文件被修改时，会替换掉目前的JasperLoader的实例，并通过再建立一个新的Jsp类加载器来实现JSP文件的热加载功能。

每个webappClassLoader加载自己的目录下的class文件，不会传递给父类加载器，打破了双亲委派机制。

Hotspot源码JVM启动执行main方法流程

image-20240306210156339

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.hqwc.cn/news/519596.html

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

[LeetCode][239]【学习日记】滑动窗口最大值——O(n)单调队列

[LeetCode][239]【学习日记】滑动窗口最大值——O(n)单调队列

题目 239. 滑动窗口最大值 难度&#xff1a;困难相关标签相关企业提示 给你一个整数数组 nums&#xff0c;有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。 返回滑动窗口中的最大值。 示例 1…
阅读更多...
Vue中如何处理用户权限？

Vue中如何处理用户权限？

在前端开发中&#xff0c;处理用户权限是非常重要的一个方面。Vue作为一种流行的前端框架&#xff0c;提供了很多便捷的方式来管理用户权限。本文将介绍一些Vue中处理用户权限的方法 1. 使用路由守卫 Vue Router提供了一个功能强大的功能&#xff0c;即导航守卫&#xff08;N…
阅读更多...
testvue-个人中心

testvue-个人中心

header.vue（右上角） <template><div class="header"><!-- 折叠按钮 --><div class="collapse-btn" @click="collapseChage"><i v-if="!collapse" class="el-icon-s-fold"></i><…
阅读更多...
使用java批量写入环境变量

使用java批量写入环境变量

环境需求 jdk版本&#xff1a;1.8 jna依赖&#xff1a; <dependency><groupId>net.java.dev.jna</groupId><artifactId>jna</artifactId><version>5.10.0</version></dependency><dependency><groupId>net.java.…
阅读更多...
培训机构新助力：教务管理工教务管理新境界：完善流程，高效运营触手可及具

培训机构新助力：教务管理工教务管理新境界：完善流程，高效运营触手可及具

随着科技的不断进步&#xff0c;教育领域正迎来一场革命性的变革。乔拓云教育系统&#xff0c;作为这场变革的引领者&#xff0c;正以其卓越的功能和高效的解决方案&#xff0c;为培训机构带来前所未有的教务管理新篇章。 一、高效排课&#xff0c;让教务管理更轻松 乔拓云教育…
阅读更多...
模型部署——rknn-toolkit-lite2部署RKNN模型到开发板上（python版）

模型部署——rknn-toolkit-lite2部署RKNN模型到开发板上（python版）

在RKNN模型部署前&#xff0c;需要注意以下几点&#xff1a; &#xff08;1&#xff09;硬件平台兼容性: 确保你的开发板与 RKNN Toolkit Lite2 兼容。目前&#xff0c;RKNN Toolkit Lite2 支持 Rockchip RK3566、RK3588、RK3399 等平台。 确认开发板的 NPU 型号和版本与 RKNN…
阅读更多...
1.BOM-获取元素(获取元素、修改属性)

1.BOM-获取元素(获取元素、修改属性)

web Api基本认知 作用&#xff1a;通过JS去操作html页面和浏览器(实现浏览器中的某些功能) 分类&#xff1a; DOM(网页)&#xff1a;Document Object Model(文档对象模型) BOM(浏览器)&#xff1a;Borwser Object Model(浏览器对象模型) DOM DOM树 将网页中标签的关系以树状…
阅读更多...
数字孪生10个技术栈：数据处理的六步骤，以获得可靠数据。

数字孪生10个技术栈：数据处理的六步骤，以获得可靠数据。

一、什么是数据处理 在数字孪生中&#xff0c;数据处理是指对采集到的实时或历史数据进行整理、清洗、分析和转化的过程。数据处理是数字孪生的基础&#xff0c;它将原始数据转化为有意义的信息&#xff0c;用于模型构建、仿真和决策支持。 数据处理是为了提高数据质量、整合数…
阅读更多...
Frida-Hook-Native层操作大全

Frida-Hook-Native层操作大全

前期准备 使用 jadx 进行逆向工程的基础知识。能够理解 Java 代码。能够编写简短的 JavaScript 代码片段。熟悉 adb。已 root 的设备。对 x86/ARM64 汇编和逆向工程有基础了解。 1、Hook Native层中调用的函数并且读取传入的参数 对于Native层的函数Hook&#xff0c;我们使用…
阅读更多...
计算阶梯数 Python

计算阶梯数 Python

题目描述 爱因斯坦曾出过这样一道有趣的数学题&#xff1a; 有一个长阶梯&#xff0c; 若每步上2阶&#xff0c;最后剩1阶&#xff1b; 若每步上3阶&#xff0c;最后剩2阶&#xff1b; 若每步上5阶&#xff0c;最后剩4阶&#xff1b; 若每步上6阶&#xff0c;最后剩5阶&#xf…
阅读更多...
MES+APS难度地狱级，搞定它就是劫后余生呀。

MES+APS难度地狱级，搞定它就是劫后余生呀。

一、什么是MES和APS MES&#xff08;Manufacturing Execution System&#xff09;和APS&#xff08;Advanced Planning and Scheduling&#xff09;是两种在制造业中常用的软件系统&#xff0c;用于优化生产过程和提高生产效率。 MES是一种用于管理和监控制造过程的系统。它与…
阅读更多...
九：多播和广播

九：多播和广播

1 多播 &emsp 多播(Multicast )方式的数据传输是基于UDP完成的。 因此&#xff0c;与UDP服务器端/客户端的实现方式非常接近。 区别在于&#xff0c; UDP数据传输以单一目标进行&#xff0c;而多播数据同时传递到加入(注册)特定组的大量主机。 换言之&#xff0c;采用多播…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023