深入浅出JVM(八)之类加载器

Android解析ClassLoader(一)Java中的ClassLoader 热修复和插件化是目前比较热门的技术,要想更好的掌握它们需要了解ClassLoader,因此也就有了本系列的产生,这一篇我们先来学习Java中的ClassLoader。 阅读详情

 本篇文章将重点聊聊类加载器,围绕类加载器深入浅出的解析类加载器的分类、种类、双亲委派模型以及从源码方面推导出我们的结论

类加载器简介

什么是类加载器?

类加载器通过类的全限定类名进行类加载机制从而生成Class对象

Class对象中包含该类相关类信息,通过Class对象能够使用反射在运行时阶段动态做一些事情

显示加载与隐式加载

类加载器有两种方式进行加载,一种是在代码层面显示的调用,另一种是当程序遇到创建对象等命令时自行判断该类是否进行过加载,未加载就先进行类加载

显示加载:显示调用ClassLoader加载class对象

隐式加载:不显示调用ClassLoader加载class对象(因为虚拟机会在第一次使用到某个类时自动加载这个类)

 //显示类加载  第7章虚拟机类加载机制.User为全限定类名(包名+类名)
 Class.forName("第7章虚拟机类加载机制.User");
             
 //隐式类加载
 new User();    

唯一性与命名空间

判断两个类是否完全相同可能并不是我们自认为理解的那样,类在JVM中的唯一性需要根据类本身和加载它的类加载器

  • 唯一性

    • 所有类都由它本身和加载它的那个类在JVM中确定唯一性
    • 也就是说判断俩个类是否为同一个类时,如果它们的类加载器都不同那肯定不是同一个类
  • 命名空间

    • 每个类加载有自己的命名空间,命名空间由所有父类加载器和该加载器所加载的类组成
    • 同一命名空间中,不存在类完整名相同的俩个类
    • 不同命名空间中,允许存在类完整名相同的俩个类(多个自定义类加载加载同一个类时,会在各个类加载器中生成对应的命名,且它们都不是同一个类)

基本特征

类加载器中有一些基本特性,比如子类加载器可以访问父类加载器所加载的类、父类加载过的类子类不再加载、双亲委派模型等

  • 可见性

    • 子类加载器可以访问父类加载器所加载的类*
    • (命名空间包含父类加载器加载的类)
  • 单一性

    • 因为可见性,所以父类加载器加载过的类,子类加载器不会再加载
    • 同一级的自定义类加载器可能都会加载同一个类,因为它们互不可见
  • 双亲委派模型

    • 由哪个类加载器来进行类加载的一套策略,后续会详细说明
类加载器分类

类加载器可以分成两种,一种是引导类由非Java语言实现的,另一种是由Java语言实现的自定义类加载器

  • 引导类加载器 (c/c++写的Bootstrap ClassLoader)
  • 自定义类加载器:由ClassLoader类派生的类加载器类(包括扩展类,系统类,程序员自定义加载器等)

系统(应用程序)类加载器和扩展类加载器是Launcher的内部类,它们间接实现了ClassLoader

注意

image-20210516203457475.png

平常说的系统(应用程序)类加载器的父类加载器是扩展类加载器,而扩展类加载器的父类加载器是启动类加载器,都是"逻辑"上的父类加载器

实际上扩展类加载器和系统(应用程序)类加载器间接继承的ClassLoader中有一个字段parent用来表示自己的逻辑父类加载器

类加载器种类
  • 启动(引导)类加载器

    • Bootstrap Classloader c++编写,无法直接获取
    • 加载核心库<JAVA_HOME>\lib\部分jar包
    • 不继承java.lang.ClassLoader,没有父类加载器
    • 加载扩展类加载器和应用程序类加载器,并指定为它们的父类加载器
  • 扩展类加载器

    • Extension Classloader
    • 加载扩展库<JAVA_HOME>\lib\ext*.jar
    • 间接继承java.lang.ClassLoader,父类加载器为启动类加载器
  • 应用程序(系统)类加载器

    • App(System) Classloader 最常用的加载器
    • 负责加载环境变量classpath或java.class.path指定路径下的类库 ,一般加载我们程序中自定义的类
    • 间接继承java.lang.ClassLoader,父类加载器为扩展类加载器
    • 使用ClassLoader.getSystemClassLoader()获得
  • 自定义类加载器(实现ClassLoader类,重写findClass方法)

