Java开发：JVM篇-类加载内存分析

一、类加载器

A、类加载器的作用

将class文件字节码内容加载到内存中，并将这些静态数据结构转换成方法区的运行时数据结构，然后在堆中生成一个代表这个类的java.lang.Class对象，作为方法区中类数据的访问入口。

B、类缓存

标准的JavaSE类加载器可以按要求查找类，但一旦某个类被加载到类加载器中，它将维持（缓存）加载一段时间。不过JVM垃圾回收机制可以回收这些Class对象。

示例代码：

public class Lesson007 {
    public static void main(String[] args) {
        try {
            //系统类加载器
            ClassLoader sClassLoader = ClassLoader.getSystemClassLoader();
            System.out.println("系统类加载器--->" + sClassLoader);

            //扩展类加载器
            ClassLoader eClassLoader = sClassLoader.getParent();
            System.out.println("扩展类加载器--->" + eClassLoader);

            //根加载器（c/c++）
            ClassLoader rClassLoader = eClassLoader.getParent();
            System.out.println("根加载器--->" + rClassLoader);

            //测试当前类是哪个类加载器
            ClassLoader cClassLoader = Class.forName("com.baidu.baike.lesson.annotations_reflection.Lesson007").getClassLoader();
            System.out.println("当前类加载器--->" + cClassLoader);

            //JDK类使用的哪个加载器
            ClassLoader oClassLoader = Class.forName("java.lang.Object").getClassLoader();
            System.out.println("JDK中的类使用的加载器--->" + oClassLoader);

            //如何获得系统类加载器可以加载的路径
            System.out.println("系统类加载器可以加载的路径--->" + System.getProperty("java.class.path"));
        } catch (ClassNotFoundException e) {
            throw new RuntimeException(e);
        }
    }
}

运行结果：
系统类加载器--->sun.misc.Launcher$AppClassLoader@18b4aac2
扩展类加载器--->sun.misc.Launcher$ExtClassLoader@74a14482
根加载器--->null
当前类加载器--->sun.misc.Launcher$AppClassLoader@18b4aac2
JDK中的类使用的加载器--->null
系统类加载器可以加载的路径--->
C:\Users\86157\.jdks\corretto-1.8.0_292\jre\lib\charsets.jar;
C:\Users\86157\.jdks\corretto-1.8.0_292\jre\lib\ext\access-bridge-64.jar;
C:\Users\86157\.jdks\corretto-1.8.0_292\jre\lib\ext\cldrdata.jar;
C:\Users\86157\.jdks\corretto-1.8.0_292\jre\lib\ext\dnsns.jar;
C:\Users\86157\.jdks\corretto-1.8.0_292\jre\lib\ext\jaccess.jar;
C:\Users\86157\.jdks\corretto-1.8.0_292\jre\lib\ext\jfxrt.jar;
C:\Users\86157\.jdks\corretto-1.8.0_292\jre\lib\ext\localedata.jar;
C:\Users\86157\.jdks\corretto-1.8.0_292\jre\lib\ext\nashorn.jar;
C:\Users\86157\.jdks\corretto-1.8.0_292\jre\lib\ext\sunec.jar;
C:\Users\86157\.jdks\corretto-1.8.0_292\jre\lib\ext\sunjce_provider.jar;
C:\Users\86157\.jdks\corretto-1.8.0_292\jre\lib\ext\sunmscapi.jar;
C:\Users\86157\.jdks\corretto-1.8.0_292\jre\lib\ext\sunpkcs11.jar;
C:\Users\86157\.jdks\corretto-1.8.0_292\jre\lib\ext\zipfs.jar;
C:\Users\86157\.jdks\corretto-1.8.0_292\jre\lib\jce.jar;
C:\Users\86157\.jdks\corretto-1.8.0_292\jre\lib\jfr.jar;
C:\Users\86157\.jdks\corretto-1.8.0_292\jre\lib\jfxswt.jar;
C:\Users\86157\.jdks\corretto-1.8.0_292\jre\lib\jsse.jar;
C:\Users\86157\.jdks\corretto-1.8.0_292\jre\lib\management-agent.jar;
C:\Users\86157\.jdks\corretto-1.8.0_292\jre\lib\resources.jar;
C:\Users\86157\.jdks\corretto-1.8.0_292\jre\lib\rt.jar;
D:\code\JavaProject\MyProject\MyProject\out\production\MyProject;
D:\code\JavaProject\MyProject\MyProject\src\lib\commons-io-2.10.0.jar;
D:\software\IDEA\IntelliJ IDEA 2022.2.3\IntelliJ IDEA Community Edition 2022.2.3\lib\idea_rt.jar

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

