JVM极简教程

news2024/11/15 12:03:54

基础概念

1.1. Java 虚拟机

是运行 Java字节码的虚拟机

1.2. JVM跨平台原理

JVM在不同的系统（Linux、Windows、MacOS）上有不同的实现，目的是在使用相同的字节码，它们都会给出相同的结果

JVM跨平台本质：不同操作系统上运行的JVM是不同的

1.3. Java字节码

在Java中，JVM可理解的代码就叫作字节码，即扩展名为.class的文件。

Java文件首先被javac编译为.class字节码，JVM将.class字节码解释成机器指令

JVM整体架构

2.1. 架构概述

  1. Hello.java: Java源代码文件，包含Java代码。

  2. Hello.class: 通过Java编译器将Hello.java文件编译成字节码文件Hello.class。

  3. 类加载子系统: 将Hello.class文件加载到JVM内存中，准备执行。

  4. 运行时数据区（Runtime Data Area）: JVM运行时使用的内存区域，包括多个部分：

    • 本地方法栈: 用于本地方法（使用JNI调用的非Java方法）执行的栈。

    • Java方法栈: 每个Java方法调用时都会创建一个栈帧，存储局部变量和部分结果。

    • 程序计数器: 用于存储当前线程所执行的字节码指令的地址，以方便线程继续执行接下来的指令。

    • 方法区: 存储类结构信息、常量池、方法数据和方法代码等。

    • 堆: 用于存储所有Java对象的区域。

  1. 执行引擎: 负责执行字节码，包括以下组件：

    • 解释器: 将字节码逐行解释执行。

    • JIT编译器: 将热点字节码编译成本地机器代码，提高执行效率。

    • 垃圾回收器: 管理和回收不再使用的对象内存。

整体流程：

  1. Java源代码文件（Hello.java）被编译成字节码文件（Hello.class）。

  2. 类加载子系统将字节码文件加载到方法区。

  3. 执行引擎负责解释和编译字节码，最终在运行时数据区执行。

2.2. 类加载子系统

2.2.1. 加载

加载阶段是将类的字节码文件（如 Hello.class）从磁盘或其他存储设备加载到 JVM 的内存中。加载过程包括以下几个步骤：

  • 通过类的全限定名获取类的二进制字节流：根据类的全限定名（比如 com.example.Hello），找到对应的 .class 文件，并读取其二进制数据。

  • 创建一个类的 Class 对象：将类的二进制数据转换成 JVM 中的 Class 对象，该对象包含了类的结构信息（类的字段、方法、父类、接口等）。

  • 存储在方法区（或元空间）：将加载的类信息存储在 JVM 的方法区（或元空间）中，包括类的结构信息、静态变量等。方法区是 JVM 的一部分，用于存储类的结构信息和静态变量。

2.2.2. 链接

链接阶段主要负责将 Java 类的二进制代码合并到运行环境中，包括以下三个步骤：

1. 验证（Verification）

验证阶段主要确保加载的类符合 JVM 规范，不会破坏 JVM 的内部结构和安全：

  • 文件格式验证：验证类文件的字节码格式是否符合 JVM 规范，防止恶意代码或错误的类文件导致 JVM 崩溃。

  • 语义验证：对类文件进行语义分析，确保类的字节码执行时不会违反 Java 语言规范，如类型转换的正确性、访问权限的合法性等。

  • 字节码验证：确保类的字节码操作的正确性和安全性，防止恶意代码通过字节码操纵 JVM。

2. 准备（Preparation）

准备阶段为类的静态变量分配内存空间，并设置默认初始值（零值）：

  • 为静态变量分配内存空间：在方法区中为类的静态变量分配内存空间，不包括在代码中赋值的操作。

  • 设置默认初始值：静态变量会被默认初始化为零值（数值类型为 0，引用类型为 null）。

3. 解析（Resolution）

解析阶段将类、接口、字段和方法的符号引用解析为直接引用，找到引用类在方法区具体的地址：

  • 将符号引用解析为直接引用：将类或接口名转换为对应的直接引用，如方法、字段等的直接引用地址，以便后续执行时能够直接定位到具体的内存地址。

2.2.3. 初始化

初始化阶段是类加载过程的最后一步，主要执行类构造器 <clinit>() 方法，初始化类的静态变量和静态代码块：

  • 执行 <clinit>() 方法：<clinit>() 是类构造器方法，由编译器自动收集类中的所有静态变量的赋值动作和静态代码块（静态初始化块）的合并产生的。在执行过程中，虚拟机会保证 <clinit>() 方法的线程安全性，确保它仅被执行一次，即使多个线程同时去初始化一个类。

  • 静态变量和静态代码块的初始化：执行静态变量的显式赋值和静态代码块中的逻辑，完成对静态成员变量的初始化。

