Bootstrap

【JVM】内存结构

一、程序计数器

在这里插入图片描述

1.1 定义

Program Counter Register 程序计数器（寄存器）：物理上是通过寄存器实现的。寄存器是CPU组件中读取数据最快的一个单元，又因为读取指令地址这个动作是非常频繁的，所以JVM把寄存器当作程序计数器

  • 作用：是记住下一条jvm指令的执行地址
  • 特点
    • 是线程私有的
    • 不会存在内存溢出

1.2 作用

在这里插入图片描述

二、虚拟机栈 -Xss

在这里插入图片描述

2.1 定义

Java Virtual Machine Stacks （Java 虚拟机栈）

  • 虚拟机栈 ：每个线程运行时所需要的内存空间

    • 每个栈由多个栈帧（Frame）组成，对应着每次方法调用时所占用的内存

  • 栈帧：每个方法运行时需要的内存

    • 每个线程只能有一个活动栈帧，对应着当前正在执行的那个方法

    在这里插入图片描述

    在这里插入图片描述

2.2 问题辨析

  1. 垃圾回收是否涉及栈内存？

    不需要。因为栈帧内存在每次方法结束后会被弹出栈，即被自动回收掉

  2. 栈内存分配越大越好吗？

    不是。栈内存越大，只能运行更多次的递归方法调用，而不会提高运行效率。反而导致允许的线程数越少，因为物理内存是固定的。

  3. 方法内的局部变量是否线程安全？

    • 不一定

    • 情况一：如果方法内局部变量没有逃离方法的作用访问，它是线程安全的

    • 情况二：如果局部变量引用了对象（方法参数）、或逃离方法的作用范围（作为返回值），需要考虑线程安全

2.3 栈内存溢出案例

  • 栈帧过多导致栈内存溢出：

    • 递归调用没有正确的结束条件

      public class StackOverFlow {
    private static int count=0;
    public static void main(String[] args) {
        try {
            test();
        } catch (Throwable e) {
            e.printStackTrace(); //java.lang.StackOverflowError
            System.out.println(count); //23010  ——> -Xss256k ——> 3639
        }
    }
    public static void test(){
        count++;
        test();
    }
}

    • 递归Josn转换循环依赖：@JsonIgnore

  • 栈帧过大导致栈内存溢出

2.4 线程运行诊断案例

  • 案例1： cpu 占用过高

    1. 定位进程：top

    2. 定位线程：ps H -eo pid,tid,%cpu | grep 进程id

    3. 定位线程代码：jstack 进程id

      根据线程id （换算为16进制）找到有问题的线程，进一步定位到问题代码的源码行号

  • 案例2：产生死锁，程序运行很长时间没有结果。nohup java cn.itcast.jvm.t1.Demo1_3 &

    1. 查看问题：jstack 进程id
    2. 找到问题：结尾的死锁信息
    3. 定位代码

三、本地方法栈

  • 本地方法栈：为本地方法调用提供的内存空间
  • 本地方法：不是由java代码编写的方法。
    • 由C或C++编写，与操作系统更底层的API打交道
    • java代码通过本地方法间接调用底层功能。

在这里插入图片描述

四、堆 -Xmx

在这里插入图片描述

4.1 定义

Heap 堆

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

4.2 堆内存溢出案例

  1. 不断产生对象，且这些新对象仍然有对象在使用
  2. 且使用的对象未被回收
public class OutOfMemoryTest {
    public static void main(String[] args) {
        try {
            List<String> list =new ArrayList<>();
            String str="hello";
            int count=0;
            while (true){
                str+=str;   //java.lang.OutOfMemoryError: Java heap space
                list.add(str);
                count++;
            }
        } catch (Throwable e) {
            e.printStackTrace();
        }
    }
}

4.3 堆内存诊断案例

  • jps 工具：查看当前系统中有哪些 java 进程
  • jmap 工具：查看进程某一时刻的堆内存占用情况
  • jconsole 工具：图形化的多功能的实时监测工具（堆内存、线程、CPU）
  • jvisualvm 工具：与 jconsole 相似。特点是可以转储堆信息

