[JVM]类加载的过程（学习总结）

一、引入

我们所写的代码就相当于：

一组 *.java 文件 + 一组资源文件（多么媒体文件、配置文件）+ 相关存储中的数据（MySQL、Redis…)

我们现在的

程序数据放在硬盘中

，要让运行时电脑运行我们的程序，实际就是让该电脑的CPU 运行我们程序中的指令数据。

但CPU 无法直接和硬盘（IO设备）做直接的数据交换

CPU 只能和内存中的数据打交道，现在数据又放在硬盘中

所以我们应该先

把数据从硬盘中读取到内存中。

这个过程是

以类为单位

（某个*.class 文件）进行读取的

一次一个类文件的加载，按需进行加载（用到哪个加载哪个）

这个过程就被称为

类的加载（Class Load）。这个加载过程也得依赖某些指令来执行，这些指令（程序）就被称为类的加载器（ClassLoader）。

这些指令是属于 JVM 程序的一部分。换言之， JVM 中有进行必要的类的加载的职责。

二、类文件中的数据是怎么组织的（什么东西放在哪）

javac.exe 编译器是 A 电脑上进行的，靠着 JVM 的规范来约束

java.exe JVM(运行期）是 B 电脑上进行

1.JDK

用于给 Java 开发人员使用的小包裹

提前准备好的程序（*.exe / *.dll)编译器、调试工具：编译器、调试工具、运行时的分析工具
官方提供的所有人都能使用的类文件 *.class

2.JRE：Java运行时的环境

用于给一般用户运行好别人写好的 Java 程序（以 *.class 为代表的数据文件，可以是*.jar / *.war…)的一组环境

JVM(Java Virtual Machine) Java虚拟机：java.exe
运行期间支持运行的一组官方类文件 *.class

开发人员也会用到 JRE （不可能光开发，不去运行测试）

三、类文件中主要有哪些部分的数据

class file 格式一直在更新

javac.exe 5编译的类能不能用java.exe 17运行

<maven.compiler.source>1.8 :让编译器按照1.8（Java8）的标准检查 java 文件语法

<maven.compiler.tareget>1.8 :编译出来的类文件里，写明是 1.8（Java8）版本

常量池（很多常量）、类的基本属性、方法（构造、静态构造代码块)、签名 + 指令（语句）、字符串（字面量）、数字、符号

类文件的数据 = 类的信息 + 常量池 + 方法（方法的信息 + 指令（字节码形式））

ClassLoader 要加载一个类，主要就是要加载这些数据到内存中。

四、JVM 会按需进行类的加载，什么情况下会加载一个类？

大前提：

用到了一个类，但是这个类还不在内存中，就需要加载（如果已经在内存中，就没必要进行第二次加载）

什么叫用到：

使用一个类，进行对象的实例化时（构造对象时）
使用一个类时，会触发使用这个类的父类（父类：类的继承、接口的实现、接口的继承）
使用静态的内容（静态属性、静态方法）

class Main { psvm() { … } }

java Main

以 Main 类作为主类启动 JVM 。需要加载 Main 类，因为用到了 Main 类的静态方法（main 方法）

Object类也需要加载，因为 Object 是 Main 的父类

五、类加载期间，ClassLoader 主要做了哪些工作？

类、接口、枚举、注解都在这块称为“类”

1.Loading（加载）

根据要加载的类名，找到对应的类文件（ *.class)

验证类文件合法，没有错误（还得考虑安全问题，有可能写恶意的类也加载进来）

解析数据（按照规范格式）

2.Linking（链接）

类里面用到很多用字符串字面量写死的数据，比如“java/lang/Object”

但实际程序（JVM）执行中，需要的java.lang.Object 在内存中对应的数据

所以要把 com.lingqi.demo.Main 和 java.lang.Object 根据字面量“链接”起来

3.Initializing（初始化）

将类放到内存的指定位置后，进行类里的必要数据的初始化（主要是静态属性）

执行类的初始化工作

站在Java开发者的角度：我们的代码中的哪些东西是在这个阶段执行的？静态属性的初始化（赋值操作）、静态代码块 static { … }

class Main {
    static int a = 10;  // = 10 是赋值的操作，是类的初始化阶段要做的

    static int b = callStaticMethod();  // = callStaticMethod() 操作，是类的初始化阶段要做的
                                        // 导致这个阶段，会去调用 callStaticMethod 方法

    static {    // 静态代码块/静态构造代码块
        System.out.println("hello");    // 这里的所有语句，是类的初始化阶段要做的
    }

    static int callStaticMethod() {
        return 2;   // 这个方法会被执行，只是因为 b = callStaticMethod() 导致的
    }

    static int someStaticMethod() {
        return 1;   // 这个方法不会被执行
    }

    public static void main(String[] args) {
        String s = "hello";
        System.out.println(s);
    }
}

一定是先执行父类的初始化完成之后，才会进行子类的初始化。

六、关于类

1.类名：

俗称：Main

权威类名：com.lingqi.demo.Main。更深一层就是 JVM 进行类的加载时，保证一个类只会在内存中存在一份（粗略地可以当成类只被加载一次（类是可以被卸载的））

JVM 内部：类加载器 + 权威类名，确定一个类是否存在

2.默认情况下有那些类加载器？

