Java虚拟机快速入门 | JVM引言、JVM内存结构、直接内存

╰+哭是因爲堅強的太久メ 2024-03-26 14:29 92阅读 0赞

**目录**

一：JVM引言

1. 什么是 JVM ?

2. 常见的 JVM

3. 学习路线

二：JVM内存结构

1. 程 序 计 数 器（PC Register）

2. 虚 拟 机 栈（JVM Stacks）

3. 本 地 方 法 栈（Native Method Stacks）

4. 堆（Heap）

5. 方 法 区（Method Area）

三：直接内存

--------------------

**tips：**首先给大家推荐两款好用的免费软件：动图抓取软件：ScreenToGif和录屏工具：oCam，可用来作为日常的制作动图Gif和录屏，网盘链接：[夸克网盘分享][Link 1]

## 一：JVM引言 ##

#### 1. 什么是 JVM ? ####

> 定义：Java Virtual Machine - java 程序的运行环境（java 二进制字节码的运行环境）
> 
> **好处：**
> 
> ①一次编写，到处运行； 
> 
> ②自动内存管理，具有垃圾回收功能；
> 
> ③数组下标越界检查，抛出异常；
> 
> ④多态，面向对象的基石。

**比较：JVM、 JRE、 JDK**

> 从图中我们也可以看出是逐级向上的、包含的关系！

![5c5487295ab143ec97729a1a72723d1e.png][]

#### 2. 常见的 JVM ####

> 最常用的就是：HotSpot,Oracle JDK edition、Eclipse OPenJ9；接下来的讲解都是基于HotSpot！

![c60bbbac171c4e208a468ee80a388daa.png][]

#### 3. 学习路线 ####

> **主要分为三大块：**类加载器ClassLoader、JVM内存结构、执行引擎。
> 
> **学习顺序：**先学习JVM内存结构、然后学习GC垃圾回收机制、再学习JavaClass字节码、然后学习类加载器ClassLoader、最后学习执行引擎的其它内容。

![625f2082c9244e89a103b1b66900a402.png][]

## 二：JVM内存结构 ##

#### 1. 程 序 计 数 器（PC Register） ####

（1）定义

> ProgramCounterRegister 程序计数器 （ 寄 存 器 ）
> 
> **特 点：** 是线程私有的、 不会存在内存溢 出！

（2）作用

> **执行过程：**Java源代码---》经过编译生成二进制字节码(一些JVM指令)---》经过解释器---》解释成机器码---》最后交给CPU来执行！
> 
> **程序计数器的作用：**在程序执行的过程中记住下一条JVM指令的执行地址（前面的数字就可以理解为执行地址）。例如：拿到第一条getstatic指令交给解释器、解释器变成机器码、机器码交给CPU；于此同时会把下一条指令(astore\_1)的地址(3)，放入程序计数器，等到第一条指令执行结束，解释器就会程序计数器中取下一条指令(astore\_1)的地址(3)，依次重复！
> 
> **思考：如果没有程序计数器会有什么问题？**
> 
> 就会造成接下来不知道执行哪一条指令！实际上程序计数器在物理上是通过寄存器实现的！

![0eaf9840be9d42ef9feb4daa90f776b4.png][]

#### 2. 虚 拟 机 栈（JVM Stacks） ####

栈：是一种数据结构，先进后出或者说后进先出；一个线程一个栈！

（1）定义

> Java Virtual Machine Stacks （Java 虚拟机栈）
> 
> **①每个线程运行时所需要的内存，称为虚拟机栈；**
> 
> **②每个栈由多个栈帧（Frame）组成，对应着每次方法调用时所占用的内存；**
> 
> **③每个线程只能有一个活动栈帧，对应着当前正在执行的那个方法。**

**总结：**

> **栈**\---》对应着**线程运行**所需要的内存空间。
> 
> **栈帧**\---》对应着**每个方法运行**时所需要的内存空间。

我们可以通过下面一段代码理解栈和栈帧，通过Debug模式

![cd45e0c99c2d482fa95c429ce3c3b2b7.png][]

**问题分析：**

> **（1）垃圾回收是否涉及栈内存？**
> 
> **答：**不涉及，栈帧内存每次方法结束后，都会弹出栈，自动释放回收；我们知道垃圾回收机制只能回收堆内存的无用对象。
> 
> **（2）栈内存分配越大越好吗？**
> 
> **答：**不是，栈内存越大，会导致线程数变少，因为物理内存的大小是一定的。例如：一个线程分配1M，物理内存总共500M，理论上只能分配500个线程；若一个线程分配2M，理论上只能分配250个线程！
> 
> **注：**栈内存划分大了，只是能够进行更多次的方法调用，并不会使运行效率提高！
> 
> **注：**在运行时，**可以使用 -Xss size来指定分配的栈内存大小**；默认情况下：Linux、macOS分配的是1024KB，对于Windows是根据虚拟内存大小进行分配

![5bbb3a44c9264a0caa06a54d53c73703.png][]

> **（3）方法内的局部变量是否线程安全？**

例1：分析多个线程调用是否会使变量x的值混乱？

> 我们知道一个线程一个栈，对于不同的线程进行调用，都会产生新的栈帧，每个线程都有自己私有的变量x。

![fb484ff096cd4c628b5f7f026ff2454b.png][]

例2：分析多个线程调用方法，能否保证线程安全？

> ①m1方法，局部变量，没有逃离方法的作用范围，方法结束变量释放，线程安全的；
> 
> ②m2方法，方法中的变量（前提是引用数据类型），其它线程可以通过这个方法进行调用，非线程安全的；
> 
> ③m3方法，把这个局部变量（前提是引用数据类型）通过return返回，其它线程可以接收，然后执行其它操作；

![bf3e5f0b72e641fba3ed52ff660d1123.png][]