通过代码来演示:

 public class TestClassLoader {
     public static void main(String[] args) {
         URL[] urLs = Launcher.getBootstrapClassPath().getURLs();
         /*
         启动类加载器能加载的api路径:
         file:/D:/Environment/jdk1.8.0_191/jre/lib/resources.jar
         file:/D:/Environment/jdk1.8.0_191/jre/lib/rt.jar
         file:/D:/Environment/jdk1.8.0_191/jre/lib/sunrsasign.jar
         file:/D:/Environment/jdk1.8.0_191/jre/lib/jsse.jar
         file:/D:/Environment/jdk1.8.0_191/jre/lib/jce.jar
         file:/D:/Environment/jdk1.8.0_191/jre/lib/charsets.jar
         file:/D:/Environment/jdk1.8.0_191/jre/lib/jfr.jar
         file:/D:/Environment/jdk1.8.0_191/jre/classes
         */
         System.out.println("启动类加载器能加载的api路径:");
         for (URL urL : urLs) {
             System.out.println(urL);
         } 
 ​
         /*
         扩展类加载器能加载的api路径:
         D:\Environment\jdk1.8.0_191\jre\lib\ext;C:\WINDOWS\Sun\Java\lib\ext
         */
         System.out.println("扩展类加载器能加载的api路径:");
         String property = System.getProperty("java.ext.dirs");
         System.out.println(property);
         
         //加载我们自定义类的类加载器是AppClassLoader,它是Launcher的内部类
         ClassLoader appClassLoader = TestClassLoader.class.getClassLoader();
         //sun.misc.Launcher$AppClassLoader@18b4aac2 
         System.out.println(appClassLoader);
         
         //AppClassLoader的上一层加载器是ExtClassLoader,它也是Launcher的内部类
         ClassLoader extClassloader = appClassLoader.getParent();
         //sun.misc.Launcher$ExtClassLoader@511d50c0
         System.out.println(extClassloader);
         
         //实际上是启动类加载器,因为它是c/c++写的,所以显示null
         ClassLoader bootClassloader = extClassloader.getParent();
         //null 
         System.out.println(bootClassloader);
         
         //1号测试:基本类型数组 的类加载器
         int[] ints = new int[10];
         //null 
         System.out.println(ints.getClass().getClassLoader());
         
         //2号测试:系统提供的引用类型数组 的类加载器
         String[] strings = new String[10];
         //null 
         System.out.println(strings.getClass().getClassLoader());
         
         //3号测试:自定义引用类型数组 的类加载器
         TestClassLoader[] testClassLoaderArray = new TestClassLoader[10];
         //sun.misc.Launcher$AppClassLoader@18b4aac2       
         System.out.println(testClassLoaderArray.getClass().getClassLoader());
 ​
         //4号测试:线程上下文的类加载器
         //sun.misc.Launcher$AppClassLoader@18b4aac2
         System.out.println(Thread.currentThread().getContextClassLoader());
     }
 }

从上面可以得出结论

  1. 数组类型的类加载器是数组元素的类加载器(通过2号测试与3号测试的对比)
  2. 基本类型不需要类加载 (通过1号测试与3号测试的对比)
  3. 线程上下文类加载器是系统类加载器 (通过4号测试)
关于类加载源码解析
用源码来解释上文结论
  • ClassLoader中的官方注释

image-20210516222159652.png

虚拟机自动生成的一个类,管理数组,会对这个类进行类加载

对数组类类加载器是数组元素的类加载器

如果数组元素是基本类型则不会有类加载器

  • 源码解释扩展类加载器的父类是null

image-20210516221509952.png

  • 源码解释系统类加载器的父类是扩展类加载器