案例1：创建对象前—>创建对象后—>回收对象后

public class JconsoleTest {
    public static void main(String[] args) throws InterruptedException {
        System.out.println("创建对象前");
        Thread.sleep(20000);
        byte[] array=new byte[1024*1024*10];
        System.out.println("创建对象后");
        Thread.sleep(10000);
        array=null;
        System.gc();
        System.out.println("垃圾回收后");
        Thread.sleep(30000);
    }
}

#创建对象前：可用 27.9m
PS F:\software\IDEA\JavaProjects\JvmTest> jps
12832 RemoteMavenServer36
13264 Launcher
19044 Jps
15960
13564 JconsoleTest
PS F:\software\IDEA\JavaProjects\JvmTest> jmap -heap 13564
...
Eden Space:
   capacity = 34078720 (32.5MB)
   used     = 4771328 (4.55029296875MB)
   free     = 29307392 (27.94970703125MB)
   14.000901442307692% used
#创建对象后：可用 17.9m
PS F:\software\IDEA\JavaProjects\JvmTest> jmap -heap 13564
...
Eden Space:
   capacity = 34078720 (32.5MB)
   used     = 15257104 (14.550308227539062MB)
   free     = 18821616 (17.949691772460938MB)
   44.77017916165865% used
#垃圾回收后：可用 31.8m
PS F:\software\IDEA\JavaProjects\JvmTest> jmap -heap 13564
...
Eden Space:
   capacity = 34078720 (32.5MB)
   used     = 681592 (0.6500167846679688MB)
   free     = 33397128 (31.84998321533203MB)
   2.0000516451322117% used

PS F:\software\IDEA\JavaProjects\JvmTest> jconsole

在这里插入图片描述

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

public class JvitualvmTest {
    public static void main(String[] args) throws InterruptedException {
        List<Studnet> list=new ArrayList();
        for (int i = 0; i < 200; i++) {
            list.add(new Studnet());
        }
        Thread.sleep(1000000000000L);
    }
}
class Studnet{
    private byte[] big=new byte[1024*1024];
}

PS F:\software\IDEA\JavaProjects\JvmTest> jconsole

在这里插入图片描述

PS F:\software\IDEA\JavaProjects\JvmTest> jvisualvm

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

五、方法区 -XX:Max…

在这里插入图片描述

5.1 定义

在这里插入图片描述

  1. 线程共享
  2. 存储类的结构：运行时常量池、字段、方法数据、方法和构造函数的代码（包括在类、实例初始化、接口初始化中使用的特殊方法）
  3. 在虚拟机启动时创建
  4. 在逻辑上是堆的一部分，但是没有强制方法区的位置。不同虚拟机厂商的实现不同。
    • Hostpot在 jdk8 前：实现为永久代，这时的永久代便是作为堆内存的一部分
    • Hostpot在 jdk8 时：实现为元空间，这时的元空间使用的是操作系统的内存
  5. 方法区申请内存不足时会报错

5.2 组成

方法区的位置

  • jdk6、jdk7：堆内存（永久代）
  • jdk8：操作系统内存（元空间）

字符串常量池的位置：

  • jdk 6：方法区（永久代）
  • jdk 7、jdk8： 堆

在这里插入图片描述

在这里插入图片描述

5.3 方法区内存溢出案例

场景

  • spring：代理技术广泛应用 CGlib(ClassWriter) 动态生成类的字节码
  • mybatis：应用 CGlib(ClassWriter) 动态生成Map接口实现类

1.8 以前：导致永久代内存溢出

  • 永久代内存溢出：Exception in thread “main” java.lang.OutOfMemoryError: PermGen space
  • 永久代内存大小设置：-XX:MaxPermSize=4m
public class OutOfMemoryTest extends ClassLoader{
    public static void main(String[] args) {
        int j=0;
        try {
            OutOfMemoryTest classLoader=new OutOfMemoryTest();
            for (int i = 0; i < 100000; i++,j++) {
                //作用：生成类且获得类的二进制字节码
                ClassWriter cw=new ClassWriter(0);
                //版本号，public，类名，包名，父类，接口
                cw.visit(Opcodes.V1_6,Opcodes.ACC_PUBLIC,"Class"+i,null,"java/lang/Object",null);
                //获得类的字节数组
                byte[] code=cw.toByteArray();
                //将该类加载到方法区
                classLoader.defineClass("Class"+i,code,0,code.length);
            }
        } finally{
            System.out.println(j);
        }
    }
}