**总结：**

**①如果方法内局部变量没有逃离方法的作用范围，它是线程安全的；**

**②如果是局部变量是一个引用类型（基本数据类型肯定还是线程安全的），并逃离方法的作用范围，需要考虑线程安全；**

（2）栈内存溢出

情况一：栈帧过多导致栈内存溢出

> 栈的大小是固定的，假如我们不断的调用，使得栈帧不断的压栈，最终就会导致栈内存溢出；例如：递归调用，没有结束条件，最终抛出**StackOverflowError**异常！

情况二：栈帧过大导致栈内存溢出

> 栈帧过大，一下子就超过了栈的大小；很少见！

（3）线程运行诊断

**案例1： cpu 占用过多（有可能是死循环）**

> 定位 ：在Linux环境下，运行Java代码，**nohub java 类 &**
> 
> nohub：意思是不挂断 。使用Xshell 等Linux 客户端工具，远程执行 Linux 脚本时，有时候会由于网络问题，导致客户端失去连接，终端断开，脚本运行一半就意外结束了。这种时候,就可以用nohup 指令来运行指令，即使客户端与服务端断开，服务端的脚本仍可继续运行。
> 
> &：表示在后台进行运行。

![fc4a60a8e37140f5b25ec69178290375.png][]

> 先使用**top命令可以定位哪个进程**对cpu的占用过高

![a96b82d52efa42c18d321967c7b2d8d1.png][]

> **ps H -eo pid,tid,%cpu | grep 进程id** （**用ps命令进一步定位是哪个线程**引起的cpu占用过高）
> 
> H：显示树状结构，表示进程间的相互关系
> 
> \-eo：规定输出那些感兴趣的内容，例如：进程id(pid)、线程id(tid)、Cpu的占用情况(%cpu)
> 
> |：代表管道符，经常与grep筛选命令一起使用

![2dd9a9717c544fe0b78dda6b9d56a584.png][]

> **jstack 进程id：**可以根据线程id 找到有问题的线程，进一步定位到问题代码的源码行号！
> 
> **注意：**上面显示的32665线程号是十进制，而jstack显示的十六进制对应的就是7F99

![c75fd74132324dac8f0673b3dccd2bdd.png][]

**案例2：程序运行很长时间没有结果 （有可能是发生了线程的死锁）**

> 先执行Java程序，**nohub java 类 &，**就会显示进程id

![97582b89b1624c36ad3bbaf746d9fb27.png][]

> **jstack 进程id**：此时我们无法获知线程id，看末尾执行结果的提示

![4c0d19b3978a4e859c4aeca85bfe072f.png][]

何时发生线程死锁？

> 对于一个类，含有a、b属性，对于t1线程先锁a，在锁b；对于t2线程先锁b，在锁a；这种情况程序就会僵持在哪里，也没有抛出异常，这种情况下的排查错误是非常难的！

#### 3. 本 地 方 法 栈（Native Method Stacks） ####

> **定义：JVM调用本地方法时，需要给这些本地方法提供的内存空间！**
> 
> **解释本地方法(Native Method)：**指那些不是由Java代码编写的方法，例如：利用C、C++编写的本地方法来与操作系统打交道，Java代码可以通过这些本地方法来调用到这些底层的功能；只写本地方法使用的内存就是本地方法栈！

例如：Object类的克隆方法

![0d69964d1ceb4114b0fb5e413d52effe.png][]

#### 4. 堆（Heap） ####

前面学习的栈Stack是线程私有的、堆Heap是线程共享的！

> 堆(Heap)：通过 new 关键字，创建对象都会使用堆内存
> 
> **特点：**
> 
> ①它是线程共享的，堆中对象都需要考虑线程安全的问题 ；
> 
> ②有垃圾回收机制；

（1）堆 内 存 溢 出

首先先看下面这段代码：

> 首先创建一个ArrayList集合，写一个死循环，字符串不断进行拼接，然后放到List集合当中！

public class Demo1_5 {
    
        public static void main(String[] args) {
            int i = 0;
            try {
                List<String> list = new ArrayList<>();
                String a = "hello";
                while (true) {
                    list.add(a); // hello, hellohello, hellohellohellohello ...
                    a = a + a;  // hellohellohellohello
                    i++;
                }
            } catch (Throwable e) {
                e.printStackTrace();
                System.out.println(i);
            }
        }
    }

执行结果：内存溢出，抛出**OutOfMemoryError**异常

![8c808d7b68b04f36ab4c112a434fd6d7.png][]

**可以使用 -Xmx size来指定分配的堆空间大小**

![dab4ddaa23fa443e98e7626a1cc3ca4e.png][]

（2）堆 内 存 诊 断

> **①jps工具：**查看当前系统中有哪些java进程
> 
> **②jmap工具：**查看堆内存占用情况，查看的是某一个时刻； **jmap -heap 进程id** 
> 
> **③jconsole工具：**图形界面的，多功能的监测工具，可以连续监测

**案例1：**

> 首先先创建一个byte数组，会在堆内存中开辟10M的空间；然后把数组的引用arr置为null，开启垃圾回收机制进行回收；中间的sleep睡眠是为了方便执行指令进行监控。

public class Demo1_4 {
    
        public static void main(String[] args) throws InterruptedException {
            System.out.println("1...");
            Thread.sleep(30000);
            byte[] array = new byte[1024 * 1024 * 10]; // 10 Mb
            System.out.println("2...");
            Thread.sleep(20000);
            array = null;
            System.gc();
            System.out.println("3...");
            Thread.sleep(1000000L);
        }
    }

> 使用IDEA运行此程序，打开自带的dos窗口，输入命令

**①先输入jps命令，查看有哪些Java进程**

![133f42f624d7453c982765359a3f98e2.png][]