2.3. 类加载器的分类



  1. 启动类加载器（Bootstrap Class Loader）：

  • 是 Java 虚拟机的一部分，负责加载 Java 的核心类库，如 java.lang 包中的类。它是由本地代码实现的，通常不是由 Java 实现的类。
  • 启动类加载器是所有类加载器的根，它不是 ClassLoader 的子类，它在虚拟机启动时首先被初始化。

  1. 扩展类加载器（Extension Class Loader）：

  • 是 sun.misc.Launcher$ExtClassLoader 类的实例，负责加载 Java 的扩展库，如 java.ext.dirs 系统属性指定的目录中的类。
  • 它是由 Java 实现的类，是 Launcher 类的内部静态类。
  • 扩展类加载器的父加载器是启动类加载器。

  1. 应用程序类加载器（Application Class Loader）：

  • 是 sun.misc.Launcher$AppClassLoader 类的实例，负责加载应用程序类路径（classpath）上的类，即我们自己编写的类和第三方类库。
  • 它也是由 Java 实现的类，是 Launcher 类的内部静态类。
  • 应用程序类加载器的父加载器是扩展类加载器。

这三种类加载器之间形成了一种层次关系，如下所示：

  • 应用程序类加载器（Application Class Loader）

    • 父加载器：扩展类加载器（Extension Class Loader）

      • 父加载器：启动类加载器（Bootstrap Class Loader）

这种层次结构使得类加载器可以按照一定的规则委托父加载器来加载类，从而实现类加载的双亲委派模型（Delegation Model）。

当类加载器收到加载类的请求时：

  1. 检查是否已经加载过：首先，类加载器会检查该类是否已经被自己加载过了。如果已经加载过，则直接返回已加载的类，避免重复加载。

  2. 委托给父类加载器：如果该类没有被当前类加载器加载过，它会将加载请求委托给父类加载器。父类加载器会按照同样的流程检查是否已经加载过该类，如果没有则继续向上委托，直到达到启动类加载器（Bootstrap Class Loader）为止。

  3. 尝试自己加载：如果所有父类加载器都无法加载该类（即在其委托链上都找不到），那么当前类加载器会尝试自己加载该类。这时，它会根据自己的加载规则（通常是从指定的类路径或者其他路径加载）去加载该类。

这种加载模型被称为双亲委派模型（Delegation Model），它的主要优势在于确保类加载的顺序和一致性，避免了同名类的冲突和安全性问题。通过这种方式，即使在不同的类加载器实例中，同一个类也只会被加载和定义一次，保证了类的唯一性和一致性。



2.4. 双亲委派



点击如下代码的loadClass



import lombok.SneakyThrows;

/**
 * @author guowei23
 * @Description
 * @create 2024-07-2024/7/18 00:47
 */

public class Test {
    @SneakyThrows
    public static void main(String[] args) {
        String str = "123";
        Class<?> tObj = str.getClass().getClassLoader().loadClass("java.lang.String");
    }
}

进入到

public abstract class ClassLoader {
    ...
    public Class<?> loadClass(String name) throws ClassNotFoundException {
        return loadClass(name, false);
    }
    ...
}

再次点击loadClass

protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
    synchronized (getClassLoadingLock(name)) {
        // 首先检查这个类是否已经被加载过
        Class<?> c = findLoadedClass(name);
        if (c == null) {
            // c为null证明类没有被加载过
            long t0 = System.nanoTime();
            try {
                // 找到该classLoader的父类
                if (parent != null) {
                    // 尝试通过父类加载器加载类
                    c = parent.loadClass(name, false);
                } else {
                    // 调用 findBootstrapClassOrNull(name) 来加载核心类库
                    c = findBootstrapClassOrNull(name);
                }
            } catch (ClassNotFoundException e) {
                // 如果父类加载器抛出ClassNotFoundException，则继续尝试加载
            }

            if (c == null) {
                // 如果仍然未找到，则调用findClass来加载类
                long t1 = System.nanoTime();
                c = findClass(name);

                // 记录性能统计数据
                sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
                sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
                sun.misc.PerfCounter.getFindClasses().increment();
            }
        }
        if (resolve) {
            // 调用 resolveClass(c) 方法来解析该类。解析过程包括初始化类的静态变量和执行静态代码块。
            resolveClass(c);
        }
        return c;
    }
}

2.5. 运行时数据区

  1. 方法区：存储类信息、常量、静态变量和即时编译器编译后的代码等数据。方法区是被所有线程共享的内存区域。

  2. 堆：Java堆是JVM所管理的内存中最大的一块，用于存储所有的对象实例和数组。堆也是垃圾收集器管理的主要区域，通常被称为“垃圾收集堆”。

  3. Java方法栈：每个线程运行时都会创建一个栈，用于存放局部变量、操作数栈、动态链接和方法返回地址等信息。

  4. 程序计数器：每个线程都有一个程序计数器，用于记录当前线程执行的字节码指令地址。

  5. 本地方法栈：专门用于支持本地方法的执行。

