JVM类加载机制、双亲委派和SPI机制

最新推荐文章于 2024-09-23 14:57:54 发布
最新推荐文章于 2024-09-23 14:57:54 发布
阅读量797 收藏 5
点赞数
文章标签： jvm java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mfmfmfo/article/details/126870196
版权
本文详细介绍了JVM的类加载机制，包括加载、验证、准备、解析、初始化、使用和卸载七个阶段。重点讲解了双亲委派模型，解释了其工作原理、优点和缺点，并展示了如何通过自定义类加载器打破这一模型。此外，还探讨了SPI服务发现机制，包括其使用示例、实现原理和常见应用。
摘要由CSDN通过智能技术生成

类的生命周期和加载过程

类的生命周期可以划分为 7 个阶段

  1. 加载
  2. 验证
  3. 准备
  4. 解析
  5. 初始化
  6. 使用
  7. 卸载

其中，第 1~5 阶段，即加载、验证、准备、解析、初始化，统称为「类加载」，如下图所示。

1.加载

加载阶段是类加载过程的第一个阶段。在这个阶段，JVM 的主要目的是将字节码从各个位置（网络、磁盘等）转化为二进制字节流加载到内存中，接着会为这个类在 JVM 的方法区创建一个对应的 Class 对象，这个 Class 对象就是这个类各种数据的访问入口。

该过程可以总结为「JVM 加载 Class 字节码文件到内存中，并在方法区创建对应的 Class 对象」。

2.验证

当 JVM 加载完 Class 字节码文件，并在方法区创建对应的 Class 对象之后，JVM 便会启动对该字节码流的校验，只有符合 JVM 字节码规范的文件才能被 JVM 正确执行。

这个校验过程，大致可以分为下面几个类型

  1. JVM 规范校验 
    0x cafe babe
  2. 代码逻辑校验
    • JVM 会对代码组成的数据流和控制流进行校验，确保 JVM 运行该字节码文件后不会出现致命错误。
    • 例如，一个方法要求传入 int 类型的参数，但是使用它的时候却传入了一个 String 类型的参数。

3.准备

准备阶段中，JVM 将为类变量分配内存并初始化。

准备阶段，有两个关键点需要注意

  1. 内存分配的对象
  2. 初始化的类型

内存分配的对象

Java 中的变量有「类变量」和「类成员变量」两种类型。「类变量」指的是被 static 修饰的变量，而其他所有类型的变量都属于「类成员变量」。 在准备阶段，JVM 只会为「类变量」分配内存，而不会为「类成员变量」分配内存。「类成员变量」的内存分配需要等到初始化阶段才开始。

public static int factor = 3;
public String website = "www.google.com";
复制代码

如上代码，在准备阶段，只会为 factor 变量分配内存，而不会为 website 变量分配内存。

初始化的类型

在准备阶段，JVM 会为「类变量」分配内存并为其初始化。这里的「初始化」指的是为变量赋予 Java 语言中该数据类型的零值，而不是用户代码里初始化的值。

public static int sector = 3;
复制代码

如上代码，在准备阶段后， sector 的值将是 0，而不是 3。

如果一个变量是常量（被 static final 修饰）的话，那么在准备阶段，变量便会被赋予用户希望的值。 final 关键字用在变量上，表示该变量不可变，一旦赋值就无法改变。所以，在准备阶段中，对类变量初始化赋值时，会直接赋予用户希望的值。

public static final int number = 3;
复制代码

如上代码，在准备阶段后， number 的值将是 3，而不是 0。

4.解析

解析过程中，JVM 针对「类或接口」、「字段」、「类方法」、「接口方法」、「方法类型」、「方法句柄」、「调用点限定符」这 7 类引用进行解析。解析过程的主要任务是将其在常量池中的符号引用，替换成其在内存中的直接引用。

5.初始化

到了初始化阶段，用户定义的 Java 程序代码才真正开始执行。在这个阶段，JVM 会根据语句执行顺序对类对象进行初始化。