**②使用jmap进行检测**

第一步：在控制台打印输出1，也就是未创建10M内存空间时，使用jmap -heap 18756进行检测

![de6c9f35ed3b48428c1af5541026a4d9.png][]

第二步：在控制台上打印出2，使用jmap -heap 18756进行检测（此时创建10M的空间）

![1e68b234473f4711a7f72e8f34c5e404.png][]

第三步： 在控制台上打印出3，使用jmap -heap 18756再次进行检测（此时引用置为null），并启用了垃圾回收机制进行回收

![8dcb27c8b12841cfba52a149fa9b4762.png][]

**③使用jconsole进行检测（图形化界面进行显示）**

> 步骤：直接输入jconsole--->显示图形化界面，找到要检测的类---》选择不安全连接；就会动态显示每一个时刻的检测效果！

![7ae7882289b648b48eaab1475c534c38.png][]

**案例2：调用垃圾回收后，内存占用仍然很高**

> 这里先把这段代码给出来，假如我们不知道代码的具体实现，怎么去一步排查

import java.util.ArrayList;
    import java.util.List;
    
    public class ClazzMapperTest {
    
        public static void main(String[] args) throws InterruptedException {
            List<Student> students = new ArrayList<>();
            for (int i = 0; i < 200; i++) {
                students.add(new Student());
            }
            Thread.sleep(1000000000L);
        }
    }
    class Student {
        private byte[] big = new byte[1024*1024];
    }

第一步：使用jps查看进程的id

![bfaff2bb7a364979a0e32dd7afde9012.png][]

第二步：使用jmap -head 进程id查看内存使用情况；分为两部分：

Eden区：

![b999c408739e4728b2db556451392560.png][]

Old Generation区：

![9c3ae087528e47abb39c50a12d035fc4.png][]

第三步：使用jconsole工具，执行垃圾回收机制GC；发现相对于最初的状态确实回收了一部分内存，但是还有200多M没有被回收！

![159bc7996aeb48c9a03a16e79e06b715.png][]

第四步：实际上200多M，Eden区确实被回收了不少，但是Old Generation区却没有被回收；使用更加好用的检测工具**jvisualvm（JDK9以后就没有了，需要下载插件）**进行检测

**①找到堆 Dump表示抓取当前堆的快照**

![69049f6b1e0942a596c44f788d2a91c7.png][]

**② 查找前20个占用堆内存最大的对象**

![0e1154b928364707934206db8182b2df.png][]

**③可以找到占用堆内存最大的对象是一个ArrayList对象**

![e09a7b3d950d4b7abfb3d3cb4688323c.png][]

**④点击去ArrayList，查看它的属性都是Student对象** ；总共有244个项，其中Student项有200个，其它的都是Object对象（已经被释放掉了）；一个Student对象占用1M左右，200个就是占用200多兆，这样就能排查出来。

![09bcb680369c419bac6eccd03996af97.png][]

**⑤再结合源码分析**，在主方法main执行结束之前(调用了sleep方法睡眠)，ArrrayList集合中存储了大量的Student对象，无法释放；最终使得垃圾回收后，内存占用仍然很高！

#### 5. 方 法 区（Method Area） ####

（1）定义

> （1）方法区域类似于用于传统语言的编译代码的存储区域，或者类似于操作系统进程中的“文本”段。它**存储每个类的结构，例如运行时常量池、字段和方法数据，以及方法和构造函数的代码，包括类和实例初始化以及接口初始化中使用的特殊方法。**方法区域是在虚拟机启动时创建的、方法区域在逻辑上是堆的一部分、方法区域中的内存无法满足分配请求，Java虚拟机将抛出OutOfMemoryError。
> 
> （2）特点：
> 
> ①方法区是线程共享的，如果多个线程用到同一个类的时候，若这个类还未被加载，此时只能有一个线程去加载类，其他线程需要等待；
> 
> ②方法区的大小可以是非固定的，jvm可以根据应用需要动态调整，jvm也支持用户和程序指定方法区的初始大小；
> 
> ③方法区有垃圾回收机制，一些类不再被使用则变为垃圾，需要进行垃圾清理。

（2）组成

**JVM1.6版本内存结构：**

> 使用一个**PermGen永久代**作为方法区的实现，这个永久代包括以下信息：Class类的信息、ClassLoader类加载器信息、StringTable(字符串表)运行时常量池；

![b23708f67eeb42efa26c4c9fd7cdbbb0.png][]

**JVM1.8版本内存结构：**

> 使用一个**Metaspace元空间**作为方法区的实现，存储以下信息：Class类的信息、ClassLoader类加载器信息、常量池（和上面不同的地方）；已经不占用堆内存了，换句话说不是由JVM来管理它的内存结构了；移到本地内存（操作系统内存）

![e1d2161e859049fc95285675b9325994.png][]

（3）方法区内存溢出

①JDK1.8以前会导致永久代内存溢出

> 我们没有设置内存的上限，它会把10000个类全都加载到内存当中，可以使用参数进行设置，指定源空间内存的大小：**-XX:MaxPermSize=8m**

package cn.itcast.jvm.t1.metaspace;
    
    import jdk.internal.org.objectweb.asm.ClassWriter;
    import jdk.internal.org.objectweb.asm.Opcodes;
    
    // 把下面10000个类加载到内存当中
    public class Demo1_8 extends ClassLoader { // 可以用来加载类的二进制字节码
        public static void main(String[] args) {
            int j = 0;
            try {
                Demo1_8 test = new Demo1_8();
                for (int i = 0; i < 20000; i++, j++) {
                    // ClassWriter 作用是生成类的二进制字节码
                    ClassWriter cw = new ClassWriter(0);
                    // 版本号， public， 类名, 包名, 父类， 接口
                    cw.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, "Class" + i, null, "java/lang/Object", null);
                    // 返回 byte[]
                    byte[] code = cw.toByteArray();
                    // 执行了类的加载
                    test.defineClass("Class" + i, code, 0, code.length); // Class 对象
                }
            } finally {
                System.out.println(j);
            }
        }
    }

