——基础篇——

JVM

什么是JVM

JVM 全称： Java Virtual Machine

本质上是一个运行在计算机上的程序，职责是运行Java字节码文件

JVM的功能

解释和运行

对字节码文件中的指令，实时的解释成机器码，让计算机执行

内存管理

• 自动为对象、方法等分配内存
• 自动的垃圾回收机制，回收不再使用的对象

即时编译（Just-In-Time 简称JIT)

• 对热点代码进行优化，提升执行效率
• Java语言如果不做任何优化，性能不如C、C++等语言
• java是实时解释成机器码、c/c++是直接编译和链接成机器码

• java的实时解释，主要是为了支持跨平台特性

• 由于JVM需要实时解释虚拟机指令，不做任何优化性能不如直接运行机器码的C、C++等语言

  • jvm发现一段字节码是热点代码的字节码指令时（很短时间内被多次调用），就会解释并优化这段字节码为汇编和机器码，然后保存至内存中，下次执行可以直接从内存从中调用（空间换时间）

  

常见的JVM

java虚拟机规范

• 《Java虚拟机规范》由Oracle制定，内容主要包含了Java虚拟机在设计和实现时需要遵守的规范，主 要包含class字节码文件的定义、类和接口的加载和初始化、指令集等内容
• 《Java虚拟机规范》是对虚拟机设计的要求，而不是对Java设计的要求，也就是说虚拟机可以运行在 其他的语言比如Groovy、Scala生成的class字节码文件之上
• 官网 Java SE Specifications (oracle.com)

字节码文件

JVM的组成

本地接口eg：

字节码文件的组成

使用jclasslib打开字节码文件

可以github安装或者idea装插件

Magic 魔数

用来标识文件类型为java字节码文件

• 文件是无法通过文件扩展名来确定文件类型的，文件扩展名可以随意修改，不影响文件的内容
• 软件使用文件的头几个字节（文件头）去校验文件的类型，如果软件不支持该种类型就会出错
• Java字节码文件中，将文件头称为magic魔数

主副版本号

主副版本号指的是编译字节码文件的JDK版本号

• 主版本号用来标识大版本号，JDK1.0-1.1使用了45.0-45.3，JDK1.2是46，之后每升级一个大版本就加1
• 副版本号是当主版本号相同时作为区分不同版本的标识，一般只需要关心主版本号
• 版本号的作用主要是判断当前字节码的版本和运行时的JDK是否兼容
• 1.2之后大版本号计算方法：==主版本号 – 44==
  • 比如主版本号52就是JDK8

🙋‍♀️🌰主版本号不兼容导致的错误

需求： 解决以下由于主版本号不兼容导致的错误:

类文件具有错误的版本52.0，应为50.0 请删除该文件或确保该文件位于正确的类路径子目录中。

• 方案1：

升级JDK版本（容易引发其他的兼容性问题，并且需要大量的测试）

• 方案2：

将第三方依赖的版本号降低或者更换依赖，以满足JDK版本的要求

常量池

• 字节码文件中常量池的作用：==避免相同的内容重复定义，节省空间==
• 常量池中的数据都有一个编号，编号从1开始。在字段或者字节码指令中通过编号可以快速的找到对应的数据
• 字节码指令中通过编号引用到常量池的过程称之为符号引用

🙋‍♀️🌰：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

package example;

/**
 * @author：CharmingDaiDai
 * @project：study
 * @since：2024/6/27 下午2:10
 */
public class test {
    public static final String str1 = "abc";
    public static final String str2 = "abc";
    public static final String abc = "abc";

    public static void main(String[] args) {
        test t = new test();
    }
}

引用了编号为13的内容

13是一个字符串引用14

14存放字面量abc

变量名直接指向字面量

❓为什么13不直接是字面量abc

• 因为有字符串常量池，所以要保留String
• 因为字面量可能是变量名的，可能是字符串的

方法

🙋‍♀️🌰：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

package part1;

/**
 * @author：CharmingDaiDai
 * @project：LearnJVM
 * @since：2024/6/27 下午2:30
 */
public class test2 {
    public static void main(String[] args) {
        int i = 0;
        i = i++;
        System.out.println("i = " + i);
    }
}

查看方法

iconst_<i>

Push the int constant <i> (-1, 0, 1, 2, 3, 4 or 5) onto the operand stack

格式 iconst_<i>

• 操作数栈是临时存放数据的地方，局部变量表是存放方法中的局部变量的位置

istore_<i>

从操作数栈取出（弹出）放入局部变量表1号位置（操作数栈的数据被弹出了）

iload_<i>

将局部变量表1中的数据放入操作数栈（局部变量表中的数据还在）

i=i++

i=++i

Q：int i = 0; i = i++; 最终i的值是多少？

A：答案是0，我通过分析字节码指令发现，i++先把0取出来放入临时的操作数栈中，

接下来对i进行加1，i变成了1，最后再将之前保存的临时值0放入i，最后i就变成了0

常用工具

javap -v命令

• javap是JDK自带的反编译工具，可以通过控制台查看字节码文件的内容。适合在服务器上查看字节码文件内 容
• 直接输入javap查看所有参数
• 输入javap -v 字节码文件名称 查看具体的字节码信息（如果 jar包需要先使用 jar –xvf 命令解压）

1

javap -v .\test2.class

1

javap -v .\test2.class > ./test2.txt

jclasslib

• idea下载

• github下载

阿里arthas

Arthas 是一款线上监控诊断产品，通过全局视角实时查看应用 load、内存、gc、线程的状态信息，并能在不修

改应用代码的情况下，对业务问题进行诊断，大大提升线上问题排查效率

功能

使用

• 是一个jar包，通过 java -jar .\arthas-boot.jar启动

官网： | arthas (aliyun.com)

• 打开后会显示当前运行的java程序

• 输入序号 4，然后 enter

• 会自动下载最新版的 arthas home: C:\Users\charmingdaidai\.arthas\lib\3.7.2\arthas

命令

• 清空命令行

  • cls

• dashboard

  • dashboard -i 2000 -n 3
  • 

• dump已加载类的字节码文件到特定目录

  • dump -d 路径 类名

  • 1	dump -d D:\Language\JAVA\LearnJVM\target\classes\part1 part1.test2

  • 

• 反编译已加载类的源码

  • jad 类名

  • 1	jad part1.test2

  • 

🙋‍♀️🌰

小李的团队昨天对系统进行了升级修复了某个bug，但是升级完之后发现bug还是存在，小李怀疑是因为没有把最新的字节码文件部署到服务器上，请使用阿里的arthas去确认升级完的字节码文件是不是最新的

思路

在出问题的服务器上部署一个 arthas，并启动

连接 arthas的控制台，使用 jad命令加上想要查看的类名，反编译出源码

确认源码是否是最新的

类的生命周期

高频面试题、大厂笔试题、后续基础知识

类的生命周期描述了一个类加载、使用、卸载的整个过程

加载 -> 连接 -> 初始化 -> 使用 -> 卸载

​ ↓

验证 -> 准备 -> 解析

加载阶段

• 加载(Loading)阶段第一步是==类加载器==根据类的全限定名通过不同的渠道以二进制流的方式获取字节码信息。

  程序员可以使用Java代码拓展的==不同的渠道==

  • 本地文件：磁盘上的字节码文件
  • 动态代理生成：程序运行时使用动态代理生成
  • 通过网络传输的类：早期的Applet技术使用

• 类加载器在加载完类之后，Java虚拟机会将字节码中的信息保存到方法区中

• 类加载器在加载完类之后，Java虚拟机会将字节码中的信息保存到内存的方法区中 生成一个==InstanceKlass==对象，保存类的所有信息，里边还包含实现特定功能比如多态的信息

  • 为了和源代码中的class区分，使用了klass
  • 不同的JVM或者不同的版本方法区可能不一样
  • 

• 同时，Java虚拟机还会在堆中生成一份与方法区中数据类似的java.lang.Class对象。==作用是在Java代码中去获取类的信息以及存储静态字段的数据（JDK8及之后）==

  • 
  • InstanceKlass一般是C++编写的对象，java不能直接操作
  • Java.lang.Class内容比InstanceKlass少
  • Java.lang.Class也可以一定程度上保障安全

• 查看内存中的对象

  • 推荐使用 JDK自带的hsdb工具查看Java虚拟机内存信息。工具位于JDK安装目录下lib文件夹中的sa-jdi.jar中
  • 启动命令：java -cp sa-jdi.jar sun.jvm.hotspot.HSDB
  • JDK17的目录下没有😭

  • 1 2 3

    cd D:\JAVA\JDK1.8\lib java -cp sa-jdi.jar sun.jvm.hotspot.HSDB

  • 
  • 
  • 输入进程ID
  • 可以在powershell中输入 jps获得ID

  • 1 2 3 4 5 6 7

    PS D:\Language\JAVA\LearnJVM\target\classes\part1> jps 27056 test2 51520 RemoteMavenServer36 5936 HSDB 31348 36612 Launcher 54740 Jps

  • 

连接阶段

验证：验证内容是否满足《Java虚拟机规范》

这个阶段一般不需要程序员参与

• 文件格式验证，比如文件是否以0xCAFEBABE开头，主次版本号是否满足当前Java虚拟机版本要求
• 元信息验证，例如类必须有父类（super不能为空）默认是 <java/lang/Object>
• 验证程序执行指令的语义，比如方法内的指令执行中跳转到不正确的位置
• 符号引用验证，例如是否访问了其他类中private的方法等

主副版本号的校验

Hotspot JDK8中虚拟机源码对版本号检测的代码如下：

==主版本号不能高于运行环境主版本号，如果主版本号相等，副版本号也不能超过==

JDK12之后副版本号才不为0

准备：给静态变量赋初值

准备阶段为静态变量（static）分配内存并设置初始值