一般来说，当 JVM 遇到下面 5 种情况的时候会触发初始化

  1. 遇到 new 、 getstatic 、 putstatic 、 invokestatic 这 4 条字节码指令时，如果类没有进行过初始化，则需要先触发其初始化。
    • 生成这 4 条指令的最常见的 Java 代码场景是使用 new 关键字实例化对象的时候、读取或设置一个类的静态字段（被 final 修饰、已在编译器把结果放入常量池的静态字段除外）的时候，以及调用一个类的静态方法的时候。
  2. 使用 java.lang.reflect 包的方法对类进行反射调用的时候，如果类没有进行过初始化，则需要先触发其初始化。
  3. 当初始化一个类的时候，如果发现其父类还没有进行过初始化，则需要先触发其父类的初始化。
  4. 当虚拟机启动时，用户需要指定一个要执行的主类（包含 main() 方法的那个类），虚拟机会先初始化这个主类。
  5. 当使用 JDK 1.7 动态语言支持时，如果一个 java.lang.invoke.MethodHandle 实例最后的解析结果是 REF_getstatic 、 REF_putstatic 、 REF_invokeStatic 的方法句柄，并且这个方法句柄所对应的类没有进行初始化时，则需要先出触发其初始化。

6.使用

当 JVM 完成初始化阶段之后，JVM 便开始从入口方法开始执行用户的程序代码。

7.卸载

当用户程序代码执行完毕后，JVM 便开始销毁创建的 Class 对象，最后负责运行的 JVM 也退出内存。

对类加载的理解

下面，将通过几个案例，对类加载的 5 个阶段加深理解。

类初始化方法和对象初始化方法

public class Book {
    public static void main(String[] args) {
        System.out.println("Hello Liu Baoshuai");
    }

    Book() {
        System.out.println("书的构造方法");
        System.out.println("price=" + price +",amount=" + amount);
    }

    {
        System.out.println("书的普通代码块");
    }

    int price = 110;

    static{
        System.out.println("书的静态代码块");
    }

    static int amount = 112;
}
复制代码

运行上述代码，输出信息如下。

书的静态代码块
Hello Liu Baoshuai
复制代码

下面对输出结果进行分析。

根据「类的生命周期和加载过程 / 5.初始化」章节中提到的「当虚拟机启动时，用户需要指定一个要执行的主类（包含 main() 方法的那个类），虚拟机会先初始化这个主类」可知，我们将会进行类的初始化。

Java 源代码中有构造方法这个概念。但编译为字节码后，是没有构造方法这个概念的，只有「类初始化方法」和「对象初始化方法」。

  1. 「类初始化方法」
    • 编译器会按照代码出现的顺序，收集类变量的赋值语句、静态代码块，最终组成类初始化方法。
    • 类初始化方法一般在类初始化的时候执行。

上面的例子中，其类初始化方法如下。

static {
        System.out.println("书的静态代码块");
    }

    static int amount = 112;
复制代码
  1. 「对象初始化方法」
    • 编译器会按照代码出现的顺序，收集成员变量的赋值语句、普通代码块， 最后 收集构造函数的代码，最终组成对象初始化方法。 注意，构造函数的代码一定是被放在最后的。
    • 对象初始化方法一般在实例化类对象的时候执行。

上面的例子中，其对象初始化方法如下。

{
        System.out.println("书的普通代码块");
    }

    int price = 110;

    //注意，构造函数的代码一定是被放在最后的
    Book() {
        System.out.println("书的构造方法");
        System.out.println("price=" + price +",amount=" + amount);
    }
复制代码

结合「类初始化方法」和「对象初始化方法」的分析，再回过头看上述例子，就不难得出结论了。

  1. 当虚拟机启动时，用户需要指定一个要执行的主类（包含 main() 方法的那个类），虚拟机会先初始化这个主类。所以开始执行「初始化」过程。
  2. main 方法中，并没有实例化对象，所以只执行「类初始化方法」，如下所示。因此，会输出 书的静态代码块 。
static {
        System.out.println("书的静态代码块");
    }

    static int amount = 112;
复制代码
  1. 初始化过程执行完毕后，继续执行 main() 方法。因此，会输出 Hello Liu Baoshuai 。

案例引申

下面，对上述测试案例进一步引申，修改 main() 方法，代码如下所示。

public class Book {
    public static void main(String[] args) {
        System.out.println("Hello Liu Baoshuai" + new Book().price);
    }

    Book() {
        System.out.println("书的构造方法");
        System.out.println("price=" + price +",amount=" + amount);
    }

    {
        System.out.println("书的普通代码块");
    }

    int price = 110;

    static{
        System.out.println("书的静态代码块");
    }

    static int amount = 112;
}
复制代码

运行上述代码，输出信息如下。

书的静态代码块
书的普通代码块
书的构造方法
price=110,amount=112
Hello Liu Baoshuai110
复制代码

下面对输出结果进行分析。

书的静态代码块