加上**-XX:MaxPermSize=8m** 只循环了19314次，就抛出了永久代溢出异常

![e54bb703d6fd41f293ed9089e3d7e4c0.png][]

②JDK1.8之后会导致元空间内存溢出

> 相同的代码，使用参数进行设置，指定源空间内存的大小：**-XX:MaxMetaspaceSize=8m**

加上**-XX:MaxMetaspaceSize=8m** 只循环了5411次，就抛出了元空间内存溢出

![5a3bfa769caa43f7a81bff6745e946df.png][]

（4）运行时常量池

①先理解常量池

> **对于二进制字节码**，**包括**：类基本信息，常量池，类方法定义，包含了虚拟机指令；先看以下代码，编译生成HelloWorld.class文件，使用：javap -v HelloWorld.class进行反编译

package cn.itcast.jvm.t5;
    public class HelloWorld {
        public static void main(String[] args) {
            System.out.println("hello world");
        }
    }

> 常量池，就是一张表，虚拟机指令根据这张常量表找到要执行的类名、方法名、参数类型、字面量等信息，例如：

![94ce19cc346c436ebbeb683b09b0d5e1.png][]

②运行时常量池

> 常量池是 \*.class 文件中的；当该类被加载，它的常量池信息就会放入运行时常量池，并把里面的符号地址变为真实地址 。

（5）StringTable

**StringTable特性：**

> ①常量池中的字符串仅是符号，第一次用到时才变为对象；
> 
> ② 利用串池的机制，来避免重复创建字符串对象；
> 
> ③ 字符串变量拼接的原理是 StringBuilder （1.8）；
> 
> ④ 字符串常量拼接的原理是编译期优化 ；
> 
> ⑤可以使用 intern方法，主动将串池中还没有的字符串对象放入串池；
> 
> **对于1.8 ：**将这个字符串对象尝试放入串池，如果有则并不会放入；如果没有则放入串池， 会把串池中的对象返回。
> 
> **对于1.6：**将这个字符串对象尝试放入串池，如果有则并不会放入；如果没有会把此对象复制一份， 放入串池， 会把串池中的对象返回。

**验证上面的特性：**

String s1 = "a";
    String s2 = "b";
    String s3 = "ab";

进行反编译：

> \#2就对应着String a，\#3就对应着String b，\#4就对应着String ab

![21807494c32a4199afae73b54f44debc.png][]

、

> astore\_1就把加载好的字符串对象存入1号局部变量s1，其它依次类推

![6dd91613825a4972b894401bda17c299.png][]

> 常量池是存在字节码文件.class里，当运行的时候会放到运行时常量池当中；但是加载到运行时常量池当中时，还没有成为java字符串对象，直到具体执行到引用它的那一行代码；例如：执行到String s1 = "a"，会把ldc \#2 会把a符号变为“a”字符串对象；此时还会准备一块空间StringTable，把“a”字符串对象放进去(如果里面没有的话)，这实际上是一个延迟加载（懒惰的）行为；如果串池中有的话，就会直接使用，总而言之，只会存在一份！
> 
> 所以：会把s1、s2、s3引用指向的“a”、“b”、“ab”放到字符串常量池StringTable当中，StringTable \[ "a", "b" ,"ab" \] 底层是hashtable结构，不能扩容。

String s1 = "a";
    String s2 = "b";
    String s3 = "ab";
    String s4 = s1 + s2;

> s4=s1+s2，变量拼接，s4引用首先会会创建一个StringBuilder对象，然后调用append方法，把“a”和“b”拼接进去，然后调用toString方法；我们通过查看StringBuilder的toString方法底层原码发现是创建一个新的字符串对象：new String("ab")。

![f530c3e27a6443999e3b68d8f5525deb.png][]

String s1 = "a";
    String s2 = "b";
    String s3 = "ab";
    String s4 = s1 + s2;
    // 问
    System.out.println(s3 == s4);

> s3 == s4的结果？
> 
> s3对应的"ab"是在字符串常量池中的对象，但s4是一个新创建的字符串对象，虽然值是相同的，但是s3是在串池当中的，s4是先创建出来的，== 对比的就是地址，肯定是不一样的，结果是false。

String s1 = "a";
    String s2 = "b";
    String s3 = "ab";
    String s4 = s1 + s2; // 变量拼接
    String s5 = "a" + "b"; // 常量拼接
    // 问
    System.out.println(s3 == s4); // false
    System.out.println(s3 == s5); // true

> s5 = "a" + "b" 直接找的就是已经拼接好的“ab”对象；这是javac在编译器的优化，在编译期间我们就能确定肯定就是“ab”对象，此时常量池中已经存在这个对象，所以 s3 == s5的结果就是true。
> 
> 注：s4=s1+s2是在运行期间才能确定，去动态拼接！

**JDK1.8：会将这个字符串对象尝试放入串池，如果有则并不会放入，如果没有则放入串池， 会把串池中的对象返回！**

String s = new String("a") + new String("b");
    // 使用JDK1.8，会将这个字符串对象尝试放入串池，
    // 如果有则不会放入，如果没有则放入串池，并把串池中的对象返回
    String s2 = s.intern();
    System.out.println(s2 == "ab"); // true
    System.out.println(s == "ab"); // true

> s = new String("a") + new String("b"); 首先会把“a”和“b”放到常量池当中，但是s="ab"不会放进去，因为是变量拼接，会创建一个字符串对象，是存放在堆当中，要想把"ab"放到常量池当中，可以调用intern方法，这样就可以把"ab"放入字符串常量池当中。此时就把s的对象放入常量池当中，并且s2是串池中对象的返回值；所以两个都为true。