线程共享 线程私有



2.6. 程序计数器

PC Register，程序计数寄存器简称为程序计数器:

  1. 是物理寄存器的抽象实现：在Java虚拟机中，程序计数器是物理寄存器的一个抽象表示，用于独立于物理硬件的虚拟环境中。

  2. 用来记录待执行的下一条指令的地址：程序计数器保存着当前线程正在执行的字节码指令的地址，如果执行的是本地方法，则此计数器值为undefined。

  3. 它是程序控制流的指示器，循环、if lese、异常处理、线程恢复等都依赖它来完成：程序计数器对于控制流的管理至关重要，确保在多线程环境中，每个线程在执行控制结构（如循环、分支等）和异常处理时能准确恢复执行状态。

  4. 解释器工作时就是通过它来获取下一条需要执行的字节码指令：在解释器模式下，JVM通过程序计数器来读取接下来要执行的指令。

  5. 它是唯一一个在JM规范中没有规定任何OutOfMemoryError情况的区域：程序计数器是唯一一个JVM规范中没有规定可能抛出OutOfMemoryError的区域。这是因为其生命周期和线程一样，通常不需要动态扩展，也不会因为存储不足而导致错误。

2.7. 虚拟机栈（Java栈、Java方法栈）

每个线程在创建时都会创建一个虚拟机栈，栈内会保存一个个栈帧，每个栈帧对应一个方法。

  1. 虚拟机栈是线程私有的：每个线程创建时都会拥有自己的虚拟机栈，用于存储该线程执行的方法信息。

  2. 一个方法开始执行栈帧入栈方法执行完对应的栈帧就出栈所以虚拟机栈不需要进行垃圾回收

  3. 虚拟机栈存在OutOfMemoryError、以及StackOverflowError

  4. 线程太多，就可能会出现OutOfMemoryError，线程创建时没有足够的内存区创建虚拟机栈了

  5. 方法调用层次太多，就可能会出现StackOverflowError

  6. 可以通过-Xss来设置虚拟机栈的大小

2.8. 局部变量表和操作数栈

栈帧

测试代码

public class Test {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = a + b;
    }
}
编译代码
javac -g -d ./ Test.java

查看字节码

javap -v Test
查看字节码结果
Classfile /Users/guowei23/IdeaProjects/github/com/molefuckgo/SpringBootDemo/src/main/java/com/example/springbootdemo/com/example/springbootdemo/Test.class
  Last modified 2024年7月21日; size 477 bytes
  SHA-256 checksum 21b9823acb804801b50c2ed62fa3ed6b2ef2ffd3b024fd230d5f61eee2aa7f1b
  Compiled from "Test.java"
public class com.example.springbootdemo.Test
  minor version: 0
  major version: 59
  flags: (0x0021) ACC_PUBLIC, ACC_SUPER
  this_class: #7                          // com/example/springbootdemo/Test
  super_class: #2                         // java/lang/Object
  interfaces: 0, fields: 0, methods: 2, attributes: 1