static {
        System.out.println("书的静态代码块");
    }

    static int amount = 112;
复制代码
  1. 「类初始化方法」执行完毕后，继续执行 main() 方法。遇到了 new Book() 语句，所以触发执行「对象初始化方法」，如下所示。
// part 1
    {
        System.out.println("书的普通代码块");
    }
    // part 2
    int price = 110;

    // part 3
    Book() {
        System.out.println("书的构造方法");
        System.out.println("price=" + price +",amount=" + amount);
    }
复制代码
  1. 需要注意的是， part 1 和 part 2 的先后顺序，是根据它们在代码中出现的顺序决定的。 part 3 部分是构造函数部分，这部分永远是出现最后的，和它在代码中的顺序无关。在代码中， part 3 部分虽然出现在 part 1 和 part 2 的前面，但在「对象初始化方法」中，它永远是出现在最后的。
  2. 此外，由于 part 2 出现在 part 3 前面，所以输出 price 的值是 110，而不是 0。

继承关系下类的加载情况

class Grandpa
{
    static
    {
        System.out.println("爷爷在静态代码块");
    }
}   

class Father extends Grandpa
{
    static
    {
        System.out.println("爸爸在静态代码块");
    }

    public static int factor = 25;

    public Father()
    {
        System.out.println("我是爸爸~");
    }
}

class Son extends Father
{
    static 
    {
        System.out.println("儿子在静态代码块");
    }

    public Son()
    {
        System.out.println("我是儿子~");
    }
}
public class InitializationDemo
{
    public static void main(String[] args)
    {
        System.out.println("爸爸的岁数:" + Son.factor);	//入口
    }
}
复制代码

运行上述代码，输出信息如下。

爷爷在静态代码块
爸爸在静态代码块
爸爸的岁数:25
复制代码

下面对输出结果进行分析。

  1. 当虚拟机启动时，用户需要指定一个要执行的主类（包含 main() 方法的那个类），虚拟机会先初始化这个主类。所以开始执行「初始化」过程。
  2. main 方法中，并没有实例化对象，所以只执行「类初始化方法」，不会执行「对象初始化方法」。
  3. 根据「类的生命周期和加载过程 / 5.初始化」章节中提到的「当初始化一个类的时候，如果发现其父类还没有进行过初始化，则需要先触发其父类的初始化」可知，进行 Son 初始化时，会先进行父类 Father 的初始化。同理，进行 Father 初始化时，会先进行父类 Grandpa 的初始化。所以，程序会输出如下信息。
爷爷在静态代码块
爸爸在静态代码块
复制代码
  1. 继续，执行 main() 方法中的 System.out.println 语句，程序会输出 爸爸的岁数:25 。

也许会有人问为什么没有输出「儿子在静态代码块」这个字符串？这是因为对于静态字段，只有直接定义这个字段的类才会被初始化，才会执行该类的「类初始化方法」。因此，通过其子类来引用父类中定义的静态字段，只会触发父类的初始化，而不会触发子类的初始化。

继承关系下实例化对象

class Grandpa
{
    static
    {
        System.out.println("爷爷在静态代码块");
    }

    public Grandpa() {
        System.out.println("我是爷爷~");
    }
}

class Father extends Grandpa
{
    static
    {
        System.out.println("爸爸在静态代码块");
    }

    public Father()
    {
        System.out.println("我是爸爸~");
    }
}

class Son extends Father
{
    static 
    {
        System.out.println("儿子在静态代码块");
    }

    public Son()
    {
        System.out.println("我是儿子~");
    }
}