String s = new String("a") + new String("b");
    
    String x = "ab";
    
    String s2 = s.intern();
    System.out.println(s2 == x); // true
    System.out.println(s == x); // false

> 此时String x = "ab'，会把“ab”放到串池当中；此时串池当中已经存在“ab”对象，此时s.intern()，就不会把“ab”对象放入串池当中；而s2 = s.intern返回的一定是一个串池当中的对象；所以此时s2 == x是true，s == x是false。

**JDK1.6：将这个字符串对象尝试放入串池，如果有则并不会放入，如果没有会把此对象复制一份， 放入串池， 会把串池中的对象返回！**

String s = new String("a") + new String("b");
    // 使用JDK1.6，会将这个字符串对象尝试放入串池，
    // 如果有则并不会放入，如果没有会把此对象复制一份，放入串池， 会把串池中的对象返回
    String s2 = s.intern();
    System.out.println(s2 == "ab"); // true
    System.out.println(s == "ab"); // false

> 使用JDK1.6最主要的区别就是s.intern，此时是拷贝一份放入串池当中，而不是把s本身的对象放入串池，s还是堆中的对象，此时s == "ab"就是false。

**经典面试题：**

String s1 = "a";
    String s2 = "b";
    String s3 = "a" + "b"; // ab
    String s4 = s1 + s2; // new String("ab")
    String s5 = "ab";
    String s6 = s4.intern();
    // 问
    System.out.println(s3 == s4); // false
    System.out.println(s3 == s5); // true
    System.out.println(s3 == s6); // true
    String x2 = new String("c") + new String("d"); // new String("cd")
    String x1 = "cd"; // "cd"
    x2.intern();
    System.out.println(x1 == x2); // false
    
    // 问，如果调换了x1，x2的位置呢？如果是jdk1.6呢？
    String x2 = new String("c") + new String("d"); // new String("cd")
    x2.intern(); //先把“ab”入常量池
    String x1 = "cd"; 
    System.out.println(x1 == x2); 
    // 此时对于JDK1.8-true，对于JDK1.6-false

（6）StringTable的位置

对于JDK1.6

![383a4a6eec344b22b706693b6b07b01d.png][]

对于JDK1.8

![c396b9a59ea041cc965ced73e625a22a.png][]

那么能通过代码直观上体现出StringTable的位置吗？

import java.util.ArrayList;
    import java.util.List;
    
    public class Demo1_6 {
    
        public static void main(String[] args) throws InterruptedException {
            List<String> list = new ArrayList<String>();
            int i = 0;
            try {
                for (int j = 0; j < 260000; j++) {
                    list.add(String.valueOf(j).intern());
                    i++;
                }
            } catch (Throwable e) {
                e.printStackTrace();
            } finally {
                System.out.println(i);
            }
        }
    }

对于JDK1.6把永久代的内存设置小一点：**-XX:MaxPermSize=10m**

![f1750422614243138b48b6871a65e0e0.png][]

对于JDK1.8把堆的内存设置小一点：**-Xmx10m，**此时并没有提示堆内存不足错误；下面的提示表示使用98%的精力去回收，但是值回收了2%，就会报这个错误提示。

![bcbc090da954425f8eefd087d460d298.png][]

此时需要在加上一个参数，关闭这个提示 **-Xmx10m -XX:-UseGCOverheadLimit**

![4383a2b387494cb1ad8d3429be673b47.png][]

（7）StringTable的垃圾回收机制

> StringTable也是受到垃圾回收机制的管理的，当内存空间不足时，StringTable中那些还没有被引用的字符串常量就会被垃圾回收器回收！

> 设置参数：**-Xmx10m -XX:+PrintStringTableStatistics -XX:+PrintGCDetails -verbose:gc**
> 
> \-Xmx10m：设置虚拟机堆内存的最大值；
> 
> \-XX:+PrintStringTableStatistics：打印字符串表的统计信息；
> 
> \-XX:+PrintGCDetails -verbose:gc：打印垃圾回收的一些信息（若发生了垃圾回收的话）；

package cn.itcast.jvm.t1.stringtable;
    
    import java.util.ArrayList;
    import java.util.List;
    
    public class Demo1_7 {
        public static void main(String[] args) throws InterruptedException {
            int i = 0;
            try {
                for (int j = 0; j < 100000; j++) { // j=100, j=10000
                    String.valueOf(j).intern(); // 入池
                    i++;
                }
            } catch (Throwable e) {
                e.printStackTrace();
            } finally {
                System.out.println(i);
            }
    
        }
    }

①先不添加循环代码，此时查看StringTable的存储情况

![4e3fa57f7aff4c80b93cceaf1c64f478.png][]

②若循环100次，此时还没有超过堆内存的大小，不会触发垃圾回收机制

![7439706fe7834f68a8d84f88f7c838e5.png][]

③若循环10000次，此时已经超过堆内存的大小，会触发垃圾回收机制进行回收

![014da3e2444c4ee39756d32a68d7f534.png][]

启动了垃圾回收机制的打印信息：

![fa2cac513d594948a983733b7429d82d.png][]

（8）StringTable性能调优

**方法1：调整 -XX:StringTableSize = 桶个数**

> StringTable的底层是一个哈希表（数组+链表），哈希表的性能是和它的大小密切相关的：如果哈希表桶的个数比较多，元素就会比较分散，哈希碰撞的几率就会减少，查找的速率也会变快。如果桶的个数较少，哈希碰撞的几率就会增高，导致链表比较长，查找的速度就会受到影响！