Constant pool:
   #1 = Methodref          #2.#3          // java/lang/Object."<init>":()V
   #2 = Class              #4             // java/lang/Object
   #3 = NameAndType        #5:#6          // "<init>":()V
   #4 = Utf8               java/lang/Object
   #5 = Utf8               <init>
   #6 = Utf8               ()V
   #7 = Class              #8             // com/example/springbootdemo/Test
   #8 = Utf8               com/example/springbootdemo/Test
   #9 = Utf8               Code
  #10 = Utf8               LineNumberTable
  #11 = Utf8               LocalVariableTable
  #12 = Utf8               this
  #13 = Utf8               Lcom/example/springbootdemo/Test;
  #14 = Utf8               main
  #15 = Utf8               ([Ljava/lang/String;)V
  #16 = Utf8               args
  #17 = Utf8               [Ljava/lang/String;
  #18 = Utf8               a
  #19 = Utf8               I
  #20 = Utf8               b
  #21 = Utf8               c
  #22 = Utf8               SourceFile
  #23 = Utf8               Test.java
{
  public com.example.springbootdemo.Test();
    descriptor: ()V
    flags: (0x0001) ACC_PUBLIC
    Code:
      stack=1, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: return
        // stack=1：最大堆栈深度为1。
        // locals=1：局部变量表中有1个槽位。
        // args_size=1：方法参数个数为1（this）。
        // aload_0：将this引用加载到操作数栈中。
        // invokespecial #1：调用父类Object的构造函数。
        // return：返回到调用者。
      LineNumberTable: // 显示源代码行号与字节码偏移量的映射
        line 9: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       5     0  this   Lcom/example/springbootdemo/Test;

  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: (0x0009) ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=4, args_size=1
      // stack=2：最大堆栈深度为2，表示此方法在执行过程中可能需要的最大栈大小为2。
      // locals=4：局部变量表中有4个槽位，包括方法参数和局部变量。
      // args_size=1：方法参数个数为1，即String[] args。
         0: bipush        10     // 将常量10推送到操作数栈。 根据LineNumberTable：对应Test.java第11行：int a = 10;
         2: istore_1             // 将操作数栈顶的int值存储到局部变量表索引1的位置。
         3: bipush        20     // 将常量20推送到操作数栈。根据LineNumberTable：对应Test.java第12行：int b = 20;
         5: istore_2             // 将操作数栈顶的int值存储到局部变量表索引2的位置。
         6: iload_1              // 将局部变量表索引1处的int值加载到操作数栈。根据LineNumberTable：对应Test.java第13行：int c = a + b;
         7: iload_2              // 将局部变量表索引2处的int值加载到操作数栈。
         8: iadd                 // 将操作数栈顶的两个int值相加，并将结果压入操作数栈。
         9: istore_3             // 将操作数栈顶的int值存储到局部变量表索引3的位置。
        10: return               // 返回到调用者。
      LineNumberTable:
        line 11: 0    // 源代码行号：指的是在源代码文件（例如Test.java）中的行号。
                      // 字节码偏移量：指的是在编译后生成的字节码文件（例如Test.class）中的具体位置偏移量。
                      // 源代码第11行对应于字节码的偏移量0处。这意味着当程序执行到字节码偏移量0处时，它正在执行源代码文件中的第11行代码
        line 12: 3
        line 13: 6
        line 14: 10
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      11     0  args   [Ljava/lang/String;
            3       8     1     a   I
            6       5     2     b   I
           10       1     3     c   I
        // Start：变量的起始字节码偏移量。
        // Length：变量在字节码中的作用范围。
        // Slot：局部变量表的索引（槽位）。
        // Name：变量名。
        // Signature：变量类型签名。
}
SourceFile: "Test.java"

2.9. 本地方法栈

本地方法:native method，在Java中定义的方法，但由其他语言实现。

虚拟机栈存的是Java方法调用过程的栈帧，本地方法栈存的是本地方法调用过程中的栈帧。

也是线程私有的，也可能会出现OOM和SOF

2.10. 堆

堆是JVM中最重要的一块区域，JVM规范中规定所有的对象和数组都应该存放在堆中，在执行字节码指令时会把创建的对象存入堆中，对象对应的引用地址存入虚拟机栈中的栈帧中，不过当方法执行完之后，刚刚所创建的对象并不会立马被回收，而是要等JVM后台执行GC后，对象才会被回收。

-Xms: ms(memory start)，指定堆的初始化内存大小，等价--XX:InitialHeapSize

-Xmx:mx(memory max)，指定堆的最大内存大小，等价于-XX:MaxHeapSize样，一般会把-Xms和-Xmx设置为一样，这样JVM就不需要在GC后去修改堆的内存大小了，提高了效率

默认情况下，初始化内存大小=无力内存大小/64，最大内存大小=物理内存大小/4



-X:NewRatio 是一个 Java 虚拟机 (JVM) 参数，用于设置 Java 垃圾收集器中年轻代和老年代的比率。

-XX:NewRatio=<ratio>

这里的 <ratio> 是老年代与年轻代的比率。例如，-XX:NewRatio=3 表示老年代的大小是年轻代的三倍。这个参数可以帮助调整垃圾收集器的性能，根据应用程序的特点选择合适的比率，以优化内存使用和垃圾收集频率



Java 堆内存主要分为两大部分：新生代（Young Generation）和老年代（Old Generation）。它们在垃圾收集行为和目的方面有所不同：

新生代 (Young Generation)

  • 目的：大多数 Java 对象初始创建时都会被分配到新生代。由于许多对象生命周期较短，新生代经常进行垃圾回收，这种回收被称为 Minor GC。

  • 结构：新生代通常进一步分为三个部分：一个较大的Eden区和两个较小的Survivor区（通常标记为 Survivor1 和 Survivor2 或 From 和 To）。对象首先在 Eden 区域分配。Minor GC 时，存活的对象会从 Eden 区移动到一个 Survivor 区，之后从一个 Survivor 区移动到另一个。

  • 回收频率：相对较高，但每次回收处理的数据量较小，速度快。

老年代 (Old Generation)

  • 目的：在多次 Minor GC 之后依然存活的对象会被晋升到老年代。老年代用来存放应用中生命周期长的数据。

  • 回收频率：较新生代低很多，但每次回收的开销较大，因为涉及到的数据量通常较大。

  • 垃圾回收：当老年代满时进行的垃圾回收称为 Major GC 或 Full GC，这种回收会涉及整个堆，包括新生代和老年代，因此会造成较长的停顿时间。

垃圾回收算法

不同的垃圾收集器可能会使用不同的算法来管理这两个区域。常见的垃圾收集器包括：

  • Serial GC：单线程收集器，适用于小型数据。

  • Parallel GC：多线程收集器，适用于需要高吞吐量的应用。

  • Concurrent Mark Sweep (CMS) GC：以获取最小停顿时间为目标，适用于需要低延迟的应用。

  • G1 GC：将堆划分为多个区域并并行处理，目标是在提供高吞吐量的同时控制停顿。

Young GC/Minor Gc:负声对新生代进行垃圾回收

Old GC/Major Gc: 负责对CMS垃圾收集器会单独对老年老年代进行垃圾回收，目前只有CMS垃圾收集器会单独对老年代进行垃圾收集，其他垃圾收集器基本都是整堆回收的时候对老年代进行垃圾收集

Full GC:整堆回收，也会堆方法区进行垃圾收集



在Java的垃圾回收机制中，对象主要在堆内存中进行分配和移动。堆内存被分为几个区域，其中包括年轻代（Young Generation）和老年代（Old Generation）。年轻代进一步分为Eden区、Survivor0（S0）区和Survivor1（S1）区。对象的移动过程如下：

  1. 对象首次分配：当新对象被创建时，它们通常首先被分配在Eden区。Eden区是年轻代中最大的部分，大多数新生成的对象都会被分配到这里。

  2. 第一次垃圾回收：当Eden区满时，将触发一次Minor GC（也称为Young GC），负责清理年轻代的垃圾回收。GC过程中，存活的对象会从Eden区移动到一个Survivor区（例如S0）。在这个过程中，所有从Eden区和另一个Survivor区（此时通常为空，例如S1）中存活下来的对象都会被复制到S0区。

  3. 对象在Survivor区间移动：在随后的几次Minor GC中，如果对象在S0区存活下来，它们会被移动到S1区，然后在下一次GC时可能又会移回S0区。这种在两个Survivor区间的来回移动主要是为了过滤掉只临时存活的对象，确保只有较长时间存活的对象最终被移动到老年代。

  4. 晋升到老年代：一个对象如果在Survivor区中存活了足够多的垃圾回收周期（这个阈值可以通过JVM参数进行设置，如-XX:MaxTenuringThreshold），或者Survivor区不够大以至于无法容纳这些对象，它们就会被移动到老年代。老年代有更大的空间，用于存放长时间存活的对象。

  5. 在老年代的回收：老年代的回收频率较低，且通常采用不同的回收算法（如标记-清除或标记-整理）。老年代满了时会触发Major GC（也称为Full GC），这个过程通常比Minor GC要慢得多。

2.11. 垃圾回收

2.11.1. 垃圾标记阶段

2.11.1.1. 引用计数法

每个对象都保存一个引用计数器属性，用户记录对象被引用的次数

引用计数法优缺点：

优点

缺点

实现简单，计数器为0则表示是垃圾对象

需要额外的空间来存储引用计数



需要额外的时间维护引用计数



无法处理引用循环问题

2.11.1.2. 可达性分析法

用于确定哪些对象是“活的”。可达性分析法以GC Roots作为起始点，然后一层一层找到所引用的对象，被找到的对象就是存活的对象，其他不可达对象就是垃圾对象

GC Roots包括哪些

方法区静态属性引用的对象

全局对象的一种，Class对象本身很难被回收，回收的条件非常苛刻，只要Class对象不被回收，静态成员就不能被回收。

方法区常量池引用的对象

属于全局对象，例如字符串常量池，常量本身初始化后不会再改变，因此作为GC Roots也是合理的

方法栈中栈帧本地变量表引用的对象

属于执行上下文中的对象，线程在执行方法时，会将方法打包成一个栈帧入栈执行，方法里用到的局部变量会存放到栈帧的本地变量表中。只要方法还在运行，还没出栈，就意味这本地变量表的对象还会被访问，GC就不应该回收，所以这一类对象也可作为GC Roots。

JNI本地方法栈中引用的对象

和上一条本质相同，无非是一个是Java方法栈中的变量引用，一个是native方法(C、C++)方法栈中的变量引用。

被同步锁持有的对象

被synchronized锁住的对象也是绝对不能回收的，当前有线程持有对象锁呢，GC如果回收了对象，锁不就失效了嘛。

2.11.2.标记-清除（Mark-Sweep）算法

一种非常基础和常用的垃圾回收算法，针对某块内存空间，比如新生代、老年代，如果可用内存不足后，就会STW，暂定用户线程的执行，然后执行算法进行垃圾回收：

  1. 标记阶段：从GC Rootsi开始遍历，找到可达对象，并在对象头中进行记录

  2. 清除阶段：堆内存空间进行线性遍历，如果发现对象头中没有记录是可达对象，则回收它

优点

缺点

简单和直观：标记清除算法的逻辑相对简单，易于实现。它直接标记所有可达对象，然后清除未被标记的对象。

效率问题：每次垃圾回收都需要遍历所有的GC Roots以及从这些Roots可达的所有对象，这在对象数量庞大时会消耗较多的时间。

无需移动对象：该算法在清除垃圾时不需要移动存活的对象，这避免了对象地址更新相关的复杂性和开销。

内存碎片：虽然不移动对象减少了复杂性，但这也导致了内存碎片的问题。内存碎片可能使得大对象难以找到足够的连续空间，从而影响性能。



停顿时间：标记和清除过程中需要暂停应用程序的运行（Stop-the-World），在用户体验和实时系统中可能是不可接受的，特别是在标记和清除阶段需要的时间较长时更为明显。

2.11.3.复制（Copying）算法

复制算法通常用于年轻代，年轻代内存被分为两个半区：一为活动区，一为空闲区。当进行垃圾回收时，算法遵循以下步骤：

  1. 标记阶段：从GC Roots开始，标记所有可达的对象。

  2. 复制阶段：将所有标记的存活对象复制到空闲的内存半区。

  3. 清除阶段：清空原有的活动内存区，然后交换活动区和空闲区的角色。

优点

缺点

减少碎片：由于存活的对象被连续复制到另一块干净的内存区域，内存碎片得到显著减少，这有助于提高内存的分配速度。

内存利用率：复制算法需要额外的内存空间来存放复制的对象，实际上只有一半的内存区域是可用的，这减少了内存的有效利用率。

停顿时间短：相比标记-清除算法，复制算法只处理存活的对象，而且通常只在年轻代执行，因此可以实现更短的停顿时间。

成本问题：在对象存活率较高的场景下，复制的成本会相对较高，因为需要复制大量对象到新空间。

简化分配：在清除原内存区后，新对象可以快速地在一块连续的内存区域中分配，通常只需要简单地移动堆的指针。

适用性限制：复制算法更适用于对象存活率低的场合（如Java中的年轻代），在老年代或存活对象较多的情况下，复制算法的效率会受到影响。

2.11.3.标记-整理（Makr-Compact）算法

标记-整理算法的工作过程可以分为几个步骤：

  1. 标记阶段：从GC Roots开始，标记所有从根节点可达的对象。

  2. 整理阶段：所有存活的对象被整理并向内存区的一端移动。这一步骤压缩了对象，使得它们在内存中连续存放，从而消除了碎片。

  3. 清理阶段：完成对象整理后，未被移动的内存区域被视为垃圾并清理，从而为新的对象分配提供连续的空间。

优点

缺点

消除内存碎片：通过移动存活对象并压缩它们，标记-整理算法有效地消除了内存碎片，保证了更大块的连续内存可用，这对于大对象的分配非常有利。

效率问题：整理内存需要移动对象，并更新引用，这个过程比单纯的标记或复制更耗时。

不改变对象位置：与复制算法不同，在整理阶段之前，对象的位置保持不变，这简化了对象引用的更新。

停顿时间：整个标记和整理过程需要在垃圾回收期间暂停应用程序（Stop-the-World），这可能导致比其他算法更长的停顿时间。

更好的内存利用率：与复制算法相比，标记-整理算法不需要额外的空间作为复制目标，从而提高了内存利用率。



2.11.4.对比总结



标记-清除

标记-整理

复制

速度

中等

最慢

最快

空间开销

少（有碎片）

少（无碎片）

最多

移动对象

否

是

是

2.11.5.分代收集算法

分代收集（Generational Collection）算法是一种广泛应用于现代垃圾回收技术中的方法，它基于这样一个观察：对象的生命周期不同，有些对象很快就不再使用（短命），而有些则可能持续存在很长时间（长寿）。为了更有效地管理内存，分代收集算法将对象按照生命周期分成几代，通常包括年轻代（Young Generation）、老年代（Old Generation）和（在某些垃圾收集器中）永久代（Permanent Generation，但在Java 8及以上版本已被元空间（Metaspace）所替代）。

分代的基本结构和特点：

  1. 年轻代：

    • 包括一个Eden区和两个Survivor区（通常标为S0和S1）。

    • 新创建的对象首先在Eden区分配。

    • 经过一次Minor GC后，存活的对象会从Eden区移动到一个Survivor区（S0或S1），并在Survivor区间移动，直到年龄达到一定值后晋升到老年代。

    • 使用复制算法，因为大多数新生对象很快变得不可达。

  1. 老年代：

    • 存放生命周期较长的对象。

    • 当对象在年轻代中存活足够长的时间后，会被晋升到老年代。

    • 通常使用标记-清除或标记-整理算法，以减少内存碎片并有效地利用空间。

  1. 元空间（Java中特有）：

    • 存放类的元数据。

    • 与堆内存分开管理，在Java 8中替代了永久代，不再由JVM直接管理内存的分配，而是依赖于本地内存。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2080375.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

高标准农田灌区信息化如何提高灌溉效率

高标准农田灌区信息化如何提高灌溉效率

高标准农田灌区的信息化建设&#xff0c;是现代农业发展的重要一环&#xff0c;旨在通过先进的信息技术手段优化水资源管理&#xff0c;提高灌溉效率&#xff0c;保障粮食安全&#xff0c;同时促进农业可持续发展。这一过程不仅涉及硬件设施的升级&#xff0c;还包括软件系统、…
阅读更多...
第2章 双向链表

第2章 双向链表

双向链表 概念 对链表而言&#xff0c;双向均可遍历是最方便的&#xff0c;另外首尾相连循环遍历也可大大增加链表操作的便捷性。因 此&#xff0c;双向循环链表&#xff0c;是在实际运用中是最常见的链表形态。 基本操作 与普通的链表完全一致&#xff0c;双向循环链表虽然…
阅读更多...
PHP房屋出售出租多端多平台预约系统小程序源码

PHP房屋出售出租多端多平台预约系统小程序源码

&#x1f3e0;&#x1f511;「房屋出售出租多端运营系统」——房产管理新纪元&#xff0c;一键掌控所有&#xff01;&#x1f680; &#x1f3e1; 开篇直击&#xff1a;房产市场新利器&#xff0c;轻松管理不再是梦&#xff01; 亲们&#xff0c;还在为房屋出售或出租的繁琐流…
阅读更多...
【IC设计】跨时钟异步处理系列——单比特跨时钟

【IC设计】跨时钟异步处理系列——单比特跨时钟

文章目录 建立时间和保持时间单比特信号的跨时钟处理慢时钟域的信号传输到快时钟域打两拍 快时钟域的信号传输到慢时钟域方案一 脉冲展宽同步 (打拍打拍&#xff0c;进行或)代码原理图 方案二 脉冲电平检测双触发器同步边沿检测代码原理图 建立时间和保持时间 所谓的建立时间或…
阅读更多...
python可视化-漏斗图（转化分析）

python可视化-漏斗图（转化分析）

1、数据生成 from scipy import stats# 构造数据 stage [浏览,加入购物车,下单,支付,交易成功] values [] for i in range(len(stage)):values.append(int(1000*stats.expon.pdf(i, scale0.95))) 2、基于漏斗图的转化分析 from pyecharts import options as opts from pye…
阅读更多...
HarmonyOs如何获取rawfile目录下的所有文件列表

HarmonyOs如何获取rawfile目录下的所有文件列表

最近在做一个功能&#xff0c;需要使用获取rawfile下目录的所有文件 参考连接为&#xff1a; zRawfile-模块-C API-Localization Kit&#xff08;本地化开发服务&#xff09;-应用框架 - 华为HarmonyOS开发者 (huawei.com) 需要使用到native实现&#xff0c;实现步骤&#…
阅读更多...
redis面试（二十四）Semaphore锁实现

redis面试（二十四）Semaphore锁实现

Semaphore也是redis分布式锁支持的一种&#xff0c;同步组件 之前给大家的讲解的锁&#xff0c;基本上都是同时间只能一个客户端获取这个锁&#xff0c;然后做一些事情&#xff0c;处理完了以后释放锁 Semaphore&#xff0c;信号量&#xff0c;他作为一个锁机制&#xff0c;可以…
阅读更多...
Charles苹果手机https抓包

Charles苹果手机https抓包

1、电脑设置Charles代理端口 1)设置代理端口 Proxy-》Proxying Settings-》HTTP Proxy 设置端口 2)设置监控的代理地址 Proxy-》SSL Proxying Settings 添加Add允许所有地址*.* 2、电脑导入Charles的ssl证书 3、电脑查看Charles的IP地址和端口 4、手机无线wifi配置代理 5、手…
阅读更多...
kubernetes HPA