image-20210516214113943.png

  • 源码解释线程上下文类加载器是系统类加载器

image-20210516221726540.png

ClassLoader主要方法

loadClass()

ClassLoader的 loadClass方法(双亲委派模型的源码)

 public Class<?> loadClass(String name) throws ClassNotFoundException {
     return loadClass(name, false);
 }
                                             //参数resolve:是否要解析类
 protected Class<?> loadClass(String name, boolean resolve)
             throws ClassNotFoundException
     {
        //加锁同步 保证只加载一次
         synchronized (getClassLoadingLock(name)) {
             // 首先检查这个class是否已经加载过了
             Class<?> c = findLoadedClass(name);
             if (c == null) {
                 long t0 = System.nanoTime();
                 try {
                     // c==null表示没有加载,如果有父类的加载器则让父类加载器加载
                     if (parent != null) {
                         c = parent.loadClass(name, false);
                     } else {
                         //如果父类的加载器为空 则说明递归到bootStrapClassloader了
                         //则委托给BootStrap加载器加载
                         //bootStrapClassloader比较特殊无法通过get获取
                         c = findBootstrapClassOrNull(name);
                     }
                 } catch (ClassNotFoundException e) {
                     //父类无法加载抛出异常
                 }
                 //如果父类加载器仍然没有加载过,则尝试自己去加载class
                 if (c == null) {
                     long t1 = System.nanoTime();
                     c = findClass(name);
                     sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
                     sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
                     sun.misc.PerfCounter.getFindClasses().increment();
                 }
             }
             //是否要解析
             if (resolve) {
                 resolveClass(c);
             }
             return c;
         }
 }

先递归交给父类加载器去加载,父类加载器未加载再由自己加载

findClass()

ClassLoader的findClass()

 

     protected Class<?> findClass(String name) throws ClassNotFoundException {
         throw new ClassNotFoundException(name);
     }

由子类URLClassLoader重写findClass去寻找类的规则

image-20210516225918213.png

最后都会来到defineClass()方法

defineClass()

 protected final Class<?> defineClass(String name, byte[] b, int off, int len)

 

根据从off开始长度为len定字节数组b转换为Class实例

在自定义类加载器时,覆盖findClass()编写加载规则,取得要加载的类的字节码后转换为流调用defineClass()生成Class对象

resolveClass()

     protected final void resolveClass(Class<?> c) {
         resolveClass0(c);
     }

 

使用该方法可以在生成Class对象后,解析类(符号引用 -> 直接引用)

findLoadedClass()

     protected final Class<?> findLoadedClass(String name) {
         if (!checkName(name))
             return null;
         return findLoadedClass0(name);
     }

 

如果加载过某个类则返回Class对象否则返回null

Class.forName()与ClassLoader.loadClass()区别
  • Class.forName()

    • 传入一个类的全限定名返回一个Class对象
    • 将Class文件加载到内存时会初始化,主动引用
  • ClassLoader.loadClass()

    • 需要class loader对象调用
    • 通过上面的源码分析可以知道,双亲委派模型调用loadClass,只是将Class文件加载到内存,不会初始化和解析,直到这个类第一次使用才进行初始化
双亲委派模型