==本章涉及到的内存结构只讨论JDK8及之后的版本，8之前的版本后续章节详述==

==初始化阶段才会进行赋值阶段，准备阶段只赋初始值==

准备阶段只会给静态变量赋初始值，而每一种基本数据类型和引用数据类型都有其初始值

Q：为什么要赋初始值？

A：防止之前的内存区域有值，会出现随机值的情况

final修饰的基本数据类型的静态变量，准备阶段直接会将代码中的值进行赋值

解析`：将常量池中的符号引用替换成指向内存的直接引用

解析阶段主要是将常量池中的符号引用替换为直接引用

符号引用就是在字节码文件中使用编号来访问常量池中的内容

直接引用不再使用编号，而是使用内存中地址进行访问具体的数据

初始化阶段

• 初始化阶段会执行==静态代码块中的代码==，并==为静态变量赋值==
• 初始化阶段会执行字节码文件中==clinit==（class init）部分的字节码指令

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

package part1;

/**
 * @author：CharmingDaiDai
 * @project：LearnJVM
 * @since：2024/6/27 下午9:01
 */
public class test3 {
    public static int value = 1;

    static {
        value = 2;
    }

    public static void main(String[] args) {
      
    }
}

putstatic

给类中的静态字段赋值

交换一下顺序

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

public class test3 {
    static {
        value = 2;
    }

    public static int value = 1;

    public static void main(String[] args) {

    }
}

==clinit方法中的执行顺序与Java中编写的顺序是一致的==

什么情况会导致类的初始化

添加-XX:+TraceClassLoading 参数可以打印出加载并初始化的类

访问一个类的静态变量或者静态方法，注意变量是final修饰的并且等号右边是常量不会触发初始化（final修饰的常量在连接阶段的准备过程中赋值）

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

package part1;

/**
 * @author：CharmingDaiDai
 * @project：LearnJVM
 * @since：2024/6/27 下午9:44
 */
public class test4 {
    public static void main(String[] args) {
        int i = Demo2.i;
        System.out.println(i);
    }
}

class Demo2 {
    static {
        System.out.println("初始化了...");
    }

    public static int i = 0;
}

直接运行

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

[Loaded part1.Demo2 from file:/D:/Language/JAVA/LearnJVM/target/classes/]
[Loaded sun.misc.FloatingDecimal$BinaryToASCIIConverter from D:\JAVA\JDK1.8\jre\lib\rt.jar]
[Loaded sun.misc.FloatingDecimal$ExceptionalBinaryToASCIIBuffer from D:\JAVA\JDK1.8\jre\lib\rt.jar]
[Loaded sun.misc.FloatingDecimal$BinaryToASCIIBuffer from D:\JAVA\JDK1.8\jre\lib\rt.jar]
初始化了...
0
[Loaded sun.misc.FloatingDecimal$1 from D:\JAVA\JDK1.8\jre\lib\rt.jar]
[Loaded JDK.internal.misc.TerminatingThreadLocal$1 from D:\JAVA\JDK1.8\jre\lib\rt.jar]
[Loaded sun.misc.FloatingDecimal$ASCIIToBinaryConverter from D:\JAVA\JDK1.8\jre\lib\rt.jar]
[Loaded sun.misc.FloatingDecimal$PreparedASCIIToBinaryBuffer from D:\JAVA\JDK1.8\jre\lib\rt.jar]
[Loaded java.lang.Shutdown from D:\JAVA\JDK1.8\jre\lib\rt.jar]
[Loaded sun.misc.FloatingDecimal$ASCIIToBinaryBuffer from D:\JAVA\JDK1.8\jre\lib\rt.jar]
[Loaded java.lang.Shutdown$Lock from D:\JAVA\JDK1.8\jre\lib\rt.jar]

加上final public static final int i = 0;

1

0

原因：final在连接阶段就赋值了，访问Demo2的变量i不会进行初始化阶段的执行

调用Class.forName(String className)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

public class test4 {
    public static void main(String[] args) throws ClassNotFoundException {
        Class<?> clazz = Class.forName("part1.Demo2");
    }
}

class Demo2 {
    static {
        System.out.println("初始化了...");
    }

    public static int i = 0;
}

1

初始化了...

new一个该类的对象时

执行Main方法的当前类

🙋‍♀️🌰题目1

D A C B C B

这块代码在每次创建对象时都会执行，代码块的内容会被编译到构造函数中，但是位置靠前

1
2
3

{
    System.out.println("C")
}

• clinit指令在特定情况下不会出现，比如：如下几种情况是不会进行初始化指令执行的
  • 无静态代码块且无静态变量赋值语句
  • 有静态变量的声明，但是没有赋值语句
  • public static int a;
  • 静态变量的定义使用final关键字，这类变量会在准备阶段直接进行初始化
  • public final static int a = 10

🙋‍♀️🌰题目2

2

• 直接访问父类的静态变量，不会触发子类的初始化
• 子类的初始化clinit调用之前，会先调用父类的clinit初始化方法

去掉 new B02()

🙋‍♀️🌰题目3

分析如下代码的运行结果

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

package part1;

/**
 * @author：CharmingDaiDai
 * @project：LearnJVM
 * @since：2024/6/27 下午10:36
 */
public class test5 {
    public static void main(String[] args) {
        Test2_A[] arr = new Test2_A[10];
    }
}

class Test2_A {
    static {
        System.out.println("Test2A的静态代码块运行");
    }
}

bipush

Push byte

bipush byte

立即数字节被符号扩展为一个int值。该值被推送到操作数堆栈中

anewarray

Create new array of reference

anewarray indexbyte1 indexbyte2

astore_<n>

将引用存储到局部变量中

<n>必须是当前帧的局部变量数组的索引。操作数堆栈顶部的objectref必须是returnAddress类型或reference类型。它从操作数堆栈中弹出，<n>处的局部变量的值设置为objectref

==数组的创建不会导致数组中元素的类进行初始化==

🙋‍♀️🌰题目4

分析如下代码的运行结果

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

package part1;

/**
 * @author：CharmingDaiDai
 * @project：LearnJVM
 * @since：2024/6/28 上午10:02
 */
public class test6 {
    public static void main(String[] args) {
        System.out.println(Test4_A.a);
    }
}

class Test4_A {
    public static final int a = Integer.valueOf(1);

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

1
2

Test3A的静态代码块运行
1

getstatic

从类中获取静态字段

==final修饰的变量如果赋值的内容需要执行指令才能得出结果，会执行clinit方法进行初始化==

类加载器

类加载器（ClassLoader）是Java虚拟机提供给应用程序去实现获取类和接口字节码数据的技术

类加载器只参与加载过程中的字节码获取并加载到内存这一部分

本地接口JNI是Java Native Interface的缩写，允许Java调用其他语言编写的方法。

在hotspot类加载器中，主要用于调用Java虚拟机中的方法，这些方法使用C++编写

应用场景：

企业级应用、面试题、解决线上问题

类加载器的分类

• 类加载器分为两类，一类是Java代码中实现的，一类是Java虚拟机底层源码实现的

• 类加载器的设计JDK8和8之后的版本差别较大，JDK8及之前的版本中默认的类加载器有如下几种：

启动类加载器

• 启动类加载器（Bootstrap ClassLoader）是由Hotspot虚拟机提供的、使用C++编写的类加载器
• 默认加载Java安装目录/jre/lib下的类文件，比如rt.jar、tools.jar、resources.jar等

通过启动类加载器去加载用户jar包

• 法一：放入jre/lib下进行扩展（不推荐）
  • 尽可能不要去更改JDK安装目录中的内容，会出现即时放进去由于文件名不匹配的问题也不会正常地被加载
• 法二：使用参数进行扩展（推荐）
  • 使用==-Xbootclasspath/a:jar包目录/jar包名== 进行扩展
  • a表示追加（append）

扩展类加载器、应用程序类加载器

• 扩展类加载器和应用程序类加载器都是JDK中提供的、使用Java编写的类加载器
• 它们的源码都位于sun.misc.Launcher中，是一个静态内部类。继承自URLClassLoader。具备通过目录 或者指定jar包将字节码文件加载到内存中
• 扩展类加载器（Extension Class Loader）是JDK中提供的、使用Java编写的类加载器。
• 扩展类加载器默认加载Java安装目录/jre/lib/ext下的类文件

通过扩展类加载器去加载用户jar包

• 法一：放入/jre/lib/ext下进行扩展（不推荐）
  • 尽可能不要去更改JDK安装目录中的内容
• 法二：使用参数进行扩展（推荐）
  • 使用==-Djava.ext.dirs=“jar包目录”==进行扩展,这种方式会覆盖掉原始目录，可以用;(windows):(macos/linux)追加上原始目录

Arthas中类加载器相关的功能

类加载器的详细信息可以通过classloader命令查看

• BootstrapClassLoader 加载核心类
• ExtClassLoader 扩展类加载器加载通用的类
• AppClassLoader 加载自己编写的类

sc -d 全类名 可以搜索某个类

类加载器的加载路径可以通过classloader –c hash值 查看

classloader -l 查看hash值

classloader –c hash值

启动类加载器加载了启动类和扩展类

类加载器双亲委派机制

• 双亲是parent翻译过来的，实际上只有一个父类
• 应用程序类加载器的parent父类加载器是扩展类加载器，而扩展类加载器的parent是空
• 启动类加载器使用C++编写，没有上级类加载器

作用

• 保证类加载的安全性

  通过双亲委派机制，让顶层的类加载器去加载 核心类，避免恶意代码替换JDK中的核心类库，比如java.lang.String，确保核心类库的完整性和安全性

• 避免重复加载

  双亲委派机制可以避免同一个类被多次加载，上层的类加载器如果加载过类，就会直接返回该类，避免重复加载

机制

自底向上查找是否加载过，再由顶向下进行加载

• 在类加载的过程中，每个类加载器都会先检查是否已经加载了该类，如果已经加载则直接返回，否则会 将加载请求委派给父类加载器
• 如果类加载的parent为null，则会提交给启动类加载器处理
• 如果所有的父类加载器都无法加载该类，则由当前类加载器自己尝试加载。所以看上去是自顶向下尝试 加载
• 第二次再去加载相同的类，仍然会向上进行委派，如果某个类加载器加载过就会直接返回

==向下委派的优点：起到了加载优先级的作用==

解决三个问题

重复的类

Q：如果一个类重复出现在三个类加载器的加载位置，应该由谁来加载？

A：启动类加载器加载，根据双亲委派机制，它的优先级是最高的

String类能覆盖吗

Q：在自己的项目中去创建一个java.lang.String类，会被加载吗？

A：不能，会交由启动类加载器加载在rt.jar包中的String类，会直接返回

类加载器的关系

Q：这几个类加载器彼此之间存在关系吗？

A：应用类加载器的父类加载器是扩展类加载器，扩展类加载器没有父类加载器，但是会委派给启动类加载器加载

在Java中如何使用代码的方式去主动加载一个类呢？

方式1：使用Class.forName方法，使用当前类的类加载器去加载指定的类

方式2：获取到类加载器，通过类加载器的loadClass方法指定某个类加载器加载

打破双亲委派机制

自定义类加载器

• 自定义类加载器并且重写loadClass方法，就可以将双亲委派机制的代码去除
• Tomcat通过这种方式实现应用之间类隔离，《面试篇》中分享它的做法

问题

一个Tomcat程序中是可以运行多个Web应用的，如果这两个应用中出现了相同限定名的类，比如Servlet类，Tomcat要保证这两个类都能加载并且它们应该是不同的类。如果不打破双亲委派机制，当应用类加载器加载Web应用1中的MyServlet之后，Web应用2中相同限定名的MyServlet类就无法被加载了

解决

Tomcat使用了自定义类加载器来实现应用之间类的隔离。 每一个应用会有一个独立的类加载器加载对应的类

代码

ClassLoader中包含了4个核心方法，双亲委派机制的核心代码就位于loadClass方法中

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

public Class<?> loadClass(String name)
类加载的入口，提供了双亲委派机制。内部会调用findClass。重要

protected Class<?> findClass(String name)
由类加载器子类实现，获取二进制数据调用defineClass，比如URLClassLoader会根据文件路径去获取类文件中的二进制数据。重要

protected final Class<?> defineClass(String name, byte[] b, int off, int len)
做一些类名的校验，然后调用虚拟机底层的方法将字节码信息加载到虚拟机内存中

protected final void resolveClass(Class<?> c)
执行类生命周期中的连接阶段

入口方法：

再进入看下：

如果查找都失败，进入加载阶段，首先会由启动类加载器加载，这段代码在 findBootstrapClassOrNull中。如果失败会抛出异常，接下来执行下面这段代码：

父类加载器加载失败就会抛出异常，回到子类加载器的这段代码，这样就实现了加载并向下传递

最后根据传入的参数判断是否进入连接阶段：

实现打破双亲委派机制：

 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
64
65
66
67
68
69
70
71
72
73
74
75
76
77

package classloader.broken;//package com.itheima.jvm.chapter02.classloader.broken;

import org.apache.commons.io.IOUtils;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.nio.charset.StandardCharsets;
import java.security.ProtectionDomain;
import java.util.regex.Matcher;

/**
 * 打破双亲委派机制 - 自定义类加载器
 */

public class BreakClassLoader1 extends ClassLoader {

    private String basePath;
    private final static String FILE_EXT = ".class";

    //设置加载目录
    public void setBasePath(String basePath) {
        this.basePath = basePath;
    }

    //使用commons io 从指定目录下加载文件
    private byte[] loadClassData(String name)  {
        try {
            String tempName = name.replaceAll("\\.", Matcher.quoteReplacement(File.separator));
            FileInputStream fis = new FileInputStream(basePath + tempName + FILE_EXT);
            try {
                return IOUtils.toByteArray(fis);
            } finally {
                IOUtils.closeQuietly(fis);
            }

        } catch (Exception e) {
            System.out.println("自定义类加载器加载失败，错误原因：" + e.getMessage());
            return null;
        }
    }

    //重写loadClass方法
    @Override
    public Class<?> loadClass(String name) throws ClassNotFoundException {
        //如果是java包下，还是走双亲委派机制
        if(name.startsWith("java.")){
            return super.loadClass(name);
        }
        //从磁盘中指定目录下加载
        byte[] data = loadClassData(name);
        //调用虚拟机底层方法，方法区和堆区创建对象
        return defineClass(name, data, 0, data.length);
    }

    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException {
        //第一个自定义类加载器对象
        BreakClassLoader1 classLoader1 = new BreakClassLoader1();
        classLoader1.setBasePath("D:\\lib\\");

        Class<?> clazz1 = classLoader1.loadClass("com.itheima.my.A");
         //第二个自定义类加载器对象
        BreakClassLoader1 classLoader2 = new BreakClassLoader1();
        classLoader2.setBasePath("D:\\lib\\");

        Class<?> clazz2 = classLoader2.loadClass("com.itheima.my.A");

        System.out.println(clazz1 == clazz2);

        Thread.currentThread().setContextClassLoader(classLoader1);

        System.out.println(Thread.currentThread().getContextClassLoader());

        System.in.read();
     }
}

• 自定义类加载器父类怎么是AppClassLoader呢？
  • 默认情况下自定义类加载器的父类加载器是应用程序类加载器
  • 
  • 以JDK8为例，ClassLoader类中提供了构造方法设置parent的内容
  • 
  • 这个构造方法由另外一个构造方法调用，其中父类加载器由getSystemClassLoader方法设置，该方法返回的是AppClassLoader
  • 

Q：两个自定义类加载器加载相同限定名的类，不会冲突吗？

A：不会冲突，在同一个Java虚拟机中，只有🚩相同类加载器+相同的类限定名🚩才会被认为是同一个类

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

 public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException {
        //第一个自定义类加载器对象
        BreakClassLoader1 classLoader1 = new BreakClassLoader1();
        classLoader1.setBasePath("D:\\lib\\");

        Class<?> clazz1 = classLoader1.loadClass("com.itheima.my.A");
         //第二个自定义类加载器对象
        BreakClassLoader1 classLoader2 = new BreakClassLoader1();
        classLoader2.setBasePath("D:\\lib\\");

        Class<?> clazz2 = classLoader2.loadClass("com.itheima.my.A");

        System.out.println(clazz1 == clazz2);
     }

// false

sc -d

在Arthas中使用 sc –d 类名的方式查看具体的情况

search class -detail

• 正确的去实现一个自定义类加载器的方式是重写findClass方法，这样不会破坏双亲委派机制

线程上下文类加载器

利用上下文类加载器加载类，比如JDBC和JNDI等

JDBC的案例：

JDBC中使用了DriverManager来管理项目中引入的不同数据库的驱动，比如mysql驱动、oracle驱动

 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
64
65

package classloader.broken;//package com.itheima.jvm.chapter02.classloader.broken;

import com.mysql.cj.jdbc.Driver;

import java.sql.*;

/**
 * 打破双亲委派机制 - JDBC案例
 */

public class JDBCExample {
    // JDBC driver name and database URL
    static final String JDBC_DRIVER = "com.mysql.cj.jdbc.Driver";
    static final String DB_URL = "jdbc:mysql:///bank1";

    //  Database credentials
    static final String USER = "root";
    static final String PASS = "123456";

    public static void main(String[] args) {
        Connection conn = null;
        Statement stmt = null;
        try {
            conn = DriverManager.getConnection(DB_URL, USER, PASS);
            stmt = conn.createStatement();
            String sql;
            sql = "SELECT id, account_name FROM account_info";
            ResultSet rs = stmt.executeQuery(sql);

            //STEP 4: Extract data from result set
            while (rs.next()) {
                //Retrieve by column name
                int id = rs.getInt("id");
                String name = rs.getString("account_name");

                //Display values
                System.out.print("ID: " + id);
                System.out.print(", Name: " + name + "\n");
            }
            //STEP 5: Clean-up environment
            rs.close();
            stmt.close();
            conn.close();
        } catch (SQLException se) {
            //Handle errors for JDBC
            se.printStackTrace();
        } catch (Exception e) {
            //Handle errors for Class.forName
            e.printStackTrace();
        } finally {
            //finally block used to close resources
            try {
                if (stmt != null)
                    stmt.close();
            } catch (SQLException se2) {
            }// nothing we can do
            try {
                if (conn != null)
                    conn.close();
            } catch (SQLException se) {
                se.printStackTrace();
            }//end finally try
        }//end try
    }//end main
}//end FirstExample

DriverManager类位于rt.jar包中，由启动类加载器加载

依赖中的mysql驱动对应的类，由应用程序类加载器来加载

在类中有初始化代码：

DriverManager属于rt.jar是启动类加载器加载的。而用户jar包中的驱动需要由应用类加载器加载，这就违反了双亲委派机制。（这点存疑，一会儿再讨论）

DriverManager怎么知道jar包中要加载的驱动在哪儿？

在类的初始化代码中有这么一个方法 LoadInitialDrivers：

这里使用了SPI机制，去加载所有jar包中实现了Driver接口的实现类

SPI机制

spi全称为(Service Provider Interface)，是JDK内置的一种服务提供发现机制

SPI机制就是在这个位置下存放了一个文件，文件名是接口名，文件里包含了实现类的类名。这样SPI机制就可以找到实现类了

SPI中利用了线程上下文类加载器（应用程序类加载器）去加载类并创建对象

1
2

// 手动设置当前线程类加载器
Thread.currentThread().setContextclassLoader(classLoader1);

总结：

JDBC案例中真的打破了双亲委派机制吗？

最早这个论点提出是在周志明《深入理解Java虚拟机》中，他认为打破了双亲委派机制，这种由启动类加载器加载的类，委派应用程序类加载器去加载类的方式，所以打破了双亲委派机制。

但是如果我们分别从DriverManager以及驱动类的加载流程上分析，JDBC只是在DriverManager加载完之后，通过初始化阶段触发了驱动类的加载，类的加载依然遵循双亲委派机制

所以这里==没有打破双亲委派机制==，只是用一种巧妙的方法让启动类加载器加载的类，去引发的其他类的加载

Osgi框架的类加载器（了解）

• 历史上，OSGi模块化框架。它存在同级之间的类加载器的委托加载。OSGi还使用类加载器实现了热部署的功能
• ==热部署指的是在服务不停止的情况下，动态地更新字节码文件到内存中==

这种机制使用已经不多，着重看下热部署在实际项目中的应用

案例：使用阿里arthas不停机解决线上问题（应急手段）

背景：

小李的团队将代码上线之后，发现存在一个小bug，但是用户急着使用，如果重新打包再发布需要一个多小时的时间，所以希望能使用arthas尽快的将这个问题修复。

思路：

• 在出问题的服务器上部署一个 arthas，并启动
• jad --source-only 类全限定名 > 目录/文件名.java

jad 命令反编译，然后可以用其它编译器，比如 vim 来修改源码

• mc –c 类加载器的hashcode 目录/文件名.java -d 输出目录

  mc 命令用来编译修改过的代码

• retransform class文件所在目录/xxx.class

  用 retransform 命令加载新的字节码

详细流程：

1、这段代码编写有误，在枚举中的类型判断上使用了 == 而不是 equals

2、枚举中是这样定义的，1001是普通用户，1002是VIP用户：

3、由于代码有误，导致传递1001参数时，返回的是收费用户的内容

4、jad --source-only 类全限定名 > 目录/文件名.java 使用 jad 命令反编译，然后可以用其它编译器，比如 vim 来修改源码

直接双击文件使用finalShell编辑：

5、mc –c 类加载器的hashcode 目录/文件名.java -d 输出目录 使用mc 命令用来编译修改过的代码

这里会提示找不到其他的类，因为编译需要依赖其他类

使用 sc -d 全类名 找到类加载器的 hash值

6、retransform class文件所在目录/xxx.class 用 retransform 命令加载新的字节码

7、测试

注意事项：

1、程序重启之后，字节码文件会恢复，除非将class文件放入jar包中进行更新（因为只是将字节码的内容更新到了内存中）

2、使用retransform不能添加方法或者字段，也不能更新正在执行中的方法

JDK9之后的类加载器

JDK8及之前的版本中，扩展类加载器和应用程序类加载器的源码位于 rt.jar包中的 sun.misc.Launcher.java

由于JDK9引入了module的概念，类加载器在设计上发生了很多变化

• 启动类加载器使用Java编写，位于JDK.internal.loader.ClassLoaders类中

  • Java中的BootClassLoader继承自BuiltinClassLoader实现从模块中找到要加载的字节码资源文件
  • 启动类加载器依然无法通过java代码获取到，返回的仍然是null，保持了统一

• 扩展类加载器被替换成了平台类加载器（Platform Class Loader）

  • 平台类加载器遵循模块化方式加载字节码文件，所以继承关系从URLClassLoader变成了BuiltinClassLoader，BuiltinClassLoader实现了从模块中加载字节码文件
  • 平台类加载器的存在更多的是为了与老版本的设计方案兼容，自身没有特殊的逻辑

运行时数据区

• Java虚拟机在运行Java程序过程中管理的内存区域，称之为运行时数据区

• 内存调优路线
  • 了解运行时内存结构 了解JVM运行过程中每一部分的内存结构以及哪些部分容易出现内存溢出
  • 掌握内存问题的产生原因 学习代码中常见的几种内存泄漏、性能问题的常见原因
  • 掌握内存调优的基本方法 学习内存泄漏、性能问题等常见JVM问题的常规解决方案

程序计数器

程序计数器（Program Counter Register）也叫PC寄存器，每个线程会通过程序计数器记录当前要执行的的字节码指令的地址

一个程序计数器的具体案例：

在加载阶段，虚拟机将字节码文件中的指令读取到内存之后，会将原文件中的偏移量转换成内存地址。每一条字节码指令都会拥有一个内存地址

在代码执行过程中，程序计数器会记录下一行字节码指令的地址。执行完当前指令之后，虚拟机的执行引擎根据程序计数器执行下一行指令。这里为了简单起见，使用偏移量代替，真实内存中执行时保存的应该是地址

比如当前执行的是偏移量为0的指令，那么程序计数器中保存的就是下一条的地址（偏移量1）

❗️❗️❗️程序计数器，实际上保存的是地址，不是图中的偏移❗️❗️❗️

一路向下执行

一直执行到方法的最后一行指令，此时方法执行return语句，当前方法执行结束，程序计数器中会放入方法出口的地址（栈中讲解，简单来说就是这个B方法结束了，A调用了B，那么要回到A方法）

所以，程序计数器可以控制程序指令的进行，实现分支、跳转、异常等逻辑。不管是分支、跳转、异常，只需要在程序计数器中放入下一行要执行的指令地址即可

在多线程执行情况下，Java虚拟机需要通过程序计数器记录CPU切换前解释执行到那一句指令并继续解释运行

Q：程序计数器会出现内存溢出吗？

A：内存溢出指的是程序在使用某一块内存区域时，存放的数据需要占用的内存大小超过了虚拟机能提供的内存上限。

由于每个线程只存储一个固定长度的内存地址，程序计数器是不会发生内存溢出的。程序员无需对程序计数器做任何处理。

栈

二者使用了一个栈来保存方法信息

Java虚拟机栈

• Java虚拟机栈（Java Virtual Machine Stack）采用栈的数据结构来管理方法调用中的基本数据，先进后出（First In Last Out），每一个方法的调用使用一个栈帧（Stack Frame）来保存

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

public class MethodDemo {   
    public static void main(String[] args) {      
         study();  
     }

    public static void study(){
        eat();

        sleep();
    }   
  
    public static void eat(){     
         System.out.println("吃饭");   
    }  
  
    public static void sleep(){      
        System.out.println("睡觉");  
        }
  }

main方法执行时，会创建main方法的栈帧：

接下来执行study方法，会创建study方法的栈帧

进入eat方法，创建eat方法的栈帧

eat方法执行完之后，会弹出它的栈帧：

然后调用sleep方法，创建sleep方法栈帧

最后study方法结束之后弹出栈帧，main方法结束之后弹出main的栈帧

Idea中

打上断点debug之后会出现栈帧内容：

抛出异常时也会打印

顺序和代码顺序相反，因为先进后出

Java虚拟机栈随着线程的创建而创建，而回收则会在线程的销毁时进行。

由于方法可能会在不同线程中执行，每个线程都会包含一个自己的虚拟机栈。如下就有两个线程的虚拟机栈，main线程和线程A。

栈帧的组成

• 局部变量表
  • 局部变量表的作用是在运行过程中存放所有的局部变量
• 操作数栈
  • 操作数栈是栈帧中虚拟机在执行指令过程中用来存放临时数据的一块区域
• 帧数据
  • 帧数据主要包含动态链接、方法出口、异常表的引用

局部变量表

• 局部变量表的作用是在方法执行过程中存放所有的局部变量
• 局部变量表分为两种，一种是==字节码文件==中的，另外一种是==栈帧==中的也就是保存在==内存==中
• 栈帧中的局部变量表是根据字节码文件中的内容生成的

字节码文件的局部变量表

• 编译成字节码文件时就可以确定局部变量表的内容

1
2
3
4

public static void test1(){
    int i = 0;
    long j = 1;
}

• test1方法的局部变量表如下：

• 局部变量表中保存了字节码指令生效的偏移量：

• 比如 i这个变量，它的起始PC是2，代表从 lconst_1这句指令开始才能使用 i，长度为3，也就是2-4这三句指令都可以使用 i。为什么从2才能使用，因为0和1这两句字节码指令还在处理 int i = 0这句赋值语句。j这个变量只有等3指令执行完之后也就是 long j = 1代码执行完之后才能使用，所以起始PC为4，只能在4这行字节码指令中使用

栈帧中的局部变量表

• 栈帧中的局部变量表，栈帧中的局部变量表是一个数组，数组中每一个位置称之为槽(slot) ，long和double类型占用两个槽，其他类型占用一个槽
• 一个槽4字节

• i占用数组下标为0的位置，j占用数组下标1-2的位置
• 刚才看到的是静态方法，实例方法中的==序号为0的位置存放的是this==，指的是当前调用方法的对象，运行时会在内存中存放实例对象的地址

• 方法参数也会保存在局部变量表中，其顺序与方法中参数定义的顺序一致。局部变量表保存的内容有：实例方法的this对象，方法的参数，方法体中声明的局部变量。

• test3方法中包含两个参数 k,m，这两个参数也会被加入到局部变量表中

Q：以下代码的局部变量表中会占用几个槽？

1 2 3 4 5 6 7 8 9 10 11

public void test4(int k,int m){ { int a = 1; int b = 2; } { int c = 1; } int i = 0; long j = 1; }

A：6

Explain：

• 为了节省空间，局部变量表中的槽是可以复用的，一旦某个局部变量不再生效，当前槽就可以再次被使用
• this占用1个，1/1
• k、m占用两个，3/3
• a、b占两个槽，5/5，出代码块后失效，3/5
• c复用，4/5，出代码块后失效，3/5
• i复用，4/5
• j需要两个，6/6

==复用是覆盖，局部变量不生效并没有清空槽，而是接下来的可以覆盖==

局部变量表数值的长度为6。这一点在编译期间就可以确定了，运行过程中只需要在栈帧中创建长度为6的数组即可

操作数栈

操作数栈是栈帧中虚拟机在执行指令过程中用来存放中间数据的一块区域。他是一种栈式的数据结构，如果一条指令将一个值压入操作数栈，则后面的指令可以弹出并使用该值

• 在编译期就可以确定操作数栈的最大深度，从而在执行时正确的分配内存大小

• 比如之前的相加案例中，操作数栈最大的深入会出现在这个时刻：
• 0存放的是==this的引用==

• 所以操作数栈的深度会定义为2

帧数据

动态链接

当前类的字节码指令引用了其他类的属性或者方法时，需要将符号引用（编号）转换成对应的运行时常量池中的内存地址。==动态链接就保存了编号到运行时常量池的内存地址的映射关系==

方法出口

方法出口指的是方法在正确或者异常结束时，当前栈帧会被弹出，同时程序计数器应该指向上一个栈帧中的下一条指令的地址。所以在当前栈帧中，需要存储此方法出口的地址

异常表

异常表存放的是代码中异常的处理信息，包含了异常捕获的生效范围以及异常发生后跳转到的字节码指令位置

如下案例：i=1这行源代码编译成字节码指令之后，会包含偏移量2-4这三行指令

其中2-3是对i进行赋值1的操作，4的没有异常就跳转到10方法结束

如果出现异常的情况下，继续执行到7这行指令，7会将异常对象放入操作数栈中，这样在catch代码块中就可以使用异常对象了

接下来执行8-9，对i进行赋值为2的操作

所以异常表中，异常捕获的起始偏移量就是2，结束偏移量是4，在2-4执行过程中抛出了 java.lang.Exception对象或者子类对象，就会将其捕获，然后跳转到偏移量为7的指令

内存溢出

• Java虚拟机栈如果栈帧过多，占用内存超过栈内存可以分配的最大大小就会出现内存溢出
• Java虚拟机栈内存溢出时会出现StackOverflowError的错误

• 如果不指定栈的大小，JVM 将创建一个具有默认大小的栈。大小取决于操作系统和计算机的体系结构

测试

1
2
3
4
5
6

public static int count = 0;
     //递归方法调用自己
     public static void recursion(){
         System.out.println(++count);
         recursion();
     }

• 使用递归让方法调用自身，但是不设置退出条件。定义调用次数的变量，每一次调用让变量加1。查看错误发生时总调用的次数

要修改Java虚拟机栈的大小，可以使用虚拟机参数 -Xss

• 语法：-Xss栈大小
• 单位：字节（默认，必须是 1024 的倍数）、k或者K(KB)、m或者M(MB)、g或者G(GB)

1
2
3
4

-Xss1048576 
-Xss1024K    
-Xss1m
-Xss1g

操作步骤

验证

发现变化不大，因为最大栈大小由操作系统决定了，在1m左右。但可以调小

• 与-Xss类似，也可以使用 -XX:ThreadStackSize 调整标志来配置堆栈大小。

格式为： -XX:ThreadStackSize=1024

• HotSpot JVM对栈大小的最大值和最小值有要求：

比如测试如下两个参数，会直接报错:

-Xss1k -Xss1025m

Windows（64位）下的JDK8测试最小值为 180k，最大值为 1024m

• 局部变量过多、操作数栈深度过大也会影响栈内存的大小

1
2
3
4
5
6

//递归方法调用自己
public static void recursion() {
    long a,b,c,d,f,g,h,i,j,k;
    System.out.println(++count);
    recursion();
}

==一般情况下，工作中即便使用了递归进行操作，栈的深度最多也只能到几百,不会出现栈的溢出。所以此参数可以手动指定为-Xss256k节省内存==

本地方法栈

• Java虚拟机栈存储了Java方法调用时的栈帧，而本地方法栈存储的是native本地方法的栈帧
• 在Hotspot虚拟机中，Java虚拟机栈和本地方法栈实现上使用了同一个栈空间
• 本地方法栈会在栈内存上生成一个栈帧，临时保存方法的参数同时方便出现异常时也把本地方法的栈信息打印出来

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

package part1;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException; /**
 * 本地方法栈
 */
public class NativeDemo1 {
    public static void main(String[] args) {
        try {
            FileOutputStream fileOutputStream = new FileOutputStream("J:\\112323.txt");
            fileOutputStream.write(1);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

堆

• 一般Java程序中堆内存是空间最大的一块内存区域。创建出来的对象都存在于堆上
• 栈上的局部变量表中，可以存放堆上对象的引用
• 静态变量也可以存放堆对象的引用，通过静态变量就可以实现对象在线程之间共享

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

public class Test {  
    public static void main(String[] args) {      
        Student s1 = new Student();      
        s1.name = "张三";     
        s1.age = 18;     
        s1.id = 1;
        s1.printTotalScore();      
        s1.printAverageScore();      
      
        Student s2 = new Student();     
        s2.name = "李四";      
        s2.age = 19;      
        s2.id= 2;      
        s2.printTotalScore();      
        s2.printAverageScore();  
    }
}

通过 new关键字创建了两个 Student类的对象，这两个对象会被存放在堆上。在栈上通过 s1和 s2两个局部变量保存堆上两个对象的地址，从而实现了引用关系的建立

堆内存的溢出

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

package part1;

import java.io.IOException;
import java.util.ArrayList;

/**
 * @author：CharmingDaiDai
 * @project：LearnJVM
 * @since：2024/7/1 下午5:09
 */
public class test8 {
    public static void main(String[] args) throws InterruptedException, IOException {

        ArrayList<Object> objects = new ArrayList<Object>();
        System.in.read();
        while (true){
            objects.add(new byte[1024 * 1024 * 100]);
            Thread.sleep(1000);
        }
    }
}

三个重要的值

• 堆空间有三个需要关注的值，used、total、max
• used指的是当前已使用的堆内存
• total是java虚拟机已经分配的可用堆内存
• max是java虚拟机可以分配的最大堆内存

查看

堆内存used total max三个值可以通过dashboard命令看到

手动指定刷新频率（不指定默认5秒一次）：dashboard –i 刷新频率(毫秒)

只关注内存可以输入 memory命令：

随着堆中的对象增多，当total可以使用的内存即将不足时，java虚拟机会继续分配内存给堆

此时used达到了total的大小，Java虚拟机会向操作系统申请更大的内存

但是这个申请过程不是无限的，==total最多只能与max相等==

那么是不是当used = max = total的时候，堆内存就溢出了呢

不是，堆内存溢出的判断条件比较复杂，在《垃圾回收器》¹中会详细介绍

如果不设置任何的虚拟机参数，max默认是系统内存的1/4，total默认是系统内存的1/64。在实际应用中一般都需要设置total和max的值

oracle官方文档

设置堆的大小

要修改堆的大小，可以使用虚拟机参数 –Xmx（max最大值）和-Xms (初始的total)

语法：-Xmx值 -Xms值

单位：字节（默认，必须是 1024 的倍数）、k或者K(KB)、m或者M(MB)、g或者G(GB)

限制：Xmx必须大于2MB，Xms必须大于1MB

1
2
3
4
5
6

-Xms6291456
-Xms6144k
-Xms6m
-Xmx83886080
-Xmx81920k
-Xmx80m

这样可以将max和初始的total都设置为4g，在启动后就已经获得了最大的堆内存大小。运行过程中不需要向操作系统申请

为什么arthas中显示的heap堆大小与设置的值不一样呢？

arthas中的heap堆内存使用了JMX技术中内存获取方式，这种方式与垃圾回收器有关，计算的是可以分配对象的内存，而不是整个内存

建议：

Java服务端程序开发时，建议将-Xmx和-Xms设置为相同的值，这样在程序启动之后可使用的总内存就是最大内存，而无需向java虚拟机再次申请，减少了申请并分配内存时间上的开销，同时也不会出现内存过剩之后堆收缩的情况。-Xmx具体设置的值与实际的应用程序运行环境有关，在《实战篇》²中会给出设置方案

方法区

方法区是存放基础信息的位置，线程共享，主要包含三部分内容：

• 类的元信息，保存了所有类的基本信息
• 运行时常量池，保存了字节码文件中的常量池内容
• 字符串常量池，保存了字符串常量

类的元信息

方法区是用来==存储每个类的基本信息（元信息）==，一般称之为==InstanceKlass==对象。在类的加载阶段完成

其中就包含了类的字段、方法等字节码文件中的内容，同时还保存了运行过程中需要使用的虚方法表（实现多态的基础）等信息

运行时常量池

方法区除了存储类的元信息之外，还存放了运行时常量池。常量池中存放的是字节码中的常量池内容

字节码文件中通过编号查表的方式找到常量，这种常量池称为静态常量池

当常量池加载到内存中之后，可以通过内存地址快速的定位到常量池中的内容，这种常量池称为运行时常量池

方法区的实现

方法区是《Java虚拟机规范》中设计的虚拟概念，每款Java虚拟机在实现上都各不相同

Hotspot设计如下：

• ==JDK7及之前==的版本将==方法区存放在堆区域中的永久代空间==，堆的大小由虚拟机参数来控制
• ==JDK8及之后==的版本将==方法区存放在元空间中==，元空间位于操作系统维护的直接内存中，默认情况下只要不超过操作系统承受的上限，可以一直分配

• JDK7及之前的版本查看 ps_perm_gen属性

• JDK8及之后的版本查看 metaspace属性

方法区的溢出

通过ByteBuddy框架，动态创建类并将字节码数据加载到内存中

通过死循环不停地加载到方法区，观察方法区是否会出现内存溢出的情况

分别在JDK7和JDK8上运行上述代码

ByteBuddy是一个基于Java的开源库，用于生成和操作Java字节码

引入依赖

1
2
3
4
5

<dependency>
    <groupId>net.bytebuddy</groupId>
    <artifactId>byte-buddy</artifactId>
    <version>1.12.23</version>
 </dependency>

创建ClassWriter对象

1

 ClassWriter classWriter = new ClassWriter(0);

调用visit方法，创建字节码数据

1
2

classWriter.visit(Opcodes.V1_7,Opcodes.ACC_PUBLIC,name,null ,"java/lang/Object",null);
byte[] bytes = classWriter.toByteArray();

测试

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

import net.bytebuddy.jar.asm.ClassWriter;
import net.bytebuddy.jar.asm.Opcodes;

import java.io.IOException;

/**
 * 方法区的溢出测试
 */
public class Demo1 extends ClassLoader {
    public static void main(String[] args) throws IOException {
        System.in.read();
        Demo1 demo1 = new Demo1();
        int count = 0;
        while (true) {
            String name = "Class" + count;
            ClassWriter classWriter = new ClassWriter(0);
            classWriter.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, name, null
                    , "java/lang/Object", null);
            byte[] bytes = classWriter.toByteArray();
            demo1.defineClass(name, bytes, 0, bytes.length);
            System.out.println(++count);
        }
    }
}

实验发现，JDK7上运行大概十几万次，就出现了错误。

在JDK8上运行百万次，程序都没有出现任何错误，但是内存会直线升高。这说明JDK7和JDK8在方法区的存放上，采用了不同的设计

• JDK7将方法区存放在堆区域中的永久代空间，堆的大小由虚拟机参数 -XX:MaxPermSize=值来控制
• JDK8将方法区存放在元空间中，元空间位于操作系统维护的直接内存中，默认情况下只要不超过操作系统承受的上限，可以一直分配。可以使用-XX:MaxMetaspaceSize=值将元空间最大大小进行限制

在JDK8中将最大元空间内存设置为256m，再次测试

这次就出现了MetaSpace溢出的错误：

建议设置一个上限，256M不够再扩

字符串常量池

方法区中除了类的元信息、运行时常量池之外，还有一块区域叫字符串常量池(StringTable)

字符串常量池存储在代码中定义的常量字符串内容。比如“123” 这个123就会被放入字符串常量池

如下代码执行时，代码中包含 abc字符串，就会被直接放入字符串常量池。在堆上创建String对象，并通过局部变量s1引用堆上的对象

接下来通过s2局部变量引用字符串常量池的 abc

所以s1和s2指向的不是同一个对象，打印出 false

字符串常量池和运行时常量池有什么关系？

早期设计时，字符串常量池是属于运行时常量池的一部分，他们存储的位置也是一致的。后续做出了调整，将字符串常量池和运行时常量池做了拆分

🙋‍♀️🌰1：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

/**
 * 字符串常量池案例
 */
public class test9 {
    public static void main(String[] args) {
        String a = "1";
        String b = "2";
        String c = "12";
        String d = a + b;
        System.out.println(c == d);
    }
}

观察字节码

• String d=a+b底层创建了一个StringBuilder对象，调用append方法添加 1、2
• 然后调用 toString方法
• 所以d创建在了堆区
• ==c!=d==

🙋‍♀️🌰2：

1
2
3
4
5
6
7
8
9

public class test9 {
    public static void main(String[] args) {
        String a = "1";
        String b = "2";
        String c = "12";
        String d = "1" + "2";
        System.out.println(c == d);
    }
}

观察字节码

• 第7行，序号9的字节码
• 使用ldc指令从常量池中取出了12
• 所以 c==d

左右都是常量 直接拼接

左右都是变量 new StringBuilder

变量 + 常量 new StringBuilder

常量 + 变量 new StringBuilder

intern方法

String.intern()方法是可以手动将字符串放入字符串常量池中

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

package part1;

import java.util.Scanner;

/**
 * @author：CharmingDaiDai
 * @project：LearnJVM
 * @since：2024/7/2 上午9:31
 */
public class internTest {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String input1 = scanner.next().intern();
        String input2 = scanner.next().intern();

        System.out.println("input1 == input2 = " + (input1 == input2));
    }
}

1
2
3

nh
nh
input1 == input2 = true

分别在JDK6 JDK8下执行代码，JDK6 中结果是false false ，JDK8中是true false

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

package part1;

/**
 * @author：CharmingDaiDai
 * @project：LearnJVM
 * @since：2024/7/2 上午9:31
 */
public class internTest {
    public static void main(String[] args) {
        String s1 = new StringBuilder().append("think").append("123").toString();
        System.out.println(s1.intern() == s1);

        String s2 = new StringBuilder().append("ja").append("va").toString();
        System.out.println(s2.intern() == s2);
    }
}

自己实验：JDK8中

1
2
3

D:\JAVA\JDK1.8\bin\java.exe "-javaagent:E:\MySoftware\IntelliJ IDEA 2024.1\lib\idea_rt.jar=7807:E:\MySoftware\IntelliJ IDEA 2024.1\bin" -Dfile.encoding=UTF-8 -classpath D:\JAVA\JDK1.8\jre\lib\charsets.jar;D:\JAVA\JDK1.8\jre\lib\ext\access-bridge-64.jar;D:\JAVA\JDK1.8\jre\lib\ext\cldrdata.jar;D:\JAVA\JDK1.8\jre\lib\ext\dnsns.jar;D:\JAVA\JDK1.8\jre\lib\ext\jaccess.jar;D:\JAVA\JDK1.8\jre\lib\ext\jfxrt.jar;D:\JAVA\JDK1.8\jre\lib\ext\localedata.jar;D:\JAVA\JDK1.8\jre\lib\ext\nashorn.jar;D:\JAVA\JDK1.8\jre\lib\ext\sunec.jar;D:\JAVA\JDK1.8\jre\lib\ext\sunjce_provider.jar;D:\JAVA\JDK1.8\jre\lib\ext\sunmscapi.jar;D:\JAVA\JDK1.8\jre\lib\ext\sunpkcs11.jar;D:\JAVA\JDK1.8\jre\lib\ext\zipfs.jar;D:\JAVA\JDK1.8\jre\lib\jce.jar;D:\JAVA\JDK1.8\jre\lib\jfr.jar;D:\JAVA\JDK1.8\jre\lib\jfxswt.jar;D:\JAVA\JDK1.8\jre\lib\jsse.jar;D:\JAVA\JDK1.8\jre\lib\management-agent.jar;D:\JAVA\JDK1.8\jre\lib\resources.jar;D:\JAVA\JDK1.8\jre\lib\rt.jar;D:\Language\JAVA\LearnJVM\target\classes part1.internTest
true
true

自己实验：JDK17中

1
2
3

D:\JAVA\JDK17.0.2\bin\java.exe "-javaagent:E:\MySoftware\IntelliJ IDEA 2024.1\lib\idea_rt.jar=7767:E:\MySoftware\IntelliJ IDEA 2024.1\bin" -Dfile.encoding=UTF-8 -classpath D:\Language\JAVA\LearnJVM\target\classes part1.internTest
true
false

JDK6中，代码执行步骤如下：

使用StringBuilder将 think和 123拼接成 think123，转换成字符串，在堆上创建一个字符串对象

局部变量 s1指向堆上的对象

调用s1.intern方法，会在字符串常量池中创建think123的对象，最后将对象引用返回

所以s1.intern和s1指向的不是同一个对象。打印出false

同理，通过StringBuilder在堆上创建java字符串对象

这里注意==字符串常量池中本来就有一个java字符串对象==，这是==java虚拟机自身使用的所以启动时就会创建==出来

调用s2.intern发现字符串常量池中已经有java字符串对象了，就将引用返回

所以s2.intern指向的是字符串常量池中的对象，而s2指向的是堆中的对象。打印结果为false

JDK7中，JDK7及之后版本中由于==字符串常量池在堆上==，所以intern () 方法会把第一次遇到的字符串的引用放入字符串常量池

代码执行步骤如下：

执行第二句代码时，由于字符串常量池中没有think123的字符串，所以直接==创建一个引用==，指向堆中的think123对象

所以s1.intern和s1指向的都是堆上的对象，打印结果为true

s2.intern方法调用时，字符串常量池中已经有java字符串了，所以将引用返回

这样打印出来的结果就是false

后续JDK版本中，如果Java虚拟机不需要使用java字符串，那么字符串常量池中就不会存放 java。打印结果有可能会出现两个true

静态变量存储在哪里呢？

• JDK6及之前的版本中，静态变量是存放在方法区中的，也就是永久代
• JDK7及之后的版本中，静态变量是存放在堆中的Class对象中，脱离了永久代。具体源码可参考虚拟机源码：BytecodeInterpreter针对putstatic指令的处理

直接内存

直接内存（Direct Memory）并不在《Java虚拟机规范》中存在，所以并不属于Java运行时的内存区域

在 JDK 1.4 中引入了 NIO 机制，使用了直接内存，主要为了解决以下两个问题:

• Java堆中的对象如果不再使用要回收，回收时会影响对象的创建和使用
• IO操作比如读文件，需要先把文件读入直接内存（缓冲区）再把数据复制到Java堆中

现在直接放入直接内存即可，同时Java堆上维护直接内存的引用，减少了数据复制的开销

写文件也是向直接内存写入，省去了从Java堆中复制的开销

使用堆创建对象的过程：

使用直接内存创建对象的过程，不需要进行复制对象，数据直接存放在直接内存中：

创建直接内存上的数据

要创建直接内存上的数据，可以使用 ByteBuffer

语法： ByteBuffer directBuffer = ByteBuffer.allocateDirect(size);

注意事项： arthas的memory命令可以查看直接内存大小，属性名direct

 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

package part1;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.List;

/**
 * @author：CharmingDaiDai
 * @project：LearnJVM
 * @since：2024/7/2 上午10:26
 */
public class test10 {
    public static int size = 1024 * 1024 * 100; //100mb
    public static List<ByteBuffer> list = new ArrayList<ByteBuffer>();
    public static int count = 0;

    public static void main(String[] args) throws IOException, InterruptedException {
        System.in.read();
        while (true) {
            //1.创建DirectByteBuffer对象并返回
            //2.在DirectByteBuffer构造方法中，向操作系统申请直接内存空间
            ByteBuffer directBuffer = ByteBuffer.allocateDirect(size);
            //directBuffer = null;

            list.add(directBuffer);
            System.out.println(++count);
            Thread.sleep(5000);
        }

    }
}

直接内存也会溢出

底层如果使用了NIO，最好设置一下直接内存的上限大小

如果需要手动调整直接内存的大小，可以使用 XX:MaxDirectMemorySize=大小

单位k或K表示千字节，m或M表示兆字节，g或G表示千兆字节

默认不设置该参数情况下，JVM 自动选择 最大分配的大小

以下示例以不同的单位说明如何将 直接内存大小设置为 1024 KB：

1
2
3

-XX:MaxDirectMemorySize=1m
-XX:MaxDirectMemorySize=1024k
-XX:MaxDirectMemorySize=1048576

总结

垃圾回收

• 在C/C++这类没有自动垃圾回收机制的语言中，对象如果不再使用，需要手动释放，否则就会出现内存泄漏
• 内存泄漏指的是不再使用的对象在系统中未被回收，内存泄漏的积累可能会导致内存溢出
• cpp内存泄漏

• 1 2 3 4 5 6 7 8

  #include "Test.h" int main() { while(1) Test* test = new Test(); return 0; }

• 手动调用delete删除对象

• 1 2 3 4 5 6 7 8 9 10 11

  #include "Test.h" int main() { while(1) { Test* test = new Test(); delete test; } return 0; }

• 称这种释放对象的过程为垃圾回收，而需要程序员编写代码进行回收的方式为手动回收
• 手动回收的方式相对来说回收比较及时，删除代码执行之后对象就被回收了，可以快速释放内存
• 缺点是对程序员要求比较高，很容易出现创建完对象之后，程序员忘记释放对象
• Java中为了简化对象的释放，引入了自动的垃圾回收（Garbage Collection简称GC）机制
• 通过垃圾回收器来对不再使用的对象完成自动的回收，垃圾回收器主要负责对==堆上的内存==进行回收。其他很多现代语言比如C#、Python、Go都拥有自己的垃圾回收器
• 垃圾回收器如果发现某个对象不再使用，就可以回收该对象

• 自动垃圾回收，自动根据对象是否使用由虚拟机来回收对象
  • 优点：降低程序员实现难度、降低对象回收bug的可能性
  • 缺点：程序员无法控制内存回收的及时性
• 手动垃圾回收，由程序员编程实现对象的删除
  • 优点：回收及时性高，由程序员把控回收的时机
  • 缺点：编写不当容易出现悬空指针、重复释放、内存泄漏等问题

那么垃圾回收器需要负责对哪些部分的内存进行回收呢？

==线程不共享的部分，伴随着线程的创建而创建，线程的销毁而销毁==

方法的栈帧在执行完方法之后就会自动弹出栈并释放掉对应的内存

这一部分不需要垃圾回收器负责回收

方法区的回收

方法区中能回收的内容主要就是不再使用的类

一个类可以被卸载。需要同时满足三个条件:

• 此类所有实例对象都已经被回收，在堆中不存在任何该类的实例对象以及子类对象

  1 2 3 4 5

  // 将局部变量对堆上实例对象的引用去除 Class<?>clazz = loader.loadclass(name:"com.itheima.my.A"); object o = clazz.newInstance(); o = null;

• 加载该类的类加载器已经被回收

  1 2 3 4 5

  // 局部变量对类加载器的引用去除 URLClassLoader loader = new URLClassLoader( new URL[]{new URL(spec:"file:D:\\1ib\\")}); loader = null;

• 该类对应的 java.lang.Class 对象没有在任何地方被引用

  1 2	Class<?>clazz = loader.loadclass(name:"com.itheima.my.A"); clazz = null;

在虚拟机上添加参数

-XX:+TraceClassLoading -XX:+TraceClassUnloading

可以打印类加载和类卸载的过程

 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

package part1;

import java.net.URL;
import java.net.URLClassLoader;
import java.util.ArrayList;

/**
 * @author：CharmingDaiDai
 * @project：LearnJVM
 * @since：2024/7/3 下午1:10
 */
public class Java11 {
    public static void main(String[] args) throws InterruptedException {
        try {
            ArrayList<Class<?>> classes = new ArrayList<>();
            ArrayList<URLClassLoader> loaders = new ArrayList<>();
            ArrayList<Object> objs = new ArrayList<>();
            while (true) {
                URLClassLoader loader = new URLClassLoader(
                        new URL[]{new URL("file:D:\\lib\\")});
                Class<?> clazz = loader.loadClass("com.itheima.my.A");
                Object o = clazz.newInstance();

//                objs.add(o);
//                classes.add(clazz);
//                loaders.add(loader);
// 注释的部分，去掉任意一部分，类就不会被回收

                System.gc();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

System.gc()

语法： System.gc()

注意事项：

调用System.gc()方法并不一定会立即回收垃圾，仅仅是向Java虚拟机发送一个垃圾回收的请求，具体是否需要执行垃圾回收Java虚拟机会自行判断

类卸载主要用在什么场景下呢？

开发中此类场景一般很少出现，主要在如 OSGi、JSP 的热部署等应用场景中

每个jsp文件对应一个唯一的类加载器，当一个jsp文件修改了，就直接卸载这个jsp类加载器

重新创建类加载器，重新加载jsp文件

如何判断对象可以回收

==垃圾回收器要回收对象的第一步就是判断哪些对象可以回收==

Java中的对象是否能被回收，是根据对象是否被引用来决定的

如果对象被引用了，说明该对象还在使用，不允许被回收

比如下面代码的内存结构图：

第一行代码执行之后，堆上创建了Demo类的实例对象，同时栈上保存局部变量引用堆上的对象

第二行代码执行之后，局部变量对堆上的对象引用去掉，那么堆上的对象就可以被回收了

一个更复杂的案例：

这个案例中，如果要让对象a和b回收，必须将局部变量到堆上的引用去除

Q：那么问题来了，A和B互相之间的引用需要去除吗？

A：不需要，因为局部变量没引用这两个对象，在代码中已经无法访问这两个对象，即便他们之间互相有引用关系，也不影响对象的回收

判断对象是否可以回收，主要有两种方式：引用计数法和可达性分析法

引用计数法（无法解决循环引用）

引用计数法会为每个对象维护一个引用计数器，当对象被引用时加1，取消引用时减1

引用计数法的优点是实现简单，C++中的智能指针就采用了引用计数法，但是它也存在缺点，主要有两点：

• 每次引用和取消引用都需要维护计数器，对==系统性能==会有一定的影响
• 存在==循环引用==问题，所谓循环引用就是当A引用B，B同时引用A时会出现对象无法回收的问题

这张图上，由于A和B之间存在互相引用，所以计数器都为1，两个对象都不能被回收

但是由于没有局部变量对这两个代码产生引用，代码中已经无法访问到这两个对象，理应可以被回收

查看垃圾回收日志

使用 -verbose:gc参数

加上这个参数之后执行代码，发现对象确实被回收了：

通过不断的死循环创建对象，内存并没有上升，一直维持在1000K，说明每轮循环创建的两个对象在垃圾回收之后都被回收了

可达性分析法（看一个普通对象是否从GC Root可达）

==Java使用可达性分析算法==来判断对象是否可以被回收

可达性分析将对象分为两类：垃圾回收的==根对象==（GC Root）和==普通对象==，对象与对象之间存在引用关系

==GC ROOT对象一般不可被回收==

下图中A到B再到C和D，形成了一个引用链，可达性分析算法指的是如果从某个到GC Root对象是可达的，对象就不可被回收

哪些对象被称之为GC Root对象呢？

• 线程Thread对象，引用线程栈帧中的方法参数、局部变量等
• 系统类加载器加载的java.lang.Class对象，引用类中的静态变量

• 监视器对象，用来保存同步锁synchronized关键字持有的对象

• 本地方法调用时使用的全局对象

通过arthas和eclipse Memory Analyzer (MAT) 工具可以查看GC Root，MAT工具是eclipse推出的Java堆内存检测工具

具体操作步骤如下：

1、使用arthas的heapdump命令将堆内存快照保存到本地磁盘中

heapdump 输出路径+文件名+.hprof

2、使用MAT工具打开堆内存快照文件

3、选择GC Roots功能查看所有的GC Root

• 打开资料中提供的MAT工具，如果出现如下错误，将环境变量中的JDK版本升级到17以上

• 选择菜单中的打开堆内存快照功能，并选择文件

• 选择内存泄漏检测报告，并确定

• 通过菜单找到GC Roots

• MAT对4类GC Root对象做了分类

• 找到静态变量

• 找到局部变量

JProfiler分析器

软引用

可达性算法中描述的对象引用，一般指的是强引用，即是GCRoot对象对普通对象有引用关系，只要这层关系存在，普通对象就不会被回收

软引用相对于强引用是一种比较弱的引用关系，如果==一个对象只有软引用关联==到它，==当程序内存不足时，就会将软引用中的数据进行回收==

在JDK 1.2版之后提供了 SoftReference类来实现软引用，软引用常用于缓存中

如下图中，对象A被GC Root对象强引用了，同时创建了一个软引用SoftReference对象（它本身也是一个对象），软引用对象中引用了对象A

接下来强引用被去掉之后，对象A暂时还是处于不可回收状态，因为有软引用存在并且内存还够用

如果内存出现不够用的情况，对象A就处于可回收状态，可以被垃圾回收器回收

Q：这样做有什么好处？

如果对象A是一个缓存，平时会保存在内存中，如果想访问数据可以快速访问，但是如果内存不够用了，就可以将这部分缓存清理掉释放内存

即便缓存没了，也可以从数据库等地方获取数据，不会影响到业务正常运行，这样可以减少内存溢出产生的可能性

特别注意：

==软引用对象本身，也需要被强引用，否则软引用对象也会被回收掉==

软引用的使用方法

软引用的执行过程如下：

• 将对象使用软引用包装起来，new SoftReference<对象类型>(对象)
• 内存不足时，虚拟机尝试进行垃圾回收
• 如果垃圾回收仍不能解决内存不足的问题，回收软引用中的对象
• 如果依然内存不足，抛出OutOfMemory异常

基本使用案例

 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

package part1;

import java.io.IOException;
import java.lang.ref.SoftReference;

/**
 * @author：CharmingDaiDai
 * @project：LearnJVM
 * @since：2024/7/3 下午9:51
 */
public class test13 {
    public static void main(String[] args) throws IOException {

        byte[] bytes = new byte[1024 * 1024 * 100];
        SoftReference<byte[]> softReference = new SoftReference<byte[]>(bytes);
        bytes = null;
        System.out.println(softReference.get());

        byte[] bytes2 = new byte[1024 * 1024 * 100];
        System.out.println(softReference.get());
//
//        byte[] bytes3 = new byte[1024 * 1024 * 100];
//        softReference = null;
//        System.gc();
//
//        System.in.read();
    }
}

添加虚拟机参数，限制最大堆内存大小为200m：_Xmx200m

执行后发现，第二个100m对象创建之后，软引用中包含的对象已经被回收了

1
2
3
4
5

D:\JAVA\JDK1.8\bin\java.exe -Xmx200m "-javaagent:E:\MySoftware\IntelliJ IDEA 2024.1\lib\idea_rt.jar=10535:E:\MySoftware\IntelliJ IDEA 2024.1\bin" -Dfile.encoding=UTF-8 -classpath D:\JAVA\JDK1.8\jre\lib\charsets.jar;D:\JAVA\JDK1.8\jre\lib\ext\access-bridge-64.jar;D:\JAVA\JDK1.8\jre\lib\ext\cldrdata.jar;D:\JAVA\JDK1.8\jre\lib\ext\dnsns.jar;D:\JAVA\JDK1.8\jre\lib\ext\jaccess.jar;D:\JAVA\JDK1.8\jre\lib\ext\jfxrt.jar;D:\JAVA\JDK1.8\jre\lib\ext\localedata.jar;D:\JAVA\JDK1.8\jre\lib\ext\nashorn.jar;D:\JAVA\JDK1.8\jre\lib\ext\sunec.jar;D:\JAVA\JDK1.8\jre\lib\ext\sunjce_provider.jar;D:\JAVA\JDK1.8\jre\lib\ext\sunmscapi.jar;D:\JAVA\JDK1.8\jre\lib\ext\sunpkcs11.jar;D:\JAVA\JDK1.8\jre\lib\ext\zipfs.jar;D:\JAVA\JDK1.8\jre\lib\jce.jar;D:\JAVA\JDK1.8\jre\lib\jfr.jar;D:\JAVA\JDK1.8\jre\lib\jfxswt.jar;D:\JAVA\JDK1.8\jre\lib\jsse.jar;D:\JAVA\JDK1.8\jre\lib\management-agent.jar;D:\JAVA\JDK1.8\jre\lib\resources.jar;D:\JAVA\JDK1.8\jre\lib\rt.jar;D:\Language\JAVA\LearnJVM\target\classes part1.test13
[B@1b6d3586
null

进程已结束，退出代码为 0

软引用对象本身的回收

如果软引用对象里边包含的数据已经被回收了，那么软引用对象本身其实也可以被回收了

SoftReference提供了一套队列机制：

• 软引用创建时，通过构造器传入引用队列

• 在软引用中包含的对象被回收时，该软引用对象会被放入引用队列

• 通过代码遍历引用队列，将 SoftReference的强引用删除

 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

package part1;

import java.io.IOException;
import java.lang.ref.ReferenceQueue;
import java.lang.ref.SoftReference;
import java.util.ArrayList;

/**
 * @author：CharmingDaiDai
 * @project：LearnJVM
 * @since：2024/7/3 下午9:59
 */
public class test14 {
    public static void main(String[] args) throws IOException {

        ArrayList<SoftReference> softReferences = new ArrayList<>();
        ReferenceQueue<byte[]> queues = new ReferenceQueue<byte[]>();
        for (int i = 0; i < 10; i++) {
            byte[] bytes = new byte[1024 * 1024 * 100];
            SoftReference studentRef = new SoftReference<byte[]>(bytes,queues);
            softReferences.add(studentRef);
        }

        SoftReference<byte[]> ref = null;
        int count = 0;
        while ((ref = (SoftReference<byte[]>) queues.poll()) != null) {
            count++;
        }
        System.out.println(count);

    }public class test14 {
    public static void main(String[] args) throws IOException {

        // 创建一个ArrayList来存储SoftReference对象
        ArrayList<SoftReference> softReferences = new ArrayList<>();
      
        // 创建一个ReferenceQueue用于跟踪被垃圾回收的引用
        ReferenceQueue<byte[]> queues = new ReferenceQueue<byte[]>();
      
        // 创建10个100MB的byte数组，并用SoftReference包装它们，加入到softReferences列表中
        for (int i = 0; i < 10; i++) {
            byte[] bytes = new byte[1024 * 1024 * 100]; // 分配100MB的byte数组
            SoftReference<byte[]> studentRef = new SoftReference<byte[]>(bytes, queues);
            softReferences.add(studentRef);
        }

        // 计数被垃圾回收的引用数量
        SoftReference<byte[]> ref = null;
        int count = 0;
        while ((ref = (SoftReference<byte[]>) queues.poll()) != null) {
            count++;
        }
        System.out.println(count); // 打印被垃圾回收的引用数量
    }
}

代码解释：

1. 创建存储 SoftReference 对象的 ArrayList:

   1	ArrayList<SoftReference> softReferences = new ArrayList<>();

   这是一个 ArrayList，用来保存 SoftReference 对象。

2. 创建 ReferenceQueue 对象:

   1	ReferenceQueue<byte[]> queues = new ReferenceQueue<byte[]>();

   ReferenceQueue 是一个特殊的队列，用于存放被垃圾回收器回收的引用对象。

3. 创建和添加 SoftReference 对象:

   1 2 3 4 5

   for (int i = 0; i < 10; i++) { byte[] bytes = new byte[1024 * 1024 * 100]; // 分配100MB的数组 SoftReference<byte[]> studentRef = new SoftReference<byte[]>(bytes, queues); softReferences.add(studentRef); }

   这里创建了 10 个 100MB 的 byte 数组，并将每个数组包装在一个 SoftReference 对象中。然后，将这些 SoftReference 对象添加到 softReferences 列表中。

4. 检查 ReferenceQueue 中的被回收引用:

   1 2 3 4 5 6

   SoftReference<byte[]> ref = null; int count = 0; while ((ref = (SoftReference<byte[]>) queues.poll()) != null) { count++; } System.out.println(count);

   这个循环从 ReferenceQueue 中取出被回收的 SoftReference 对象，并计数。queues.poll() 方法返回队列中的下一个引用，如果队列为空，则返回 null。

SoftReference 和 ReferenceQueue 的作用：

• SoftReference
  • SoftReference 对象引用的内存只有在 JVM 内存不足时才会被回收。它们适用于实现内存敏感的缓存。
• ReferenceQueue
  • ReferenceQueue 用于跟踪被垃圾回收的引用对象。每当一个 SoftReference 所引用的对象被回收时，该 SoftReference 会被加入到与之关联的 ReferenceQueue 中。

这9个软引用对象中包含的数据已经被回收掉，所以可以手动从ArrayList中去掉，这样就可以释放这9个对象

1
2
3
4

D:\JAVA\JDK1.8\bin\java.exe -Xmx200m "-javaagent:E:\MySoftware\IntelliJ IDEA 2024.1\lib\idea_rt.jar=10757:E:\MySoftware\IntelliJ IDEA 2024.1\bin" -Dfile.encoding=UTF-8 -classpath D:\JAVA\JDK1.8\jre\lib\charsets.jar;D:\JAVA\JDK1.8\jre\lib\ext\access-bridge-64.jar;D:\JAVA\JDK1.8\jre\lib\ext\cldrdata.jar;D:\JAVA\JDK1.8\jre\lib\ext\dnsns.jar;D:\JAVA\JDK1.8\jre\lib\ext\jaccess.jar;D:\JAVA\JDK1.8\jre\lib\ext\jfxrt.jar;D:\JAVA\JDK1.8\jre\lib\ext\localedata.jar;D:\JAVA\JDK1.8\jre\lib\ext\nashorn.jar;D:\JAVA\JDK1.8\jre\lib\ext\sunec.jar;D:\JAVA\JDK1.8\jre\lib\ext\sunjce_provider.jar;D:\JAVA\JDK1.8\jre\lib\ext\sunmscapi.jar;D:\JAVA\JDK1.8\jre\lib\ext\sunpkcs11.jar;D:\JAVA\JDK1.8\jre\lib\ext\zipfs.jar;D:\JAVA\JDK1.8\jre\lib\jce.jar;D:\JAVA\JDK1.8\jre\lib\jfr.jar;D:\JAVA\JDK1.8\jre\lib\jfxswt.jar;D:\JAVA\JDK1.8\jre\lib\jsse.jar;D:\JAVA\JDK1.8\jre\lib\management-agent.jar;D:\JAVA\JDK1.8\jre\lib\resources.jar;D:\JAVA\JDK1.8\jre\lib\rt.jar;D:\Language\JAVA\LearnJVM\target\classes part1.test14
9

进程已结束，退出代码为 0