kubernetes HPA

K8S的HPA介绍 在Kubernetes&#xff08;K8S&#xff09;集群管理中&#xff0c;Horizontal Pod Autoscaler&#xff08;HPA&#xff09;是一种关键的自动扩缩容机制&#xff0c;用于根据当前负载情况自动调整Pod副本的数量。这一机制能够显著提升应用的响应能力和资源利用率&a…
阅读更多...
虚幻5|按键触发学习

虚幻5|按键触发学习

一&#xff0c;如图参考 1.下移 驱动阈值 越大按时间长才会触发&#xff0c;越小很快就可以触发 2.按下 当按下超出驱动阈值大小就会触发一次&#xff0c;这里的驱动阈值只能设置再0.1~1的大小 3.已松开 当按下的时候&#xff0c;先触发单次的started&#xff0c;如果按压…
阅读更多...
华为OD 山峰个数 C语言实现

华为OD 山峰个数 C语言实现

不知道是不是我理解错了&#xff0c;这个题目200分&#xff1f; int main(void) {int i 0;int len 0;char c \0;int data[1000] {0};int temp[1000] {-1};int top 0;int count 0;while(scanf("%d",&data[i]) 1){i;len;cgetchar();if(c \n){break;}}// …
阅读更多...
【调研】弱网环境下分片上传方案调研