19317
Exception in thread "main" java.lang.OutOfMemoryError: PermGen space
	at java.lang.ClassLoader.defineClass1(Native Method)
	at java.lang.ClassLoader.defineClassCond(ClassLoader.java:631)
	at java.lang.ClassLoader.defineClass(ClassLoader.java:615)
	at java.lang.ClassLoader.defineClass(ClassLoader.java:465)
	at org.example.java.methodArea.OutOfMemoryTest.main(OutOfMemoryTest.java from InputFileObject:24)

1.8 之后：导致元空间内存溢出

  • 元空间内存溢出：Error occurred during initialization of VM MaxMetaspaceSize is too small.
  • 元空间内存大小设置：-XX:MaxMetaspaceSize=8m
public class OutOfMemoryTest extends ClassLoader{
    public static void main(String[] args) {
        int j=0;
        try {
            OutOfMemoryTest classLoader=new OutOfMemoryTest();
            for (int i = 0; i < 100000; i++,j++) {
                //作用：生成类且获得类的二进制字节码
                ClassWriter cw=new ClassWriter(0);
                //版本号，public，类名，包名，父类，接口
                cw.visit(Opcodes.V1_8,Opcodes.ACC_PUBLIC,"Class"+i,null,"java/lang/Object",null);
                //获得类的字节数组
                byte[] code=cw.toByteArray();
                //将该类加载到方法区
                classLoader.defineClass("Class"+i,code,0,code.length);
            }
        } catch (Throwable t){
            t.printStackTrace();
        } finally{
            System.out.println(j);
        }
    }
}

Error occurred during initialization of VM
MaxMetaspaceSize is too small.

5.4 运行时常量池

  • 常量池：
    • 就是一张表
    • 虚拟机指令根据这张常量表找到要执行的类名、方法名、参数类型、字面量 等信息
  • 运行时常量池：
    • 常量池是 *.class 文件中的，当该类被加载，它的常量池信息就会放入运行时常量 池，并把里面的符号地址变为真实地址

反编译字节码文件

/**
 * 二进制字节码：类基本信息、常量池、类方法定义、虚拟机指令
 */
public class HelloWord {
    public static void main(String[] args) {
        System.out.println("Hello word!");
    }
}

PS F:\software\IDEA\JavaProjects\JvmTest\target\classes\org\example\java\methodArea\changleiPool> javap -v HelloWord
警告: 二进制文件HelloWord包含org.example.java.methodArea.changleiPool.HelloWord
    
//----------------------类基本信息
Classfile /F:/software/IDEA/JavaProjects/JvmTest/target/classes/org/example/java/methodArea/changleiPool/HelloWord.cla
ss
  Last modified 2022-11-7; size 612 bytes
  MD5 checksum 8ac0f4a48d54619bddaec8c500042064
  Compiled from "HelloWord.java"