不同的类，由不同的类加载(因为类和类的地位的不平等）

Boostrap ClassLoader（启动类加载器）

：加载 SE 下的标准类（java.lang.String、java.util.List、java.io.InputStream）

Extenttion ClassLoader（扩展类加载器）

：加载 SE 下的扩展类

Application ClassLoader（应用类加载器）

：我们写类、我们通过 maven 或者其他工具引入的第三方类

举个例子：

如果有人提个要求，说让我加载一个类，那么我们怎么知道要加载的这个类的.class文件放在哪里呢？(比如说 rt.jar)

ClassLoader 肯定输入 JRE，所以知道自己被安装在哪

C:\Program Files\Java\jdk1.8.0_131\jre

所以去固定位置去找C:\Program Files\Java\jdk1.8.0_131\jre\lib\rt.jar

对于应用类加载器

Application ClassLoader

来说：

必须告诉它去哪里找，通过 ClassPath 变量告诉。java-classpath=路径，或者放在环境变量 ClassPath 中。路径1/路径2/路径3。 ClassLoader 先去路径1下找，没找到再去 2 下，没找到再去 3，最后没找到，就会报异常（ClassNotFound，NoClassDef）

3.类的数据被加载到内存的什么位置了？

JVM 会管理一片内存（这片内存，JVM 是哪弄来的？JVM 是普通进程，从OS 申请过来的）

内存分的区域：

PC 寄存器（每个线程存在自己下一条指令的地址）
JVM 栈（Java Virtual Machine Stacks）
本地方法栈 Native Method Stacks（和JVM 栈一起称为栈区）
堆（Heap）
方法区（Mathod Area）
Run-Time Constant Pool（运行时常量池）

不同的JVM 实现中，可以有自己的实现。比如我们现在使用的都是 Oracle 提供的 Hotspot JVM。

除了上述的区域，还有一部分直接管理的内存，一般称为原生内存

类中的数据：类的信息、方法、常量池数据。

类的信息和方法组织成一个东西，叫做类信息，常量池其实也是类的信息。逻辑上，类信息被存到了方法区。常量池存在了运行时的常量池中，它也是类，实际上逻辑上也可以理解为，这也是方法区的一部分。

那么，我们简单理解就是，整个类的数据，都被放在了方法区之中了（基本信息、方法（所有的方法）、常量数据、静态属性）。但是这个阶段是不讨论具体的JVM 实现的。不同版本的 JVM 的具体实现实际上是不同的。所以深入探讨的时候，还需要根据实际情况来具体的分析。

七、小结

1.类文件放在哪里？

硬盘中，以文件的形式出现最为常见

2.类文件是怎么来的

经过编译器，将 java 源文件编译而来的

3.类文件中的主要数据有？

按照规范，主要有基本信息（静态属性）、方法（方法信息、指令（字节码））、常量

4.为什么进行类的加载？

按照冯诺依玛体系，CPU 无法直接读取硬盘中的数据，需要先加载到内存中

5.为什么类文件要按需加载，并且以类为单位加载？

相对来说，节省内存空间，实现方便

6.类名是什么

①权威类名 = 包名 + 类名 ② 类加载器 + 权威类名

7.什么时候会去加载类（什么时候用到了一个类）？

实例化对象、访问静态属性、调用静态方法、子类调用到父类

8.类在内存中只会存在一份

正确

9.类的加载过程

加载、链接、初始化

10.类的初始化时会执行我们的哪些代码？

①属性的初始化赋值 ②静态构造代码块父类的初始化一定在子类之前完成按照书写顺序

11.类被加载到内存的什么位置？

逻辑上，放在方法区。但不同 JVM 的实现，可以有进一步讨论空间

12.默认的类加载器有哪些？

启动类加载器、扩展类加载器、应用类加载器

13.加载时，ClassLoader 怎么知道一个类对应的类文件所在？

启动、扩展类加载器根据固定位置找。应用类加载器，根据class path 的路径依次查找

14.如果加载时，一个类不存在，会出现异常（ClassNotFound、NoClassDef…）

八、双亲委派机制（⭐）

默认的三个类加载器之间遵守一个规范：

1.三个类加载器之间存在

2.Application ClassLoader 需要加载类的时候，先委派给双亲去加载

如果 parent 加载成功这个类了，你就不用加载了；否则自己再去加载

3.目的是放置加载进来用户写好的恶意代码

前提：一个类（A类）用到了其他类（B C D类），则其他的这些类（B C D ）的加载动作，默认是由当时加载 A类的加载器来加载。

比如说com.lingqi.demo.Main 用到了 java.lang.String 类

public static void main(String[] args){
    String s = "hello";
    System.out.println(s);
}

但是我还定义了一个自己的String 类

那么我用的时候用的是 rt.jar 下的java.lang.String 还是我自己定义的？

那么双亲委派机制是如何解决这个问题的

1.com.lingqi.demo.Main 类被哪个类加载？—— ApplicationClassLoader 去加载

2.Main 用到了 java.lang.String ，则默认让 ApplicationClassLoader 去加载。

3.如果没有双亲委派，加载的就是我们自己写的 java.lang.String

4.如果有双亲委派，则 ApplicationClassLoader 优先让 BootStrapClassLoader 去加载，能加载到是 rt.jar 下的。所以不会加载我们自己写的。

这就是双亲委派的意义。

原文链接：https://blog.csdn.net/weixin_61567666/article/details/126027182