【调研】弱网环境下分片上传方案调研

目标 在高延迟、高丢包的弱网环境下&#xff0c;合理调整上传任务中分片大小这一参数&#xff0c;以达到尽可能好的传输性能&#xff08;传输时间、成功率&#xff09;。 调研 腾讯云弱网分块续传功能 腾讯云的弱网分块续传功能&#xff0c;基于腾讯云对象存储(Cloud Object…
阅读更多...
Redis单线程和多线程

Redis单线程和多线程

1.Redis的单线程 Redis的单线程主要是指Redis的网络IO和键值对读写是由一个线程完成的&#xff0c;Redis在处理客户端的请求时包括获取&#xff08;Socket读&#xff09;、解析、执行、内容返回&#xff08;Socket写&#xff09;等都由一个顺序串行的主线程处理&#xff0c;这…
阅读更多...
OpenCV绘图函数（3）判断点一条直线是否在一个矩形范围内的函数clipLine()的使用

OpenCV绘图函数（3）判断点一条直线是否在一个矩形范围内的函数clipLine()的使用

操作系统&#xff1a;ubuntu22.04 OpenCV版本&#xff1a;OpenCV4.9 IDE:Visual Studio Code 编程语言&#xff1a;C11 算法描述 裁剪线段与图像矩形相交的部分。 cv::clipLine 函数计算出完全位于指定矩形内的线段部分。如果线段完全位于矩形之外&#xff0c;则返回 false。…
阅读更多...
实现流程化办公，可专注于开源可视化报表设计器！