package cn.itcast.jvm.t1.stringtable;
    
    import java.io.BufferedReader;
    import java.io.FileInputStream;
    import java.io.IOException;
    import java.io.InputStreamReader;
    
    /**
     * 演示串池大小对性能的影响
     * -Xms500m -Xmx500m -XX:+PrintStringTableStatistics -XX:StringTableSize=1009
     */
    public class Demo1_24 {
    
        public static void main(String[] args) throws IOException {
            try (BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream("linux.words"), "utf-8"))) {
                String line = null;
                long start = System.nanoTime();
                while (true) {
                    line = reader.readLine();
                    if (line == null) {
                        break;
                    }
                    line.intern(); // 入串池
                }
                System.out.println("cost:" + (System.nanoTime() - start) / 1000000); // 毫秒
            }
    
    
        }
    }

**所谓的调优，最主要的就是调整桶的个数**： **-XX:StringTableSize = 桶 数**，不设置虚拟机的内存的最大值，对于四万多个数据可以轻松入池！

①**-XX:StringTableSize = 200000，**把桶的个数调整为200000

![4475f5c9915a44e8a3c40388f898b7bd.png][]

②不加**-XX:StringTableSize**这个参数，使用的默认桶大小60013

![d0fb1f57633d43fa9bdfeef197a800e2.png][]

**结论：桶的个数越小，耗费的时间最多；并且最小的桶个数是1009！**

**方法二：考虑将字符串对象是否入池**

> 假设现在有大量的字符串对象被创建，例如：linux.words文件中有4.8万个串，循坏10次，对比入池与不如池的内存使用情况。

import java.io.BufferedReader;
    import java.io.FileInputStream;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.util.ArrayList;
    import java.util.List;
    
    public class Demo1_25 {
    
        public static void main(String[] args) throws IOException {
    
            List<String> address = new ArrayList<>();
            System.in.read();
            for (int i = 0; i < 10; i++) {
                try (BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream("linux.words"), "utf-8"))) {
                    String line = null;
                    long start = System.nanoTime();
                    while (true) {
                        line = reader.readLine();
                        if(line == null) {
                            break;
                        }
                        // 不入池
                        address.add(line);
                        // 入池
                        address.add(line.intern());
                    }
                    System.out.println("cost:" +(System.nanoTime()-start)/1000000);
                }
            }
            System.in.read();
    
    
        }
    }

①address.add(line)不入池，此时相当于有48万个数据被添加到List集合当中。

使用jvisualvm工具，选择抽样器：

![5113b417831341feb73b3aab0a356408.png][]

对内存的占用进行图形化的展示：

![667fc26cdef3489888debeede393a26b.png][]

读取之前，此时字符串占用的内存大概是1M左右：

![0f15f14a02f74443aa480f542bde04b1.png][]

读取之后，此时字符串占用的内存大概是110M左右：

![fb67de43eb1643399fa59edea73a7b79.png][]

②address.add(line.intern())入池，入池以后，后面循环9次的数据都是重复的，都是直接使用只有第一次入池的数据即可，此时读取之后，String+创建的char数组也才40M不到，大大节省了堆内存空间！

![00e391b1078d4b619d106af76c51cb5d.png][]

## 三：直接内存 ##

（1）定义

> 直接内存不属于Java虚拟机里面的内存，是操作系统的内存！
> 
> 直接内存：DirectMemory
> 
> ①常见于NIO操作时 ， 用于数据缓冲区；
> 
> ②分配回收成本较高 ， 但读写性能高；
> 
> ③不受JVM内存回收管理；

案例：使用传统的IO流和直接内存进行比较