双亲委派模型源码实现对应ClassLoader的loadClass()

  • 分析:

    1. 先检查这个类是否加载过

    2. 没有加载过,查看父类加载器是否为空,

      如果不为空,就交给父类加载器去加载(递归),

      如果为空,说明已经到启动类加载器了(启动类加载器不能get因为是c++写的)

    3. 如果父类加载器没有加载过,则递归回来自己加载

  • 举例

    1. 假如我现在自己定义一个MyString类,它会自己找(先在系统类加载器中找,然后在扩展类加载器中找,最后去启动类加载器中找,启动类加载器无法加载然后退回扩展类加载器,扩展类加载器无法加载然后退回系统类加载器,然后系统类加载器就完成加载)

    2. 我们都知道Java有java.lang.String这个类

      那我再创建一个java.lang.String运行时,报错

      image-20200328155339760.png

      可是我明明写了main方法

      这是因为类装载器的沙箱安全机制

      很明显这里的报错是因为它找到的是启动类加载器中的java.lang.String而不是在应用程序类加载器中的java.lang.String(我们写的)

      而且核心类库的包名也是被禁止使用的

      image-20210425231816778.png

    类装载器的加载机制:启动类加载器->扩展类加载器->应用程序类加载器

    1. 如果自定义类加载器重写loadClass不使用双亲委派模型是否就能够用自定义类加载器加载核心类库了呢?

      JDK为核心类库提供一层保护机制,不管用什么类加载器最终都会调用defineClass(),该方法会执行preDefineClass(),它提供对JDK核心类库的保护

      image-20210517103634644.png

  • 优点

    1. 防止重复加载同一个class文件
    2. 保证核心类不能被篡改
  • 缺点

    • 父类加载器无法访问子类加载器

      • 比如系统类中提供一个接口,实现这个接口的实现类需要在系统类加载器加载,而该接口提供静态工厂方法用于返回接口的实现类的实例,但由于启动类加载器无法访问系统类加载器,这时静态工厂方法就无法创建由系统类加载器加载的实例
  • Java虚拟机规范只是建议使用双亲委派模型,不是一定要使用

    • Tomcat中是由自己先去加载,加载失败再由父类加载器去加载
自定义类加载器
  1. 继承ClassLoader类

  2. 可以覆写loadClass方法,也可以覆写findClass方法

    • 建议覆写findClass方法,因为loadClass是双亲委派模型实现的方法,其中父类类加载器加载不到时会调用findClass尝试自己加载
  3. 编写好后调用loadClass方法来实现类加载

自定义类加载器代码

public class MyClassLoader extends ClassLoader {

    /**
     * 字节码文件路径
     */
    private final String codeClassPath;

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

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        //字节码文件完全路径
        String path = codeClassPath + name + ".class";
        System.out.println(path);

        Class<?> aClass = null;
        try (
                BufferedInputStream bis = new BufferedInputStream(new FileInputStream(path));
                ByteArrayOutputStream baos = new ByteArrayOutputStream()
        ) {
            int len = -1;
            byte[] bytes = new byte[1024];
            while ((len = bis.read(bytes)) != -1) {
                baos.write(bytes,0,len);
            }
            byte[] classCode = baos.toByteArray();
            //用字节码流 创建 Class对象
            aClass = defineClass(null, classCode, 0, classCode.length);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return aClass;
    }
}

客户端调用自定义类加载器加载类