实现流程化办公，可专注于开源可视化报表设计器！

近日&#xff0c;有很多粉丝和朋友们会问我们关于低代码技术平台、开源可视化报表设计器的相关内容和问题。其实&#xff0c;在流程化办公新时代&#xff0c;愿意启用新软件平台的客户朋友会收获市场红利&#xff0c;也会站在前沿之地上斩获更多市场份额。今天我们就一起来了解…
阅读更多...
【LLM之Data】SKYSCRIPT-100M论文阅读笔记

【LLM之Data】SKYSCRIPT-100M论文阅读笔记

研究背景 随着短视频和短剧的兴起&#xff0c;自动化的剧本生成和短剧制作在影视行业中的需求逐渐增加。传统的剧本生成过程需要大量的人工干预&#xff0c;限制了其在规模和效率上的扩展性。当前的大型语言模型&#xff08;LLM&#xff09;在剧本生成方面展现出一定潜力&…
阅读更多...
Leetcode面试经典150题-5.最长回文子串

Leetcode面试经典150题-5.最长回文子串

解法都在代码里&#xff0c;不懂就留言或者私信 class Solution {public static String longestPalindrome(String s) {if(s null || s.length() 0) {return null;}//加工字符串&#xff0c;例如abcdcba加工成#a#b#c#d#a#b#c#d#String str getManacherString(s);char[] str…
阅读更多...
UWB实操：用litepoint确认UWB SP0和SP3帧长度

UWB实操：用litepoint确认UWB SP0和SP3帧长度

用litepoint确认UWB SP0和SP3帧长度 预备知识 SP0 frame length Sync+SFD = 65.1+ 8.1 = 73 us
阅读更多...
uniapp定义scss颜色变量deep()修改子组件样式

uniapp定义scss颜色变量deep()修改子组件样式

uni.scss中 import "/common/style/base-style.scss"; 在base-style.scss中 $brand-theme-color:#28B389;//品牌主体红色$border-color:#e0e0e0 ; $border-color-light:#efefef; $text-font-color-1: #000 ;//文字主色 $text-font-color-2:#676767;//副标题颜色 $…
阅读更多...
​​聆思CSK6大模型语音视觉开发板接入AIUI技能实操（控制风扇开关）

​​聆思CSK6大模型语音视觉开发板接入AIUI技能实操（控制风扇开关）

前言 本文以大模型语音控制灯的开关为例,讲解如何通过LSPlatform的云端编排功能在大模型语音交互流程中加入AIUI技能&#xff0c;实现更丰富的产品功能。 大模型语音模板加入AIUI技能节点后的数据流程如下图所示&#xff1a; 大模型语音控制AIUI之风扇 硬件准备工作 聆思CSK6大…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023