二、分析类初始化

什么时候会发生类初始化？

A、类的主动引用（一定会发生类的初始化）

• 当虚拟机启动，先初始化main方法所在的类
• new 一个类的对象
• 调用类的静态成员（除了final常量）和静态方法
• 使用java.lang.reflect包的方法对类进行反射调用
• 当初始化一个类，如果其父类没有被初始化，则会先初始化它的父类

B、类的被动引用（不会发生类的初始化）

• 当访问一个静态域时，只有真正声明这个域的类才会被初始化。如：当通过子类引用父类的静态变量，不会导致子类初始化。
• 通过数组定义类引用，不会触发此类的初始化
• 引用常量不会触发此类的初始化（常量在链接阶段就存入了调用类的常量池中了）

public class Lesson006 {
    public static void main(String[] args) {
//        System.out.println("调用Son类的M值为：" + Son.C_M);
//        System.out.println("调用Son类的c_m+" + Son.c_m);

        //主动引用
//        Son son = new Son();


        //反射也会产生主动引用
//        try {
//            Class.forName("com.baidu.baike.lesson.annotations_reflection.Son");
//        } catch (ClassNotFoundException e) {
//            throw new RuntimeException(e);
//        }

        //不会产生类的引用方法
//        System.out.println("调用父类的静态参数f_b = " + Son.f_b);
//        Son[] sons = new Son[5];
//        System.out.println("调用子类的静态常量C_M = " + Son.C_M);
    }
}

class Father {
    static int f_b = 2;

    static {
        System.out.println("父类的静态方法被加载");
    }
}


class Son extends Father {
    static {
        System.out.println("子类的静态方法被加载");
        c_m = 300;
    }

    static int c_m = 100;
    static final int C_M = 1;
    String C_CLASS_NAME = Son.class.getSimpleName();

    public Son() {
        System.out.println("子类的构造函数被加载--->" + C_CLASS_NAME);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

三、类加载内存分析

A、加载

将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后生成一个代表这个类的java.lang.Class对象。

B、链接

将Java类的二进制代码合并到JVM的运行状态之中的过程。

• 验证：确保加载的类信息符合JVM规范，没有安全方面的问题。
• 准备：正式为类变量（static）分配内存并设置类变量默认初始值的阶段，这些内存都将在方法区中进行分配。
• 解析：虚拟机常量池内的符号引用（常量名）替换为直接引用（地址）的过程。

C、初始化

• 执行类构造器**方法的过程**。类构造器()方法是编译器自动收集类中所有类变量的赋值动作和静态代码块中的语句合并产生的。（类构造器是构造类信息的，不是构造该类对象的构造器）。
• 当初始化一个类的时候，如果发现其父类还没有进行初始化，则需要先触发其父类的初始化。
• 虚拟机会保证一个类的()方法在多线程环境中被正确加锁和同步。

D、示例

1、示例代码

示例：
public class Lesson005 {
    public static void main(String[] args) {
        System.out.println("获取A类的m值为="+A.m);
    }
}

class A {
    static {
        System.out.println("A类静态代码初始化");
        m = 300;
    }

    static int m = 100;

    public A() {
        System.out.println("A类无参构造初始化");
    }
}

运行结果：
A类静态代码初始化
获取A类的m值为=100

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

2、运行逻辑分析

a、加载到内存，会产生一个类对应Class对象
b、链接，链接结束后 m=0
c、初始化
(){
System.out.println(“A类静态代码初始化”);
m = 300;
m = 100;
}
d、最终 m=100

3、运行分析图

上述代码运行分析图：

end