public class Client {
    public static void main(String[] args) {
        MyClassLoader myClassLoader = new MyClassLoader("C:\");
        try {
            Class<?> classLoader = myClassLoader.loadClass("HotTest");
            System.out.println("类加载器为:" + classLoader.getClassLoader().getClass().getName());
            System.out.println("父类加载器为" + classLoader.getClassLoader().getParent().getClass().getName());
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

记得对要加载的类先进行编译

image-20210517123408569.png

  • 注意:

    • 要加载的类不要放在父类加载器可以加载的目录下
    • 自定义类加载器父类加载器为系统类加载器
    • JVM所有类类加载都使用loadClass

解释如果类加载器不同那么它们肯定不是同一个类

	MyClassLoader myClassLoader1 = new MyClassLoader("D:\代码\JavaVirtualMachineHotSpot\src\main\java\");
        MyClassLoader myClassLoader2 = new MyClassLoader("D:\代码\JavaVirtualMachineHotSpot\src\main\java\");
        try {
            Class<?> aClass1 = myClassLoader1.findClass("HotTest");
            Class<?> aClass2 = myClassLoader2.findClass("HotTest");
            System.out.println(aClass1 == aClass2);//false
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

 

  • 优点

    • 隔离加载类 (各个中间件jar包中类名可能相同,但自定义类加载器不同)
    • 修改类加载方式
    • 扩展加载源 (可以从网络,数据库中进行加载)
    • 防止源码泄漏 (Java反编译容易,可以编译时进行加密,自定义类加载解码字节码)
热替换

热替换: 服务不中断,修改会立即表现在运行的系统上

对Java来说,如果一个类被类加载器加载过了,就无法被再加载了

但是如果每次加载这个类的类加载不同,那么就可以实现热替换

还是使用上面写好的自定义类加载器

        //测试热替换
        try {
            while (true){
                MyClassLoader myClassLoader = new MyClassLoader("D:\代码\JavaVirtualMachineHotSpot\src\main\java\");
                
                Class<?> aClass = myClassLoader.findClass("HotTest");
                Method hot = aClass.getMethod("hot");
                Object instance = aClass.newInstance();
                Object invoke = hot.invoke(instance);
                TimeUnit.SECONDS.sleep(3);
            }
        } catch (Exception e){
            e.printStackTrace();
        }

通过反射调用HotTest类的hot方法

中途修改hot方法并重新编译

image-20210517124720782.png

总结

本篇文章围绕类加载器深入浅出的解析类加载器的分类与种类、双亲委派模型、通过源码解析证实我们的观点、最后还自定义的类加载器和说明热替换

类加载器将字节码文件进行类加载机制生成Class对象从而加载到Java虚拟机中

类加载只会进行一次,能够显示调用执行或者在遇到创建对象的字节码命令时隐式判断是否进行过类加载

类加载器分为非Java语言实现的引导类加载器和Java语言实现的自定义类加载器,其中JDK中实现了自定义类加载器中的扩展类加载器和系统类加载器

引导类加载器用来加载Java的核心类库,它的子类扩展类加载器用来加载扩展类,扩展类的子类系统类加载器常用于加载程序中自定义的类(这里的父子类是逻辑的,并不是代码层面的继承)

双亲委派模型让父类加载器优先进行加载,无法加载再交给子类加载器进行加载;通过双亲委派模型和沙箱安全机制来保护核心类库不被其他恶意代码替代

基本类型不需要类加载、数组类型的类加载器是数组元素的类加载器、线程上下文类加载器是系统类加载器

由于类和类加载器才能确定JVM中的唯一性,每次加载类的类加载不同时就能够多次进行类加载从而实现在运行时修改的热替换

JVM的三种类加载器 干java程序员有一段时间了,但是对JVM是怎么加载类的一直是懵懵懂懂,看了一些博客,现把自己对JVM的类加载器的一些理解和大家分享一下。 咱们的类经过javac编译后,生成.class文件保存下来,然后经过类加载器加载类至内存,生成java.lang.Class类的实例,这个实例就是程序访问这个类的入口,通过这个class实例的newInstance方法即可得到这个类的实例... 阅读详情

相关推荐

JVM系列之类加载器

前言 上节我们介绍了类加载的时机和过程,对类加载有了个初步的认识,上节我们有不断提到一个东西:类加载器,那么什么是类加载器?又有哪些类加载器?类加载器之间的联系等等一些问题,今天我们将会围绕这些点展开,那么,开始我们今天的JVM之旅吧。 什么是类加载器? 把类加载阶段中的“通过一个类的全限定名来获取描述此类的二进制字节流”这个动作放到Java虚拟机外部去实现,以便让应用程序自己决定如何去获取所需要的类,实现该动作的代码模块就被称为“类加载器”。 类与类加载器的联系 类加载器用于实现类的..

吭哧吭哧快乐的小牛码 2万+

深入理解Java虚拟机——再谈类的加载器——第十二章——中篇

文章目录1:概述1.1 类加载器分类1.2 类加载器的必要性1.3 命名空间1.4 类加载器的基本特性2:类的加载器分类2.1 引导类加载器2.2 扩展类加载器2.3 系统类加载器2.4 用户自定义类加载器3:测试不同的类加载器4:ClassLoader源码解析4.1 ClassLoader的主要方法4.2 SourceClassLoader与URLClassLoader4.3 ExtClassLoader和AppClassLoader4.4 Class.forName()与ClassLoader.load

qq_44891295的博客 1678

JVM基础之类加载器详解

开始 本文我整理了一些JVM类加载器相关的面试高频知识点,方便同学们复习。 在详细了解JVM知识点之前,我们先引入以下基础的经典面试题: 谈谈你对Java的理解 平台无关性,一次编译到处运行。 GC垃圾回收机制:Java无需像C++一样手动管理内存。 Java的语言特性:泛型、反射、lambda表达式等。 面向对象:包括封装、继承、多态。 Java自身类库如:集合、并发库、网络库以及IO流。 异常处理。 Java 和 C++的区别 Java不提供指针直接访问内存,程序的内存更加安全。

a6636656的博客 1156

【Java 基础篇】Java类加载器详解

Java允许开发人员自定义类加载器,以满足特定的加载需求。自定义类加载器必须继承类,并重写findClass方法。在findClass方法中,开发人员可以根据自己的规则和逻辑来加载类的字节码。// 根据名称加载类的字节码 byte [ ] byteCode = loadClassByteCode(name);// 调用defineClass方法将字节码转换为Class对象 return defineClass(name , byteCode , 0 , byteCode . length);

繁依Fanyi的博客 1万+

JSBSim开发手册:飞机仿真模型开发指南

JSBSim是一款开源的飞行动力学模型仿真引擎,支持多种飞行器的仿真,包括固定翼飞机、直升机、无人机等。JSBSim的设计目标是提供一个灵活、高效、精确的飞行动力学仿真环境。飞行动力学仿真:实现飞行器的动力学仿真,包括空气动力学、发动机、质量和惯性等模型。控制系统仿真:实现飞行器的控制系统仿真,包括自动驾驶仪、飞控系统等。环境仿真:模拟飞行环境,包括大气模型、风力模型等。本文详细介绍了如何使用C++进行JSBSim开发,包括系统设计、模型实现、代码优化和性能调优等方面的内容。

qq_38334677的博客 4528

AI应用架构师实战:高等教育智能课程推荐系统开发

性能:选课季并发量达1000QPS,推荐响应时间≤500ms(否则学生不耐烦)。数据隐私:符合《教育数据安全管理规范》,学生姓名、学号等敏感信息需匿名化存储。可扩展性:支持新增课程类型(如MOOC、实践课)、新增数据源(如竞赛获奖记录)。教育AI要“以教为中心”:不能纯技术驱动,要和教育工作者深度合作(如教师参与定义课程的前置关系)。数据是核心:数据质量决定推荐效果,要重视数据治理和隐私保护。持续迭代:教育需求是动态的(如每年新增课程、学生目标变化),要定期收集用户反馈,更新模型和策略。张三。

AI大模型应用之禅 1353

类加载器 超详解:什么是类加载器,类加载器作用及应用场景,类加载时机,类加载的完整过程,类加载器分类

类加载器 超详解:什么是类加载器,类加载器作用及应用场景,类加载时机,类加载的完整过程,类加载器分类

qq_44700578的博客 7113

TMC5160电机驱动芯片实战:从模式选择到参数配置全解析

本文深入解析TMC5160电机驱动芯片的实战应用,涵盖三种核心工作模式的选择策略与参数配置。详细介绍了全功能运动控制、外部脉冲驱动及独立驱动模式的应用场景与配置要点,并提供了电流控制、静音优化、SPI通信及高级功能(如StallGuard2)的调优指南,帮助开发者充分发挥其高精度、低噪音性能。

weixin_29179311的博客 325

什么是类加载器,类加载器有哪些

类加载器(Class Loader)是Java虚拟机(JVM)的一部分,负责将Java类的二进制代码加载到内存中,并转换为可执行的Java字节码。它是Java语言的重要特性之一,为Java应用程序提供了动态加载和运行时扩展的能力。类加载器的主要职责是根据类的全限定名(Fully Qualified Name)在运行时定位并读取类的字节码。类加载器使用一种称为双亲委派模型(Parent Delegation Model)的机制来加载类。

Flying_Fish_roe的博客 2295

【Qwen2微调实战】LLaMA-Factory框架对Qwen2-7B模型的微调实践

在人工智能的浪潮中,大型语言模型(LLMs)正逐渐成为研究和应用的热点。它们在自然语言处理(NLP)的各个领域,如文本生成、翻译、问答等任务中展现出了卓越的能力。Qwen2-7B模型,作为该领域的佼佼者,不仅因其庞大的参数量和强大的表示能力受到关注,更因其在微调后能够更好地适应特定任务而备受关注。本文将详细介绍如何利用LLaMA-Factory这一高效的微调框架对Qwen2-7B进行微调,以期达到提升模型在特定任务上的表现。

寻道AI,探索AI无限可能! 2万+

170、电机控制中的温升测试

本文以一次IGBT炸管事故为切入点,深入剖析电机控制中温升测试的实质:不仅是温度测量,更是对铜损、铁损、散热效率等热管理问题的系统验证。作者强调测试前热电偶布置、环境记录、预运行的重要性,提出实时监控电流谐波、绕组电阻、散热梯度等关键参数,并通过损耗分离与冷却系统实测,揭示真实热源。结合温升曲线异常分析与经验建议,强调留余量、仿真结合实测、关注瞬态工况等实践要点,警示温升测试是保障可靠性与安全性的核心环节。

2401_88858637的博客 51

JVM 之类加载器

JVM(Java Virtual Machine)是一个可以执行 Java 字节码文件(即 .class 文件)的虚拟机进程。当 Java 源文件能被成功编译成 .class 文件,就能在不同平台上的不同版本的 JVM 运行,因为 JVM 能将相同的 .class 文件解释称不同平台的机器码。正是因为 JVM 的存在,Java 被称为与平台无关的语言。一般而言,.java 文件经过编译后会得到 .class 文件,而将这个文件加载到内存之前需要先通过类加载器,先简单过一下图:类加载的过程为: 加载–>连接(

大数据的奇妙冒险 1762

MFC C++ 中实现跨平台(WindowsLinux)的远程桌面控制

**输入捕获**:在显示窗口中捕获鼠标/键盘事件(重写 `OnLButtonDown`、`OnMouseMove`、`OnKeyDown` 等),将事件坐标/键值通过网络发送到服务端。- **显示窗口**:使用 `CStatic` 或自定义 `CWnd` 派生类显示远程桌面图像(通过 `StretchDIBits` 绘制解压后的像素数据)。// 转换为相对坐标。- **Wayland 支持**:需使用 `libweston` 或 `xdg-desktop-portal`,较复杂,建议优先支持 X11。

寒寒豆豆软件公司的博客 157

jvm之类加载器

类加载器 注意图中的类加载器之间并不是继承关系,而是包含关系。 根类加载器 根类加载器(BootstrapClassLoader):负责加载存放在JDK/jre/lib下的指定的jar,也可以使用-Xbootclasspath参数指定哪些jar要使用根类加载器加载。 下面的代码将会打印BootstrapClassLoader以及根类加载器负责加载哪些jar: System.out.println("BootstrapClassLoader:" + String.class.getClassLoader()

morris 1万+

【数据分析八步法】将模糊需求转化为可验证的分析问题

国内访问Huggingface官方源常遇网络问题,可通过切换国内镜像提升下载速度。三种配置方式:1)设置HF_ENDPOINT环境变量;2)在from_pretrained中直接指定镜像参数;3)修改本地Huggingface配置文件。常用镜像包括hf-mirror.com、阿里云ModelScope和清华镜像源。注意镜像同步延迟、私有模型限制,建议配合huggingface-cli工具使用,必要时取消代理设置。合理配置镜像源可显著改善Huggingface生态使用体验。

Mr数据杨 860

jdk-8u144-linux-x64.tar.gz.

该资源为搭建Linux系统Java环境用,资源的后缀为tar.gz格式的压缩包

JVM之类加载器

文章目录JVM整体结构1、类加载器子系统作用2、类的加载过程2.1、Lodading加载2.2、Linking链接2.2.1、验证(Verify)2.2.2、准备(Prepare)2.2.3、解析(Resolve)2.3、Initialization初始化3、类加载器的分类3.1、启动类加载器(引导类加载器,Bootstrap ClassLoader)3.2、扩展类加载器(Extension ClassLoader)3.3、应用程序加载器(系统类加载器,AppClassLoader)3.4、用户自定义加载器

从基础到源码解析的学习记录 559

Statistics and Machine Learning Toolbox

Statistics and Machine Learning Toolbox(带书签),MATLAB统计学习工具

JVM之类加载器ClassLoader

类加载器ClassLoader是用来加载Java类的字节码代码到Java虚拟机中,并转换成java.lang.Class类的一个实例代码模块。包含启动类、拓展类、应用程序等加载器,还可以自定义类加载器

积跬步,至千里。 793

win10 跳过U8环境检测的IE WebControls.rar

win10 安装u8的时候 提示IE WebControls 不通过,这个工具可以欺骗u8的检查。 跳过U8环境检测的IE WebControls。提示导入失败后,重新检测通过。

OV9734 DATASHEET,完整规格书

OV9734完整规格书,包括电气参数,尺寸规格,寄存器配置表等

JVM进阶之类加载器详解

类加载器详解一、类加载器概述1.作用2.分类3.重要性4.命名空间5.特性二、类加载器分类1.基本概述2.引导类加载器3.扩展类加载器4.系统类加载器5.自定义类加载器三、类加载器测试1.获取类加载器方式2.获取类加载器示例四、类加载器解析1.ClassLoader关继承关系图2.ClassLoader中的核心方法3.Class.forName和ClassLoader.loadClass的区别 一、类加载器概述 1.作用 类加载器是JVM执行类加载机制的前提,它是Java的核心组件,所有的类都是由类加载器

ProChick's Blog 1394

JVM底层之类加载器详解

一、类加载器 JVM中有两种类型的类加载器,由C++编写的及由Java编写的。除了启动类加载器(Bootstrap Class Loader)是由C++编写的,其他都是由Java编写的。由Java编写的类加载器都继承自类java.lang.ClassLoader。 JVM还支持自定义类加载器。 各种类加载器之间存在着逻辑上的父子关系,但不是真正意义上的父子关系,因为它们直接没有从属关系。 1.1、启动类加载器 因为启动类是由C++编写的,所以当我们通过Java程序去看显示的是null。 启动类加载器不像其

沮丧的南瓜 1377

深入浅出JVM系列1:类加载器及其用法

1 类产生的原因 在Linux上创建hello.c,使用gcc编译器进行编译gcc hello.c -o hello,得到绿色的可执行程序hello,执行./hello便会在控制台输出Hello World! 学过编译原理的同学都清楚,整个编译过程经历了以下阶段: 这种编译方式的优点很明显,就是可执行文件运行速度快。缺点也很明显,不能跨平台。1)硬件环境原因:如X86和ARM指令集不一样,输出...

JayLaiSCUT的博客 6476

JVM底层之类加载器

JVM底层之类加载器前言JVM中的Klass模型验证准备初始化 前言 这篇博客记录下JVM底层的类加载器,关于类加载器网络上有不少博客写到,我这边只是根据自己的理解记录下jvm类加载器的过程,可能不会太详细,只是用于自己平时偶尔翻翻回忆下自己的曾经所获所得。 JVM中的Klass模型 java中的每一个类在JVM中都是以Klass形式存在的,其中包含了元数据信息,包含属性信息、方法信息以及常量池。 Klass的模型结构如下: 最顶层的父类是MeaSpaceObj,然后元信息类Metadata是子类,而我们

JAVA技术爱好者 641
上一篇: 深入浅出JVM(七)之执行引擎的解释执行与编译执行
下一篇: 深入浅出JVM(九)之字节码指令(上篇)
加班不秃顶
博客等级 码龄7年 1822粉丝 599原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值