package cn.itcast.jvm.t1.direct;
    
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.nio.ByteBuffer;
    import java.nio.channels.FileChannel;
    
    /**
     * 演示 ByteBuffer 作用
     */
    public class Demo1_9 {
        static final String FROM = "E:\\编程资料\\text.txt";
        static final String TO = "E:\\a.txt";
        static final int _1Mb = 1024 * 1024;
    
        public static void main(String[] args) {
            io(); // io 用时：3秒左右
            directBuffer(); // directBuffer 用时：1秒左右
        }
        // 使用直接内存的方式
        private static void directBuffer() {
            long start = System.nanoTime();
            try (FileChannel from = new FileInputStream(FROM).getChannel();
                 FileChannel to = new FileOutputStream(TO).getChannel();
            ) {
                ByteBuffer bb = ByteBuffer.allocateDirect(_1Mb);
                while (true) {
                    int len = from.read(bb);
                    if (len == -1) {
                        break;
                    }
                    bb.flip();
                    to.write(bb);
                    bb.clear();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            long end = System.nanoTime();
            System.out.println("directBuffer 用时：" + (end - start) / 1000_000.0);
        }
        // 传统的IO流
        private static void io() {
            long start = System.nanoTime();
            try (FileInputStream from = new FileInputStream(FROM);
                 FileOutputStream to = new FileOutputStream(TO);
            ) {
                byte[] buf = new byte[_1Mb];
                while (true) {
                    int len = from.read(buf);
                    if (len == -1) {
                        break;
                    }
                    to.write(buf, 0, len);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            long end = System.nanoTime();
            System.out.println("io 用时：" + (end - start) / 1000_000.0);
        }
    }

我们会发现，使用直接内存ByteBuffer比传统的IO流拷贝文件（特别是大文件）的速度明显快很多，就从文件的读写过程进行分析！

**对于传统的IO流：**

> Java本身并不具备读写磁盘的能力，必须调用操作系统提供的函数；就是从Java的方法调用到本地的方法；此时CPU会从用户态切换到内核态；此时就可以读取磁盘文件的内容，此时会在操作系统中划出来一层缓冲区（系统缓冲区），磁盘的内容就会先读取到这个系统缓冲区（分次读取，并且Java的代码是不能读取系统缓冲区的内容的），此时Java也会在堆内存中分配一块Java的缓冲区；Java要想读取到数据，必须先从系统缓存数据读入到Java缓冲区；两块缓冲区，相当于读取的时候必须存两份（造成不必要的数据复制），效率较低！

![0a7609e751c940d785cba123f6f9a77a.png][]

**对于直接内存：**

> 当ByteBuffer调用allocateDirect方法时，会在操作系统间划出一块缓冲区（direct memory），这块区域Java代码是可以直接访问的；这块内存无论是操作系统还是Java代码都是可以直接访问的，共享的一块内存区域；只有一次缓冲区的读入，效率较高！

![0f06556f28d54917ba1eceadfdb5d2b0.png][]

不受JVM内存回收管理，所以直接内存也会导致内存溢出，例：

import java.nio.ByteBuffer;
    import java.util.ArrayList;
    import java.util.List;
    
    
    // 演示直接内存溢出
    public class Demo1_10 {
        static int _100Mb = 1024 * 1024 * 100;
    
        public static void main(String[] args) {
            List<ByteBuffer> list = new ArrayList<>();
            int i = 0;
            try {
                while (true) {
                    ByteBuffer byteBuffer = ByteBuffer.allocateDirect(_100Mb);
                    list.add(byteBuffer);
                    i++;
                }
            } finally {
                System.out.println(i);
            }
            // 方法区是jvm规范， jdk6 中对方法区的实现称为永久代
            //                  jdk8 对方法区的实现称为元空间
        }
    }

直接内存使用操作不当，也会导致内存溢出：

![b18b63411c964082b4cdeb37f749d8d7.png][]

（2）分配和回收原理

例：

public class Test {
        static int _1Gb = 1024 * 1024 * 1024;
    
        public static void main(String[] args) throws IOException {
            ByteBuffer byteBuffer = ByteBuffer.allocateDirect(_1Gb); // 分配1G的空间
            System.out.println("分配完毕...");
            System.in.read();
            System.out.println("开始释放...");
            byteBuffer = null; // 空引用
            System.gc(); // 启动垃圾回收
            System.in.read();
        }
    }

查看任务管理器，分配1G：

![94f6dcd2dd624b5cb187bc4802faf18e.png][]

查看任务管理器，置为null，启动垃圾回收机制，发现竟然被回收了！前面不是说直接内存不受JVM内存回收管理吗？为什么垃圾回收之后，直接内存就被回收释放了？

![c6c4f9b53533466397b3ea71c9b58714.png][]

> 这就需要解释一下直接内存的释放原理：首先通过某种方式获取unsafe对象，通过unsafe对象就可以完成直接内存的分配和回收！
> 
> 注：对于直接内存的监控，就不能使用IDEA中的那些监控工具，需要看任务管理器中的进程

分配内存：

long base = unsafe.allocateMemory(_1Gb);
    unsafe.setMemory(base, _1Gb, (byte) 0);

释放内存：

unsafe.freeMemory(base);

ByteBuffer.allocateDirect方法底层是使用了ByteBuﬀer的实现类DirectByteBuffer

![6128706a9eee4fd592eb62781beaebf2.png][]

DirectByteBuffer的构造器中就调用了unsafe的allocateMemory方法对直接内存进行分配

![608aae39192e4b0da17e2fbb17e60cf3.png][]

DirectByteBuffer的构造器中内部还使用了 Cleaner （虚引用）来监测 ByteBuﬀer 对象，一旦 ByteBuﬀer对象被垃圾回收，那么就会由 ReferenceHandler 线程通过Cleaner的clean方法去执行任务对象Deallocator，任务对象在调用unsafe对象的freeMemory 来释放直接内存

![4cd3f6bed60d4f86a61c718179f2cb86.png][]

**-XX:+DisableExplicitGC：**禁用显式回收对直接内存的影响，就是让System.gc()无效，但是此时就会影响直接内存的释放，我们就可以使用unsafe对象手动释放直接内存！

##  ##

[Link 1]: https://pan.quark.cn/s/15e9a38bda9a
[5c5487295ab143ec97729a1a72723d1e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/c22be5da98804614a2b7196da03df032.png
[c60bbbac171c4e208a468ee80a388daa.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/4cff4e32bb214f71b52cccdee23fbb5a.png
[625f2082c9244e89a103b1b66900a402.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/3532e38ea6fe45598ea397c8e6bae8d0.png
[0eaf9840be9d42ef9feb4daa90f776b4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/0dd7134e520b4890b900f88a11db7b5b.png
[cd45e0c99c2d482fa95c429ce3c3b2b7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/5c607d4492414e2ca52a362aa259875f.png
[5bbb3a44c9264a0caa06a54d53c73703.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/da7d4b3ecc6943f5bcebe16ef296a8f7.png
[fb484ff096cd4c628b5f7f026ff2454b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/e1f6793ff5db417b873480eb16c6f0cd.png
[bf3e5f0b72e641fba3ed52ff660d1123.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/6bbf214e12d24178a0d0cef733e126e6.png
[fc4a60a8e37140f5b25ec69178290375.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/66ab844f25604ac08c7bf642b0f08d82.png
[a96b82d52efa42c18d321967c7b2d8d1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/027fc90e96504bf3b24b8697d568aefc.png
[2dd9a9717c544fe0b78dda6b9d56a584.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/98bc9ce1c9b7445690d7f64380254c9a.png
[c75fd74132324dac8f0673b3dccd2bdd.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/00f3cc95ab044dd3b87226f949e44b1e.png
[97582b89b1624c36ad3bbaf746d9fb27.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/b0243cd88ada4f1eae3ad662eb153c54.png
[4c0d19b3978a4e859c4aeca85bfe072f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/b5536e600045490289b4467c08cef718.png
[0d69964d1ceb4114b0fb5e413d52effe.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/31dbd7db96ba40ffbc585bcd8e8f1683.png
[8c808d7b68b04f36ab4c112a434fd6d7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/bd299a8b0d6c4e519a2b5197e2e9718d.png
[dab4ddaa23fa443e98e7626a1cc3ca4e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/401473115d434adfb3575eb0e2a7a5b0.png
[133f42f624d7453c982765359a3f98e2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/0be0b99e7cb241dbbda2e2c2a9f56221.png
[de6c9f35ed3b48428c1af5541026a4d9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/e132e1e614614807a127e6d15bd4d2fa.png
[1e68b234473f4711a7f72e8f34c5e404.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/d8804030bfc34c6cab69c25aae02badf.png
[8dcb27c8b12841cfba52a149fa9b4762.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/e0b8937781564ad5a9ce5c162e2af7a4.png
[7ae7882289b648b48eaab1475c534c38.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/70ab2ddf0734460b8f97ab8d40d790f7.png
[bfaff2bb7a364979a0e32dd7afde9012.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/2dd6ba48cc5840e1a6e2168d2bc303cf.png
[b999c408739e4728b2db556451392560.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/e4e750f338394c3cbc230b3288499006.png
[9c3ae087528e47abb39c50a12d035fc4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/9dbbfb81f41b472bb4a729cc4715cce5.png
[159bc7996aeb48c9a03a16e79e06b715.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/e81d1c0181e34e79a421e7a8ae6a1b89.png
[69049f6b1e0942a596c44f788d2a91c7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/824726894f8a40f286e46f249026dcf0.png
[0e1154b928364707934206db8182b2df.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/d082387e0d2f425a80be9e893f30137e.png
[e09a7b3d950d4b7abfb3d3cb4688323c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/dade684058a14d818c6a531ea10b758a.png
[09bcb680369c419bac6eccd03996af97.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/855bd13b2c7441d78e1d493ac544341e.png
[b23708f67eeb42efa26c4c9fd7cdbbb0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/ab31edfb27db4668a9218bef3feb7b5c.png
[e1d2161e859049fc95285675b9325994.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/b18f7ab94e67454da85f4beca28a6d9a.png
[e54bb703d6fd41f293ed9089e3d7e4c0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/ec8472f55d0e494e922caeec192beedd.png
[5a3bfa769caa43f7a81bff6745e946df.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/df34a04a6d6542d6a0fcdb76c23dfdcc.png
[94ce19cc346c436ebbeb683b09b0d5e1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/2a3bc48dc5ef48a19a4300565d4d25cf.png
[21807494c32a4199afae73b54f44debc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/91e14d1a627f40a3af7d7d7f4bf33b8e.png
[6dd91613825a4972b894401bda17c299.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/5715a0765e3f4e758c1768b00a407c04.png
[f530c3e27a6443999e3b68d8f5525deb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/2003da836e3f453aaaa3c177ff022543.png
[383a4a6eec344b22b706693b6b07b01d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/36b76350cadf4f0798ba40c974989e28.png
[c396b9a59ea041cc965ced73e625a22a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/4d66b34ebdb348e784481d872dec68f3.png
[f1750422614243138b48b6871a65e0e0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/0eac203ceb6744a889c7a18a5db02002.png
[bcbc090da954425f8eefd087d460d298.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/a14c23bae0e64bba8dda034ddc556830.png
[4383a2b387494cb1ad8d3429be673b47.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/2c4a694c011c4ab6a06f977719b83d09.png
[4e3fa57f7aff4c80b93cceaf1c64f478.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/06a4e0d388c244ab8c22f8a5f45d5065.png
[7439706fe7834f68a8d84f88f7c838e5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/bea4fd712f724ca8977ec9a7d334b207.png
[014da3e2444c4ee39756d32a68d7f534.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/4dcdb5c066974cff831654570e5cba0b.png
[fa2cac513d594948a983733b7429d82d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/85527ac9f6e84a6d8875b49853f16221.png
[4475f5c9915a44e8a3c40388f898b7bd.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/719b8ed29a114ae1b07c144d0116f7e4.png
[d0fb1f57633d43fa9bdfeef197a800e2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/daf739321f004d54b1d37954bdc620f3.png
[5113b417831341feb73b3aab0a356408.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/2efbf7babab54ce4a8c06d1c5a7292d5.png
[667fc26cdef3489888debeede393a26b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/151eec05d5eb432a921e5edd012e4562.png
[0f15f14a02f74443aa480f542bde04b1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/e2a54c13601a4da1bcd47baa4fcf4a57.png
[fb67de43eb1643399fa59edea73a7b79.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/2576443e5bb04a15a76832e18fea4cd8.png
[00e391b1078d4b619d106af76c51cb5d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/c239216eec3d47f29342263cbb19fb58.png
[0a7609e751c940d785cba123f6f9a77a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/f3ac9be4d2b942d0a7b41603cc4f6748.png
[0f06556f28d54917ba1eceadfdb5d2b0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/9d216f1b85a8435aaf555bfb77ee2599.png
[b18b63411c964082b4cdeb37f749d8d7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/771c061bd0484134aad44be0031401bd.png
[94f6dcd2dd624b5cb187bc4802faf18e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/f46e12d915bc4654bd24f45b45112b67.png
[c6c4f9b53533466397b3ea71c9b58714.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/ecc8dbed828c472cba63abbb3df7140b.png
[6128706a9eee4fd592eb62781beaebf2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/71ba755d7bc747d88062ee6625ae994b.png
[608aae39192e4b0da17e2fbb17e60cf3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/277890137d0a4d8aaa57266ae20317a3.png
[4cd3f6bed60d4f86a61c718179f2cb86.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/b49e0cb663354f1fbf284637662c3d58.png