public class org.example.java.methodArea.changleiPool.HelloWord
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
//----------------------常量池
Constant pool:
   #1 = Methodref          #6.#20         // java/lang/Object."<init>":()V
   #2 = Fieldref           #21.#22        // java/lang/System.out:Ljava/io/PrintStream;
   #3 = String             #23            // Hello word!
   #4 = Methodref          #24.#25        // java/io/PrintStream.println:(Ljava/lang/String;)V
   #5 = Class              #26            // org/example/java/methodArea/changleiPool/HelloWord
   #6 = Class              #27            // java/lang/Object
   #7 = Utf8               <init>
   #8 = Utf8               ()V
   #9 = Utf8               Code
  #10 = Utf8               LineNumberTable
  #11 = Utf8               LocalVariableTable
  #12 = Utf8               this
  #13 = Utf8               Lorg/example/java/methodArea/changleiPool/HelloWord;
  #14 = Utf8               main
  #15 = Utf8               ([Ljava/lang/String;)V
  #16 = Utf8               args
  #17 = Utf8               [Ljava/lang/String;
  #18 = Utf8               SourceFile
  #19 = Utf8               HelloWord.java
  #20 = NameAndType        #7:#8          // "<init>":()V
  #21 = Class              #28            // java/lang/System
  #22 = NameAndType        #29:#30        // out:Ljava/io/PrintStream;
  #23 = Utf8               Hello word!
  #24 = Class              #31            // java/io/PrintStream
  #25 = NameAndType        #32:#33        // println:(Ljava/lang/String;)V
  #26 = Utf8               org/example/java/methodArea/changleiPool/HelloWord
  #27 = Utf8               java/lang/Object
  #28 = Utf8               java/lang/System
  #29 = Utf8               out
  #30 = Utf8               Ljava/io/PrintStream;
  #31 = Utf8               java/io/PrintStream
  #32 = Utf8               println
  #33 = Utf8               (Ljava/lang/String;)V