public class InitializationDemo
{
    public static void
最低0.47元/天 解锁文章
java记
关注
简单认识 JVM —— 了解类加载机制和双亲委派模型
AlinaQ05的博客
06-13 757
JVM 是 Java Virtual Machine 的简称，Java 虚拟机。虚拟机是指通过软件模拟具有完整硬件功能、运行在一个完全隔离的环境中的完整计算机系统。JVM 是主流虚拟机，其他常见的虚拟机还有：VMwave, Virtual Box.JVM 是 Java 运行的基础，也是实现一次编译到处执行的关键。一个 java 文件从编译到执行需要经过以下四个阶段。JVM 结构图： 总结来看，JVM 主要通过四个部分来执行程序。分别是： 类加载器（ClassLoader）、运行时数据区（Runntime D
JVM类加载与双亲委派机制被打破
m0_67788957的博客
03-25 235
前言 前文已经讲了虚拟机将java文件编译成class文件后的格式 java文件经过编译,形成class文件,那么虚拟机如何将这些Class文件读取到内存中呢? 加载的时机 JVM 会在程序第一次主动引用类的时候加载该类，被动引用时并不会引发类加载的操作。也就是说，JVM 并不是在一开始就把一个程序就所有的类都加载到内存中，而是到不得不用的时候才把它加载进来，而且只加载一次。 一个类的生命周期如图所示: 上图中的加载、验证、准备、初始化、卸载这几个步骤是相对固定的,但是初始化这一步不一定,他
双亲委派机制和SPI的理解
weixin_59232619的博客
07-07 690
双亲委派机制简单的来说是JVM类加载过程的一个。子类加载器加载对应的Class，不会直接加载，首先会交由其父类加载器加载，若父类加载器无法加载，则由自己加载。Java一共有三层类加载器，级别从上往下依次是：BootStrap Class Loader：该类加载器由C++实现，在，所以在获取类加载器为null，主要用于加载目录下的类。当然也可自己通过JVM参数指定。ExtClassLoader：扩展类加载器，主要用于加载目录下的类。
双亲委派机制&SPI
最新发布
weixin_44038236的博客
09-23 1109
这里forName进行加载类，forName方法的getClassLoader是获取caller对应的ClassLoader,caller就是指当前调用的forName方法的那个类，即ReflectionTest这个类，因为这个类是自己写的，所以在CLASSPATH路径下，获取到的加载器应该是应用类加载器（App ClassLoader）,解析去会尝试用应用类加载器加载Persion类。尽管SPI本身是由启动类加载器加载，但是它间接的通过应用类加载器加载第三方驱动类，绕过了严格的双亲委派机制。
类加载器、双亲委派、SPI机制
helloworld_9的博客
04-15 769
JVM 并不是在启动时就把所有的​​.class​​​文件都加载一遍，而是程序在运行过程中用到了这个类才去加载。除了启动类加载器外，其他所有类加载器都需要继承抽象类​​ClassLoader​​，这个抽象类中定义了三个关键方法，理解清楚它们的作用和关系非常重要。//每个类加载器都有个父加载器//查找一下这个类是不是已经加载过了Class<?//如果没有加载过//先委派给父加载器去加载，注意这是个递归调用if (parent!
spi与双亲委派
qq_31176869的博客
08-28 280
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、pandas是什么？ 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。 二、使用步骤 1.引入库 代码
JVM 类加载机制、双亲委派
怕什么真理无穷，进一寸有一寸的欢喜。即使开了一辆老掉牙的破车，只要在前行就好，偶尔吹点小风，这就是幸
06-13 147
加载 —>连接—>初始化—>使用—>卸载其中连接包括：验证—>准备—>解析三个阶段下面介绍每个部分的作用加载是类加载过程中的一个阶段，这个阶段会在内存中生成一个代表这个类的 java.lang.Class 对 象，作为方法区这个类的各种数据的入口。注意这里不一定非得要从一个 Class 文件获取，这里既可以从 ZIP 包中读取（比如从 jar 包和 war 包中读取），也可以在运行时计算生成（动态代理），也可以由其它文件生成（比如将 JSP 文件转换成对应的 Class 类）这一阶段的主要目的是为了确保 C
JVM 类加载机制 双亲委派机制
花儿小新♥
10-25 220
类加载器：“通过一个类的全限定名来获取描述此类的二进制字节流”这个动作放到java虚拟机外部去实现，以便让应用程序自己决定如何去获取所需要的类。实现这个动作的代码模块成为“类加载器”。 通俗的讲，虚拟机是根据类的全限定名来加载类的，那么有个问题，如果同时存在两个或多个全限定名完全一致的情况下。该如何选择加载哪个类。这就是双亲委派机制要做的工作。 在这里强加个知识点：比较两个类是否“相等”，只有在这两个类是由同一个类加载器加载的前提下才有真正的意义，否则，即使这两个类来源于同一个class文件，被同一个虚拟机
Java SPI 机制（SPI实战+ServiceLoader源码分析+SPI 应用场景+破坏双亲委派）
06-21
SPI 机制的核心组件是 ServiceLoader，负责加载和实例化提供者的实现类。ServiceLoader 的实现非常简单，可以分为三个大块：加载配置文件、实例化提供者和迭代提供者。 SPI 机制的应用场景非常广泛，例如 JDBC 连接...
JVM系列1——类加载机制
xiaodigua1024的博客
04-18 607
使用java命令运行某个类的main函数启动程序时，首选需要通过类加载器把主类加载到JVM。类加载过程为加载->验证->准备->解析->初始化->使用->卸载七个阶段。
JVM-双亲委派模型
qq_38844645的博客
05-29 502
双亲委派模型1、工作流程某个特定的类加载器在接到加载类的请求时，首先将加载任务委托给父类加载器，依次递归，如果父类加载器可以完成类加载任务，就成功返回；只有父类加载器无法完成此加载任务时（会抛出ClassNotFoundException异常），才自己去加载。2、好处：防止内存中出现多份相同的字节码文件从反向思考这个问题，如果没有双亲委派模型而是由各个类加载器自行加载的话，如果用户编写了一个jav...
JVM类加载的双亲委派机制
梦里蓝天
12-23 324
抛砖引玉：JVM是如何把 String class 加载进来呢？ 我们来猜想下。 首先，String 类属于 Java 核心类，位于 $JAVA_HOME/jre/lib 目录下，该目录下的类会由 BootstrapClassLoader 进行加载。没错，它确实是由 BootstrapClassLoader 进行加载。但，这种回答的前提是你已经知道了 String 在 $JAVA_HOME/jre/lib 目录下。 那么，如果你并不知道 String 类究竟位于哪呢？或者我希望你去加载一个 unknown
【JVM】类加载——双亲委派机制
真的好想再回到那时，可现在能做的只有补救。————个人博客：https://w7h1te.github.io/
04-21 220
在面试过程中：也会被问到关于如何理解双亲委派模型这样的问题，接下来就通过这篇文章往明白了解一下。 我们首先需要了解一下类加载阶段 类的加载阶段 类加载阶段分为加载、连接、初始化三个阶段，而加载阶段需要通过类的全限定名来获取定义了此类的二进制字节流。Java特意把这一步抽出来用类加载器来实现。把这一步骤抽离出来使得应用程序可以按需自定义类加载器。并且得益于类加载器，OSGI、热部署等领域才得以在JAVA中得到应用。 类加载器除了能用来加载类，还能用来作为类的层次划分。Java自身提供了3种类加载器 类加载.
JVM：类加载的双亲委派机制
暮色年华的博客
07-21 212
双亲委派机制
java jvm 类加载机制 双亲委派模型
oQiuQian的博客
10-11 539
jvm 类加载机制 双亲委派模型
JVM类加载器的双亲委派机制
RitaAndWakaka的博客
06-23 120
相关视频链接：类加载器及双亲委派机制 JVM体系结构 JVM结构图 类加载器 双亲委派机制 Java是运行在Java的虚拟机(JVM)中的，但是它是如何运行在JVM中了呢？我们在IDE中编写的Java源代码被编译器编译成.class的字节码文件。然后由我们得ClassLoader负责将这些class文件给加载到JVM中去执行。 JVM中提供了三层的ClassLoader： Bootstrap classLoader:主要负责加载核心的类库(java.la...
一、 JVM类加载机制、双亲委派机制
一名蒟蒻的博客
03-23 388
一、 JVM类加载机制 1、类加载运行全过程 当运行某个类的main函数启动程序时，首先需要通过类加载器把主类加载到 JVM。 loadClass的类加载过程 加载 >> 验证 >> 准备 >> 解析 >> 初始化 >> 使用 >> 卸载 加载：在硬盘上查找并通过IO读入字节码文件，使用到类时才会加载，例如调用类的main()方法，new对象等等，在加载阶段会在内存中生成一个代表这个类的java.lang.Class对象，作
JVM的类加载器-----双亲委派机制
weixin_45118251的博客
05-27 465
首先我想问大家个问题，我们在写程序时能不能自己定义一个和java的核心包相同的包名，在这个报名下写代码。 也就是说能不能自己写一个java.lang 包自己定义一个String类来写代码？答案当然是不能。 java为了程序的安全性，防止某些类被黑客恶意修改从而入侵入程序，设计出了一个安全沙箱的机制，也就是双亲委派机制。 接下来我来简单介绍一下java中的类加载器： java中的类加载器分为三种：启...
深入理解JVM类加载及双亲委派机制
本文将深入解析JVM的类加载过程以及双亲委派模型，这两者是理解Java程序在JVM中运行的关键组成部分。类加载器是核心概念，它负责根据全限定名称从磁盘或网络上读取class文件，并将其转换为JVM内存中的Class对象，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值