//----------------------类方法定义
{
  public org.example.java.methodArea.changleiPool.HelloWord();//构造方法
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=1, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: return
      LineNumberTable:
        line 3: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       5     0  this   Lorg/example/java/methodArea/changleiPool/HelloWord;

  public static void main(java.lang.String[]);//main方法
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=1, args_size=1
         0: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
         3: ldc           #3                  // String Hello word!
         5: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
         8: return
      LineNumberTable:
        line 5: 0
        line 6: 8
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       9     0  args   [Ljava/lang/String;
}
SourceFile: "HelloWord.java"

六、字符串常量池

6.1 特性

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

6.2 特性面试题

1）字符串拼接

public class InterviewQuestions {
    public static void main(String[] args) {
        //1.常量池中的信息，都会被加载到运行时常量池中
        //2.这时的a b ab 都是运行时常量池中的符号，还没有变为 java 字符串对象

        String s1="a";
        String s2="b";
        String s3="ab";
        //3.在运行时常量池表中查询出 a符号、b符号、ab符号，然后在字符串常量池中查找对象，找不到再创建对象：StringTable[]{"a","b","ab"}
        String s4=s1+s2;
        //4.在局部变量表中加载到 "a"和"b" ，再创建对象：new String("ab")
        String s5="a"+"b";
        //5.在编译期间优化，结果已经在编译期确定为 ab符号，然后在字符串常量池中查找对象，找不到再创建对象：StringTable[]{"a","b","ab"}
        System.out.println("s3==s4:"+(s3==s4));//false
        System.out.println("s3==s5:"+(s3==s5));//true
        System.out.println("s4==s5:"+(s4==s5));//false
    }
}

在这里插入图片描述

2）intern()

将堆内存中的字符串对象添加到字符串常量池中

  • 字符串常量池中已存在
String s3 = "ab";
String s4 = new String("ab");
String s6 = s4.intern();

System.out.println(s3 == s6);//true：返回字符串常量池中的对象（即s3的引用）
  • 字符串常量池中不存在
String x2 = new String("c") + new String("d");
x2.intern();
String x1 = "cd";

System.out.println(x1 == x2);//jdk1.8：true。将堆内存中的对象添加到字符串常量池并返回
System.out.println(x1 == x2);//jdk1.6：false。重新创建对象添加到字符串常量池并返回新对象

6.3 位置求证案例

jdk1.6：放在方法区（永久代）

  • 放在方法区时只有当 fullGC 时才会触发垃圾回收
  • 导致 StringTable 回收效率不高。但是 StringTable 使用频繁，如果回收效率不高将占用大量内存，很容易导致永久代内存不足

在这里插入图片描述

在这里插入图片描述

jdk1.8

  • 只需要 Minor GC 就会触发 StringTable 的垃圾回收，大大减轻字符串对内存的占用

在这里插入图片描述

在这里插入图片描述

6.4 垃圾回收案例

  • 字符串常量池参与垃圾回收

未添加前：1700+ 个

/**
 * 演示 StringTable 垃圾回收
 * -Xmx10m -XX:+PrintStringTableStatistics -XX:+PrintGCDetails -verbose:gc
 */
public static void main(String[] args) {
    int i=0;
    try {
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        System.out.println("添加到字符串常量池个数："+i);
    }
}

#垃圾回收信息：无
#打印信息：
添加到字符串常量池个数：0
#字符串常量池信息：未添加前存在1757个字符串
StringTable statistics:
Number of buckets       :     60013 =    480104 bytes, avg   8.000
Number of entries       :      1757 =     42168 bytes, avg  24.000
Number of literals      :      1757 =    157720 bytes, avg  89.767
Total footprint         :           =    679992 bytes

添加10000个：应该有 11700+ 个，但只保留 2800+ 个

/**
 * 演示 StringTable 垃圾回收
 * -Xmx10m -XX:+PrintStringTableStatistics -XX:+PrintGCDetails -verbose:gc
 */
public static void main(String[] args) {
    int i=0;
    try {
        for (int j = 0; j < 10000; j++) {
            String.valueOf(j).intern();
            i++;
        }
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        System.out.println("添加到字符串常量池个数："+i);
    }
}

#垃圾回收信息：
[GC (Allocation Failure) [PSYoungGen: 2048K->488K(2560K)] 2048K->688K(9728K), 0.0010454 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
#打印信息：
添加到字符串常量池个数：10000
#字符串常量池信息：应该有 11700+ 个，但只保留 2800+ 个
StringTable statistics:
Number of buckets       :     60013 =    480104 bytes, avg   8.000
Number of entries       :      2867 =     68808 bytes, avg  24.000
Number of literals      :      2867 =    211320 bytes, avg  73.708
Total footprint         :           =    760232 bytes

6.5 性能调优案例

6.5.1 调整桶个数

/**
 * -XX:StringTableSize=200000 -XX:+PrintStringTableStatistics
 */
public static void main(String[] args) {
    Long start=System.nanoTime();
    for (int i = 0; i < 5000000; i++) {
        String.valueOf(i).intern();
    }
    System.out.println("cost："+(System.nanoTime()-start)/1000000+" ms");
}

不调整

  • 桶数量为：60013
  • 耗时：4 s
#耗时
cost：4285 ms
#字符串常量池信息：桶数量为60013
StringTable statistics:
Number of buckets       :     60013 =    480104 bytes, avg   8.000
Number of entries       :   1422564 =  34141536 bytes, avg  24.000
Number of literals      :   1422564 =  79723080 bytes, avg  56.042
Total footprint         :           = 114344720 bytes

调小

  • 桶数量为：1009
  • 耗时：2分钟
#耗时
cost：124604 ms
#字符串常量池信息：桶数量为1009
StringTable statistics:
Number of buckets       :      1009 =      8072 bytes, avg   8.000
Number of entries       :    249555 =   5989320 bytes, avg  24.000
Number of literals      :    249555 =  14034576 bytes, avg  56.238
Total footprint         :           =  20031968 bytes

调大

  • 桶数量为：200000
  • 耗时：2 s
#耗时
cost：2252 ms
#字符串常量池信息：桶数量为200000
StringTable statistics:
Number of buckets       :    200000 =   1600000 bytes, avg   8.000
Number of entries       :   1422584 =  34142016 bytes, avg  24.000
Number of literals      :   1422584 =  79724200 bytes, avg  56.042
Total footprint         :           = 115466216 bytes

6.5.2 考虑入池

不入池

/**
 * -XX:StringTableSize=200000
 * 不入池
 */
public static void main(String[] args) throws IOException {
    List<String> list=new ArrayList<>();
    System.in.read();
    for (int i = 0; i < 10; i++) {
        Long start=System.nanoTime();
        for (int j = 0; j < 500000; j++) {
            list.add(String.valueOf(j));
        }
        System.out.println("cost："+(System.nanoTime()-start)/1000000+" ms");
    }
    System.in.read();
}

在这里插入图片描述

在这里插入图片描述

入池

/**
 * -XX:StringTableSize=200000
 * 入池
 */
public static void main(String[] args) throws IOException {
    List<String> list=new ArrayList<>();
    System.in.read();
    for (int i = 0; i < 10; i++) {
        Long start=System.nanoTime();
        for (int j = 0; j < 500000; j++) {
            list.add(String.valueOf(j).intern());
        }
        System.out.println("cost："+(System.nanoTime()-start)/1000000+" ms");
    }
    System.in.read();
}

在这里插入图片描述

在这里插入图片描述

七、直接内存

在这里插入图片描述

7.1 定义

Direct Memory

  • 常见于 NIO 操作时，用于数据缓冲区

  • 分配回收成本较高，但读写性能高

  • 不受 JVM 内存回收管理

    //内存溢出：java.lang.OutOfMemoryError: Direct buffer memory
public static void main(String[] args) {
    List<ByteBuffer> list=new ArrayList<>();
    int i=0;
    try {
        while(true){
            ByteBuffer buffer = ByteBuffer.allocateDirect(1024 * 1024 * 100);
            list.add(buffer);
            i++;
        }
    } finally {
        System.out.println(i); //17
    }
}

7.2 分配

  • 使用了 **Unsafe 对象 **完成直接内存的分配回收
//分配，返回地址
Long base=unsafe.allocateMemory(1024*1024*1024);
unsafe.setMemory(base, 1024*1024*1024, (byte) 0);

在这里插入图片描述

7.3 回收原理

  • 注意与建议：不依赖gc的情况下，可以使用 unsafe 手动管理直接内存

  • ByteBuffer 的实现类内部，使用了 **Cleaner （虚引用）**来监测 ByteBuffer 对象，一旦 ByteBuffer 对象被垃圾回收，那么就会由 ReferenceHandler 线程通过 Cleaner 的 clean 方法调 用 freeMemory 来释放直接内存

    //释放内存
unsafe.freeMemory(base);

随着gc的调用而回收？

在这里插入图片描述

释放原理

public static ByteBuffer allocateDirect(int capacity) {
    return new DirectByteBuffer(capacity);
}
	//调用 直接缓存 的构造方法
    DirectByteBuffer(int cap) {
        //...
        try {
            //1.分配内存
            base = unsafe.allocateMemory(size);
        } catch (OutOfMemoryError x) {
            Bits.unreserveMemory(size, cap);
            throw x;
        }
        //2.设置内存
        unsafe.setMemory(base, size, (byte) 0);
        if (pa && (base % ps != 0)) {
            address = base + ps - (base & (ps - 1));
        } else {
            address = base;
        }
        //3.释放内存：当Cleaner关联的 this对象 被回收时，触发 clean()
        cleaner = Cleaner.create(this, new Deallocator(base, size, cap));
        att = null;
    }
		//3.1 触发回调对象的run方法
		public void clean() {
    	    if (remove(this)) {
    	        try {
                    //3.1 调用
    	            this.thunk.run();
    	        } catch (final Throwable var2) {}
    	    }
    	}
			//3.2 Cleaner中的 new Deallocator 回调任务
        	public void run() {
        	    //...
                //释放直接内存
        	    unsafe.freeMemory(address);
        	    address = 0;
        	    Bits.unreserveMemory(size, capacity);
        	}

悦读

道可道，非常道；名可名，非常名。 无名，天地之始，有名，万物之母。 故常无欲，以观其妙，常有欲，以观其徼。 此两者，同出而异名，同谓之玄，玄之又玄，众妙之门。

最新收录
ssm宠物网站系统 毕业设计-附源码07183 原创
Linux网络设置
RAG(检索增强生成)在LLM(大型语言模型)中的应用
python反编译md5_GDA反编译器更新至3.66：支持污点传播分析、方法签名、python脚本...
使用flask框架构建程序的目录结构
vue2中新增与修改在一个页面上操作
深度寻路算法（含图形化界面）--------C语言
《梦醒蝶飞：释放Excel函数与公式的力量》17.2 工作表函数的高级应用
【echarts】使用 ECharts 绘制3D饼图
序列标注 | (2) 用命名实体识别(NER)解释CRF (BiLSTM+CRF)
;