JVM相关

一. 概念

1. 概念

是一个抽象的计算机，为Java程序提供运行环境。

二. 组成

1. 运行时数据区

运行时数据区是JVM在运行Java程序时使用的内存区域,它包括以下部分:

1. 程序计数器

1. 作用

1. 程序计数器是线程私有的内存区域
2. 记录当前线程所执行的字节码指令的地址。

2. 特点

1. 线程私有。
2. 如果线程正在执行Java方法，记录当前执行的字节码指令地址；如果执行本地方法，值为undefined。
3. 确保线程能够正确地恢复到上次执行的位置。

2. 虚拟机栈

1. 作用

1. 虚拟机栈是线程私有的内存区域，每个线程在创建时都会创建一个虚拟机栈
2. 存储方法调用过程中的局部变量、操作数栈、动态链接、方法出口等信息。

2. 特点

1. 线程私有。
2. 每个方法调用都会创建一个栈帧（Frame），方法执行完毕后栈帧出栈。
3. 栈深度不足时可能抛出StackOverflowError，栈空间不足时可能抛出OutOfMemoryError。

3. 本地方法栈

1. 作用

1. 本地方法栈为本地方法（Native Method）服务，存储本地方法调用过程中的信息。
2. 本地方法是用非Java语言编写的代码，例如C或C++代码

2. 特点

1. 线程私有。
2. 与虚拟机栈类似，但具体实现可能因JVM而异。
3. 在HotSpot JVM中，本地方法栈和虚拟机栈可以合二为一。

4. 堆内存（Heap Memory）

1. 作用

存储对象实例和数组。

2. 特点

1. 线程共享。
2. 是垃圾回收的主要区域，分为新生代和老年代。
3. 需要合理配置堆内存大小（通过-Xms和-Xmx参数）。

3. 分区

1. 新生代（Young Generation）：

1. 新生代是堆内存中用于存放新创建对象的区域。
2. 新生代又分为Eden区和两个Survivor区（通常称为From区和To区）。
3. 对象首先在Eden区分配，当Eden区满时，会触发Minor GC（新生代垃圾回收），将存活的对象移动到Survivor区。

2. 老年代（Old Generation）：

1. 老年代用于存放经过多次垃圾回收后仍然存活的对象。
2. 当对象在新生代中经过多次GC后仍然存活，就会被晋升到老年代。
3. 老年代的垃圾回收称为Major GC，通常比新生代的GC耗时更长。

3. 对象晋升机制

在新生代中，对象经过多次Minor GC后，如果仍然存活，就会晋升到老年代。
默认情况下，对象在新生代中存活的次数达到一定阈值（由-XX:MaxTenuringThreshold参数控制，默认值为15），就会晋升到老年代。

5. 方法区（Method Area）/元空间

1. 作用

存储类的结构信息，如常量池、字段信息、方法信息等。

2. 特点

1. 线程共享。
2. 在JDK 8及之后，方法区被元空间（Metaspace）替代。元空间使用本地内存（而不是堆内存），因此其大小不再受JVM堆内存大小的限制
3. 需要合理配置元空间大小（通过-XX:MetaspaceSize和-XX:MaxMetaspaceSize参数）。

6. 常量池（Constant Pool）

1. 概念

1. 主要用于存储编译期生成的各种字面量和符号引用。
2. 常量池在类加载过程中被加载到内存中,并且是线程共享的.

2. 特点

1. 是方法区的一部分。
2. 常量池空间不足时可能抛出OutOfMemoryError。

3. 分类

1. 运行时常量池（Runtime Constant Pool）:是常量池在运行时的存储形式，它是方法区（或元空间）的一部分。运行时常量池在类加载时被创建，并存储以下内容：

字符串常量：如"Hello"。
类和接口的全限定名：如java.lang.String。
字段和方法的名称及描述符：如public static void main(String[] args)。
整数、浮点数等基本类型的常量：如int、float等。
对其他类、方法和字段的符号引用：这些符号引用在类加载过程中会被解析为具体的内存地址。

2. 字面量常量池（Literal Pool）:是源代码中直接定义的常量，如字符串字面量、整数字面量等。这些字面量在编译时会被存储到运行时常量池中。例如：

String s = "Hello";
int num = 123;

4. 作用

1. 提高性能:通过存储重复使用的常量，避免了重复创建对象，从而节省内存空间并提高性能。例如，字符串常量池会确保相同的字符串字面量在内存中只有一个副本.

2. 支持字符串的intern()方法:字符串常量池是运行时常量池的一部分，它支持String.intern()方法。当调用intern()方法时，如果字符串已经存在于常量池中，则返回常量池中的引用；如果不存在，则将字符串添加到常量池中，并返回其引用。例如：

String s1 = "Hello";
String s2 = new String("Hello");
String s3 = s2.intern();System.out.println(s1 == s2); // false
System.out.println(s1 == s3); // true在这个例子中，s1和s3都指向常量池中的同一个字符串对象

3. 支持反射机制：常量池中存储了类、方法和字段的符号引用，这些信息在反射操作中被使用。例如，通过反射获取类的字段或方法时，JVM会从运行时常量池中查找对应的符号引用。

5. 常量池的生命周期

常量池的生命周期与类的生命周期密切相关：

1. 创建：当类加载器加载一个类时，运行时常量池被创建，并存储类的常量信息。
2. 使用：在类的运行过程中，常量池中的常量被频繁使用，例如字符串比较、反射操作等。
3. 销毁：当类被卸载时，运行时常量池被销毁。

2. 执行引擎（Execution Engine）

执行引擎是JVM的核心部分，负责执行字节码指令。它包括以下几个子系统：

1. 解释器（Interpreter）

1. 作用

逐条读取字节码指令并执行。

2. 特点

1. 适合解释执行简单的字节码指令。
2. 执行速度相对较慢，但启动速度快。

2. 即时编译器（Just-In-Time Compiler, JIT）

1. 作用

将字节码编译为本地机器码，提高执行效率。

2. 特点

1. 只编译热点代码（频繁执行的代码）。
2. 编译后的代码执行速度更快，但编译过程需要时间。

3.垃圾回收器（Garbage Collector）

1. 作用

自动回收堆内存中不再使用的对象，释放内存空间。

2. 特点

1. 垃圾回收器的实现因JVM而异，常见的有Serial GC、Parallel GC、CMS GC、G1 GC等。
2. 需要合理配置垃圾回收策略以优化性能。

3. 本地接口

本地接口是JVM与本地方法（Native Method）之间的桥梁，允许Java程序调用本地方法（如C或C++编写的代码）。本地接口的主要组成部分包括：

1. Java Native Interface (JNI)

1. 作用

提供Java代码与本地代码之间的交互接口。

2. 特点

1. 允许Java程序调用本地方法。
2. 需要编写本地代码（如C/C++）并编译为动态链接库（DLL或.so文件）。

2. Java Native Access (JNA)

1.作用

简化JNI的使用，允许Java程序直接调用本地库中的函数。

2. 特点

1. 不需要编写C/C++代码，直接通过Java代码调用本地库。
2. 提高了开发效率，但性能可能略低于JNI。

4. 类加载器（Class Loader）

类加载器负责加载Java类文件到JVM中。它包括以下几个层次：

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

1. 作用

加载Java核心类库（如java.lang.*）。

2. 特点

1. 由JVM实现提供，通常用本地代码实现。
2. 无法直接被Java代码访问。

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

1.作用

加载Java扩展类库（如javax.*）。

2. 特点

1. 通常加载$JAVA_HOME/lib/ext目录下的JAR文件。
2. 用Java实现，由启动类加载器加载。

3. 应用类加载器（Application Class Loader）

1.作用

加载应用程序的类路径（如classpath）中的类。

2. 特点

1. 用Java实现，由扩展类加载器加载。
2. 可以被Java代码直接访问。

4. 自定义类加载器（Custom Class Loader）

1. 作用

允许用户自定义类加载逻辑。

2. 特点

1. 通过继承java.lang.ClassLoader实现。
2. 常用于实现热部署、插件化等场景

5. 双亲委派机制

双亲委派模型是Java类加载机制的核心

1. 工作流程：

1. 加载请求：当一个类加载器收到类加载请求时，它不会直接去加载这个类，而是先将请求委派给其父类加载器。
2. 逐层委派：父类加载器会继续将请求委派给自己的父类加载器，直到委派到最顶层的启动类加载器。
3. 加载判断：如果父类加载器能够完成类加载任务，则返回加载的类；如果父类加载器无法加载（例如，找不到对应的类文件），则子类加载器才会尝试自己加载。
4. 加载完成：如果子类加载器也无法加载，则抛出ClassNotFoundException。

2. 优点

1. 避免重复加载：通过这种委派机制，确保一个类在JVM中只会被加载一次，避免了类的重复加载。
2. 保护核心类库：防止用户自定义的类覆盖核心类库中的类，例如，用户无法通过自定义一个java.lang.String类来覆盖JDK中的String类。

三.java程序的执行流程

1. 编写Java源代码

// 示例：HelloWorld.java
public class HelloWorld {public static void main(String[] args) {System.out.println("Hello, World!");}
}

2. 编译源代码

Java编译器将源文件编译成字节码文件（.class文件），字节码文件是与平台无关的中间代码，可以在任何支持JVM的操作系统上运行。

3. 类加载

JVM通过类加载器将字节码文件加载到内存中。类加载过程包括三个阶段：

1. 加载（Loading）

1. 类加载器将字节码文件加载到JVM的内存中，并将其转换为java.lang.Class对象。
2. 在这个阶段，JVM会读取字节码文件的内容并存储到运行时数据区的方法区中。

2. 链接（Linking）

链接阶段包括验证、准备和解析三个子阶段：

2.1 验证（Verification）：

确保字节码文件的格式正确，没有安全问题。

2.2 准备（Preparation）：

为类的静态变量分配内存，并设置默认初始值。

2.3 解析（Resolution）：

将字节码中的符号引用（如类名、方法名等）替换为直接引用（如内存地址）。

3. 初始化（Initialization）

1. 执行类的初始化代码，包括静态变量的赋值和静态代码块的执行。
2. 这是类加载的最后一个阶段，确保类的静态变量和静态代码块按照正确的顺序初始化。

4. 字节码执行

字节码文件被加载到JVM后，执行引擎开始执行字节码。JVM的执行引擎包括以下几个部分：

1. 解释器（Interpreter）

解释器逐条读取字节码指令并执行。解释器的执行速度相对较慢，但启动速度快。

2. 即时编译器（Just-In-Time Compiler, JIT）

JIT编译器会将热点代码（频繁执行的代码）编译为本地机器码，从而提高执行效率。JIT编译器在运行时动态地将字节码转换为高效的机器码。

3. 垃圾回收器（Garbage Collector）

1. 垃圾回收器负责自动回收堆内存中不再使用的对象，释放内存空间。垃圾回收器的实现因JVM而异，常见的有Serial GC、Parallel GC、CMS GC、G1 GC等。

5. 程序运行

1. 在执行引擎的作用下，Java程序的字节码被逐步执行，完成程序的逻辑。
2. 程序的输出结果会显示在控制台或其他输出设备上。

java HelloWorld

运行上述命令后，程序会输出：
Hello, World!

6. 程序结束

1. 当程序执行完毕后，JVM会清理资源，包括关闭线程、释放内存等。
2. 如果程序中有线程或守护线程，JVM会等待这些线程执行完毕后才会退出。

7. Java执行过程示意图

四. 栈内存和堆内存的区别

在Java中，堆（Heap）和栈（Stack）是两种非常重要的内存区域,以下是它们的主要区别

1. 内存分配方式

1.堆（Heap）：

1. 堆内存是动态分配的。对象的创建和销毁由垃圾回收器（Garbage Collector, GC）自动管理。
2. 开发者可以通过new关键字在堆上创建对象，但无法手动释放对象的内存。垃圾回收器会定期清理堆内存中不再使用的对象。

2. 栈（Stack）：

1. 栈内存是静态分配的。每个线程在创建时会分配一个固定大小的栈空间。
2. 栈内存的分配和释放是自动的，与方法的调用和返回同步。当方法被调用时，会创建一个栈帧（Frame），方法执行完毕后，栈帧被弹出。

2. 存储内容

1. 堆（Heap）：

1. 主要用于存储对象实例和数组。几乎所有的对象实例都在堆内存中分配。
2. 堆内存是线程共享的，多个线程可以访问堆内存中的对象。

2. 栈（Stack）：

1. 主要用于存储方法的局部变量、方法调用的上下文信息（如方法的参数、返回值、操作数栈等）。
2. 栈内存是线程私有的，每个线程都有自己的栈空间，线程之间无法直接访问彼此的栈内存。

3. 生命周期

1. 堆（Heap）：

1. 对象的生命周期由垃圾回收器决定。只要对象被引用，它就会一直存在于堆内存中。
2. 当对象不再被任何引用指向时，垃圾回收器会将其回收。
3. 堆内存的大小可以通过JVM参数（如**-Xms和-Xmx**）进行配置。

2. 栈（Stack）：

1. 栈帧的生命周期与方法的调用和返回同步。方法调用时创建栈帧，方法返回时栈帧被弹出。
2. 栈的大小在JVM启动时确定，通常可以通过-Xss参数配置每个线程的栈大小。

4. 内存大小

1. 堆（Heap）：

1. 堆内存是JVM中最大的内存区域，通常可以配置为几GB甚至更大。
2. 堆内存的大小受到JVM参数和物理内存的限制。

2. 栈（Stack）：

1. 栈内存的大小相对较小，通常每个线程的栈空间为1MB或2MB（默认值因JVM实现而异）。
2. 栈内存的大小主要取决于线程的数量和方法调用的深度。

5. 垃圾回收

1. 堆（Heap）：

1. 堆内存是垃圾回收的主要区域。垃圾回收器会定期清理堆内存中不再使用的对象，以释放空间。
2. 垃圾回收的算法包括标记-清除、复制、标记-压缩等。

2. 栈（Stack）：

1. 栈内存不需要垃圾回收。
2. 栈帧的生命周期与方法的调用和返回同步，方法执行完毕后，栈帧自动被弹出，局部变量的内存空间也随之释放。

6. 性能

1.堆（Heap）：

1. 堆内存的分配和释放相对较慢，因为垃圾回收器需要定期扫描和清理堆内存。
2. 堆内存的分配和释放需要考虑线程安全和内存碎片问题。

2. 栈（Stack）：

1. 栈内存的分配和释放非常快，因为栈的操作是线程私有的，且栈帧的生命周期与方法的调用和返回同步。
2. 栈内存的分配和释放是连续的，不会产生内存碎片。

7. 总结

1. 堆（Heap）：用于存储对象实例和数组，是线程共享的，需要垃圾回收，生命周期较长，大小较大，但分配和释放相对较慢。
2. 栈（Stack）：用于存储方法的局部变量和调用上下文，是线程私有的，不需要垃圾回收，生命周期较短，大小较小，但分配和释放非常快。

五. 垃圾回收算法

1. 概念

垃圾回收算法是垃圾回收的核心逻辑，它定义了如何识别和回收不再使用的对象

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

1. 原理

1. 标记阶段：从根节点（如全局变量、栈中的引用等）开始，遍历所有可达对象，并将这些对象标记为“存活”。
2. 清除阶段：扫描整个内存空间，回收所有未被标记的对象所占用的内存。

2. 优点

算法简单，易于实现。

3. 缺点

1. 内存碎片化：清除阶段会留下大量不连续的内存空间，导致后续分配大对象时可能找不到足够的连续空间。
2. 效率问题：标记和清除过程都需要遍历整个内存空间，效率较低。

3. 标记-复制算法（Copying Algorithm）

1. 原理

1. 将内存分为两块区域（通常称为“From”区和“To”区），每次只使用其中一块。
2. 在垃圾回收时，将存活的对象从“From”区复制到“To”区，然后清空“From”区。
3. 之后交换“From”区和“To”区的角色，重复上述过程。

2. 优点

1. 无内存碎片化：复制算法在复制过程中自然地整理内存空间，避免了内存碎片化问题。
2. 高效处理大量短命对象：适合新生代，因为新生代的对象大多数是短命的，复制算法可以高效地回收这些对象。

3. 缺点

1. 内存利用率低：每次只能使用一半的内存空间，另一半空间被浪费。
2. 不适合大对象：对于大对象，复制操作的开销较大。

4. 标记-压缩算法（Mark-Compact Algorithm）

1. 原理

1. 标记阶段：与标记-清除算法相同，从根节点开始标记所有可达对象。
2. 压缩阶段：将所有存活的对象向内存的一端移动，然后更新对象的引用，并回收剩余的空间。

2. 优点

1. 无内存碎片化：通过压缩内存空间，避免了内存碎片化问题。
2. 高效利用内存：与标记-清除算法相比，标记-压缩算法可以更高效地利用内存空间。

3. 缺点

1. 压缩开销大：压缩阶段需要移动对象并更新引用，操作较为复杂，开销较大。

5. 分代收集算法（Generational Collection Algorithm）

1. 原理

1. 分代假设：根据对象的生命周期，将内存分为新生代（Young Generation）和老年代（Old Generation）。
2. 新生代：大多数对象在创建后很快就会被回收，适合使用复制算法。
3. 老年代：对象在新生代中存活多次后晋升到老年代，老年代的对象生命周期较长，适合使用标记-压缩算法。
4. 新生代垃圾回收（Minor GC）：使用复制算法，将新生代中的存活对象复制到另一个区域，清空当前区域。
5. 老年代垃圾回收（Major GC）：使用标记-压缩算法，回收老年代中的对象。

2. 优点

1. 高效处理不同生命周期的对象：新生代和老年代分别使用不同的算法，提高了垃圾回收的效率。
2. 减少停顿时间：新生代的垃圾回收频率高，但停顿时间短；老年代的垃圾回收频率低，但停顿时间较长。

3. 缺点

1. 复杂度较高：需要管理新生代和老年代的内存分配和回收，实现较为复杂。

6. G1算法（Garbage-First Algorithm）

1. 原理

1. 分区管理：将堆内存划分为多个大小相等的区域（Region），每个区域可以是新生代或老年代。
2. 优先回收：优先回收垃圾最多的区域（即“垃圾优先”），以减少停顿时间。
3. 并发执行：在垃圾回收过程中，可以与应用程序线程并发执行，减少停顿时间。
4. 混合回收：在回收老年代时，可以同时回收新生代的区域，提高回收效率。

2. 优点

1. 低停顿时间：通过并发执行和优先回收垃圾最多的区域，可以显著减少停顿时间。
2. 高效利用内存：通过分区管理，避免了内存碎片化问题。
3. 可预测性：可以设置停顿时间目标，G1算法会尽量在指定的时间内完成垃圾回收。

3. 缺点

1. 复杂度高：实现较为复杂，需要管理多个区域的内存分配和回收。
2. 内存占用较高：需要预留一定的内存空间用于并发回收过程。

7. ZGC（Z Garbage Collector）

1. 原理

1. 分区管理：将堆内存划分为多个大小相等的区域（Region）。
2. 并发执行：几乎所有的垃圾回收操作都与应用程序线程并发执行，减少停顿时间。
3. 染色指针：使用染色指针技术，标记对象的存活状态，避免了传统的标记-清除算法中的标记阶段。
4. 内存映射：通过内存映射技术，快速更新对象的引用。

2. 优点

1. 极低停顿时间：停顿时间通常在毫秒级别，适合低延迟应用。
2. 高吞吐量：并发执行提高了垃圾回收的效率，减少了对应用程序性能的影响。
3. 可扩展性：支持大堆内存（如几十GB甚至上百GB）。

3. 缺点

1. 复杂度高：实现较为复杂，需要支持多种并发操作。
2. 内存占用较高：需要预留一定的内存空间用于并发回收过程。

8. Shenandoah GC

1. 原理

1. 分区管理：将堆内存划分为多个大小相等的区域（Region）。
2. 并发执行：几乎所有的垃圾回收操作都与应用程序线程并发执行，减少停顿时间。
3. 并发标记和清理：在标记和清理阶段，都可以与应用程序线程并发执行，减少停顿时间。

2. 优点

1. 低停顿时间：停顿时间通常在毫秒级别，适合低延迟应用。
2. 高吞吐量：并发执行提高了垃圾回收的效率，减少了对应用程序性能的影响。
3. 可扩展性：支持大堆内存（如几十GB甚至上百GB）。

3. 缺点

1. 复杂度高：实现较为复杂，需要支持多种并发操作。
2. 内存占用较高：需要预留一定的内存空间用于并发回收过程。

9. 常用算法的适用场景

1. 标记-清除算法：简单但效率较低，容易产生内存碎片。
2. 复制算法：适合新生代，无内存碎片化问题，但内存利用率低。
3. 标记-压缩算法：适合老年代，无内存碎片化问题，但压缩开销大。
4. 分代收集算法：结合新生代和老年代的特点，提高垃圾回收效率。
5. G1算法：适合大堆内存，低停顿时间，但实现复杂。
6. ZGC和Shenandoah GC：适合低延迟应用，停顿时间极低，但内存占用较高。

六. 垃圾回收器

1. 概念

1. 垃圾回收器用于无用对象的回收,主要分为以下两种:
2. 新生代和老年代垃圾回收器分别针对不同生命周期的对象进行管理，它们在算法、并发策略和性能目标上存在显著区别。

2. 新生代垃圾回收器

主要存储生命周期较短的对象，垃圾回收频率较高，但回收速度较快

1. Serial GC（串行垃圾回收器）

1. 算法：采用“标记-复制”算法。
2. 特点：单线程执行，适合单核处理器或小堆内存环境。回收时会暂停所有应用线程（Stop-The-World, STW）。
3. 适用场景：适用于单核或低核数的客户端应用。

2. ParNew GC（并行垃圾回收器）

1. 算法：采用“标记-复制”算法。
2. 特点：多线程并行执行，适合多核处理器环境。通常与CMS垃圾回收器结合使用。
3. 适用场景：适用于多核处理器的服务器环境。

3. Parallel Scavenge GC（并行收集器）

1. 算法：采用“标记-复制”算法。
2. 特点：多线程并行执行，注重吞吐量优化，适合后台任务繁重且对响应时间要求不高的场景。
3. 适用场景：适用于多核处理器的服务器环境。

3. 老年代垃圾回收器

老年代主要存储生命周期较长的对象，垃圾回收频率较低，但回收过程较为复杂，耗时较长

1.Serial Old GC（串行老年代垃圾回收器）

1. 算法：采用“标记-整理”算法。
2. 特点：单线程执行，适合单核处理器或小堆内存环境。回收时会暂停所有应用线程（STW）。
3. 适用场景：适用于单核或低核数的客户端应用。

2. Parallel Old GC（并行老年代垃圾回收器）

1. 算法：采用“标记-整理”算法。
2. 特点：多线程并行执行，适合多核处理器环境。常与Parallel Scavenge GC配合使用，以获得较高的吞吐量。
3. 适用场景：适用于多核处理器的服务器环境。

3. CMS GC（Concurrent Mark-Sweep）

1. 算法：采用“标记-清除”算法。
2. 特点：并发执行，减少停顿时间。但可能会产生内存碎片化问题，且在内存碎片严重时可能触发Full GC。
3. 适用场景：适用于对延迟要求较高的场景。

4. G1 GC（Garbage-First Garbage Collector）

1. 算法：将堆内存划分为多个固定大小的区域（Region），优先回收垃圾最多的区域。新生代和老年代的回收都由G1统一管理。
2. 特点：支持并发回收，减少停顿时间，适合大堆内存环境。
3. 适用场景：适用于大堆内存（几GB到几十GB）的服务器应用。

5. ZGC（Z Garbage Collector）

1. 算法：采用“标记-复制”算法，结合着色指针和读屏障技术。
2. 特点：低延迟，支持并发回收，适合超大堆内存（TB级别）环境。
3. 适用场景：适用于对响应时间要求极高的大型应用。

6. Shenandoah GC

1. 算法：并发执行，减少停顿时间，适合大堆内存环境。
2. 特点：与ZGC类似，但使用不同的算法和实现，允许在高内存占用时保持较短的停顿时间。
3. 适用场景：适用于大堆内存环境。

4. 新生代与老年代垃圾回收器的区别

1. 对象生命周期

1. 新生代：对象生命周期短，垃圾回收频繁但速度快。
2. 老年代：对象生命周期长，垃圾回收频率低但过程复杂、耗时长。

2. 垃圾回收算法

1. 新生代：大多采用“标记-复制”算法，回收效率高但会造成内存浪费。
2. 老年代：通常采用“标记-整理”或“标记-清除”算法，避免内存碎片化但回收开销大。

3. 并发与暂停时间

1. 新生代：通常会引发较短的STW暂停，因为回收对象较少、过程快。
2. 老年代：往往带来较长的暂停时间，尤其是单线程回收器。

4. 内存管理策略

1. 新生代：注重回收效率，频繁回收释放空间。
2. 老年代：关注内存合理利用和碎片化问题，回收过程更复杂。

七. 判断一个对象是否是垃圾的两种方法

1. 引用计数法（Reference Counting）

1. 原理

它为每个对象维护一个计数器，记录指向该对象的引用数量。当一个对象的引用计数为零时，说明没有引用指向该对象，该对象就可以被回收。

2. 优点

1. 简单高效：实现简单，垃圾回收过程高效，不需要遍历整个堆内存。
2. 及时回收：对象的引用计数为零时，可以立即回收，减少内存占用。

3. 缺点

1. 无法处理循环引用：如果两个或多个对象相互引用，即使它们不再被外部引用，它们的引用计数也不会为零，从而导致内存泄漏。
2. 线程安全问题：在多线程环境中，引用计数的更新需要线程安全的机制，否则可能导致数据不一致。
3. 额外开销：需要为每个对象维护一个引用计数器，增加了内存开销。

4. 例子

1. 假设对象A和对象B相互引用，但它们不再被其他对象引用
2. 在这种情况下，即使a和b不再被外部引用，它们的引用计数也不会为零，因此无法被垃圾回收器回收。

A a = new A();
B b = new B();
a.setB(b);
b.setA(a);

2. 可达性分析法（Reachability Analysis）

1. 原理

1. 可达性分析法是一种基于图的遍历算法，从一组“根节点”（如全局变量、栈中的引用等）开始，通过引用链递归遍历所有可达对象。
2. 如果一个对象无法通过任何引用链到达，那么这个对象就被认为是垃圾。

2. 优点

1. 解决循环引用问题：可达性分析法可以正确处理循环引用的情况，避免内存泄漏。
2. 灵活性高：可以结合不同的垃圾回收算法（如标记-清除、复制、标记-压缩等）实现高效的垃圾回收。
3. 适用于复杂场景：适合复杂的对象图结构，能够准确判断对象的存活状态。

3. 缺点

1. 性能开销较大：需要遍历整个内存空间，标记所有可达对象，性能开销较大。
2. 停顿时间较长：在标记阶段，通常需要暂停应用程序线程（Stop-The-World, STW），可能导致较长的停顿时间。

4. 例子

1. 假设对象A和对象B相互引用，但它们不再被外部引用
2. 在这种情况下，可达性分析法会从根节点开始遍历，发现a和b无法通过任何引用链到达，因此它们会被标记为垃圾并回收。

A a = new A();
B b = new B();
a.setB(b);
b.setA(a);

八. 垃圾回收机制

1. 概念

用于回收不再使用的内存空间，防止内存泄漏和程序崩溃。

2. 作用

1. 自动回收内存

1. 在程序运行过程中，会不断地分配内存来存储变量、对象等数据。如果没有垃圾回收机制，程序员需要手动管理内存的分配和释放。
2. 一旦忘记释放内存，就会导致内存泄漏，程序占用的内存会不断增加，最终可能导致系统资源耗尽。
3. 而垃圾回收机制能够自动检测哪些内存不再被程序使用，并将其回收，避免了内存泄漏问题。

2. 提高开发效率

1. 对于程序员来说，手动管理内存是一项繁琐且容易出错的任务。
2. 垃圾回收机制的出现使得程序员可以专注于程序逻辑的实现，而无需过多地担心内存管理问题。

3. 减少程序错误

1. 手动内存管理容易出现错误，如重复释放内存、释放未分配的内存等，这些错误可能导致程序崩溃或出现不可预测的行为。
2. 垃圾回收机制通过自动管理内存，减少了这类错误的发生概率。

3. 触发条件

1. 内存不足

1. 当程序运行过程中，内存分配请求无法满足时，垃圾回收机制会被触发。
2. 例如，当程序尝试创建一个大对象，而当前内存空间不足以容纳该对象时，垃圾回收器会启动，尝试回收内存空间，以便为新对象分配内存。

2. 程序显式调用

1. 在某些编程语言中，程序员可以通过显式调用垃圾回收器来触发垃圾回收。
2. 例如，在Java中，可以通过调用System.gc()方法来建议垃圾回收器进行垃圾回收。不过，这种调用并不是强制性的，垃圾回收器可能会根据当前的系统状态决定是否执行垃圾回收。

3. 定期检查

1. 垃圾回收器会定期检查内存使用情况，当内存使用率达到一定阈值或者满足其他条件时，就会触发垃圾回收。
2. 这种机制可以避免内存占用过高，提前清理无用对象，保证程序的稳定运行。

4. Minor GC、Major GC和Full GC

在Java虚拟机（JVM）中，垃圾回收（GC）操作根据回收的内存区域和目的可以分为Minor GC、Major GC和Full GC。以下是它们的定义、触发条件和区别：

1. Minor GC（新生代垃圾回收）

• 定义：Minor GC是针对新生代（Young Generation）的垃圾回收操作。
• 触发条件：
  • 当新生代的Eden区满时，会触发Minor GC。
• 特点：
  • Minor GC的频率较高，但停顿时间相对较短。
  • Minor GC不会影响老年代，也不会清理永久代或元空间。
  • 新生代中的对象生命周期较短，因此大部分对象在Minor GC时会被回收。

2. Major GC（老年代垃圾回收）

• 定义：Major GC是针对老年代（Tenured Generation）的垃圾回收操作。
• 触发条件：
  • 老年代空间不足时会触发Major GC。
  • 通常在Minor GC后，如果老年代无法容纳晋升的对象，也可能触发Major GC。
• 特点：
  • Major GC的停顿时间相对较长，因为它需要整理老年代的内存。
  • 除了CMS收集器外，其他收集器通常不会单独执行老年代的垃圾回收。

Full GC（全堆垃圾回收）

• 定义：Full GC是对整个堆内存（包括新生代和老年代）以及元空间（Metaspace）的垃圾回收操作。
• 触发条件：
  • 老年代空间不足。
  • 永久代或元空间空间不足。
  • 显式调用System.gc()方法。
  • 在进行Minor GC时，如果老年代的剩余空间不足以容纳新生代晋升的对象，会尝试进行Full GC。
• 特点：
  • Full GC的停顿时间最长，因为它需要扫描整个堆内存。
  • Full GC会清理新生代、老年代以及元空间中的垃圾对象。

区别

特点	Minor GC	Major GC	Full GC
回收区域	新生代（Eden区和Survivor区）	老年代	整个堆内存（新生代、老年代、元空间）
触发条件	Eden区满	老年代空间不足	老年代空间不足、元空间不足、显式调用System.gc()等
停顿时间	较短	较长	最长
频率	频繁	相对较少	最少

了解这些垃圾回收操作的区别和触发条件，有助于优化JVM的性能和垃圾回收策略。

5.如何减少Full GC的发生频率

减少Full GC发生频率可以从以下几个方面入手：

1. 调整堆内存大小

• 增大堆内存：适当增加堆内存大小可以减少老年代空间不足的情况，从而减少Full GC的发生。可以通过-Xms和-Xmx参数分别设置初始堆大小和最大堆大小。
• 调整新生代大小：适当增加新生代的大小，可以减少对象晋升到老年代的频率，从而减少老年代的压力。可以通过-Xmn参数设置新生代的大小。

2. 优化垃圾回收器和参数

• 选择合适的垃圾回收器：根据应用程序的特性选择合适的垃圾回收器。例如，G1 GC适用于需要低延迟和较大堆内存的应用；CMS回收器适合对响应时间敏感的应用。
• 调整垃圾收集器参数：
  • 使用-XX:NewRatio参数调整新生代和老年代的比例。
  • 使用-XX:SurvivorRatio参数调整Survivor区与Eden区的比例。
  • 设置-XX:MaxTenuringThreshold参数，控制对象从年轻代晋升到老年代的年龄阈值。

3. 优化对象分配和生命周期

• 减少大对象的创建：大对象容易直接进入老年代，增加Full GC的频率。尽量避免创建大对象，或者将大对象拆分为多个小对象。
• 减少短生命周期对象的创建：尽量减少短生命周期对象的创建，或将其分配在栈上而不是堆上。
• 使用对象池：缓存和复用对象，减少对象分配和垃圾回收频率。

4. 避免显式调用System.gc()

显式调用System.gc()会请求JVM进行Full GC，应尽量避免。

5. 调整元空间大小

适当增加元空间大小，可以减少因元空间不足触发的Full GC。可以通过-XX:MaxMetaspaceSize参数调整元空间的最大大小。

6. 检查和修复内存泄漏

内存泄漏会导致堆内存不断增加，最终导致Full GC。使用内存分析工具（如VisualVM、MAT等）检查和修复内存泄漏。

7. 监控和调优

• 监控GC日志：通过监控GC日志，了解GC的频率和停顿时间，从而进行针对性的优化。
• 定期进行性能调优：使用性能分析工具（如JProfiler、YourKit等）进行详细的性能分析和调优。

通过以上方法，可以有效减少Full GC的频率，提高应用程序的性能和稳定性。

6. 大对象容易直接进入老年代？

在Java虚拟机（JVM）中，大对象容易直接进入老年代（Tenured Generation），这是由JVM的内存分配策略和垃圾回收机制决定的。

1. 大对象的定义

在JVM中，大对象通常是指那些占用较大内存空间的对象。具体大小取决于虚拟机的设置，可以通过参数-XX:PretenureSizeThreshold来定义。例如：

• 如果设置-XX:PretenureSizeThreshold=32m，那么大于32MB的对象会被视为大对象。
• 如果没有设置此参数，JVM会根据堆内存大小动态决定大对象的阈值。

2. 大对象直接进入老年代的原因

（1）新生代的内存限制

新生代（Young Generation）通常被设计为快速回收短生命周期对象，其内存空间相对较小。如果一个对象的大小超过了新生代的Eden区或Survivor区的容量，那么它无法在新生代中分配内存，只能直接分配到老年代。

（2）避免频繁的Minor GC

如果大对象被分配到新生代，它可能会迅速填满Eden区，从而触发频繁的Minor GC。为了避免这种情况，JVM会直接将大对象分配到老年代，这样可以减少新生代的内存压力，避免频繁的Minor GC。

（3）内存分配策略

JVM的内存分配策略会根据对象的大小来决定其分配位置：

• 小对象：通常分配在新生代的Eden区。
• 大对象：直接分配到老年代，以避免对新生代的频繁干扰。

3. 大对象对Full GC的影响

大对象直接进入老年代会增加老年代的内存占用。如果老年代的内存空间不足，就会触发Full GC（或Major GC）来清理老年代的内存。由于老年代的垃圾回收算法（如标记-压缩算法）通常比新生代的复制算法更复杂，停顿时间也更长，因此大对象的存在会增加Full GC的频率和停顿时间。

4. 如何减少大对象的影响

（1）避免创建大对象

• 尽量减少大对象的创建。如果可能，将大对象拆分为多个小对象，以避免它们直接进入老年代。
• 例如，对于大数组或大集合，可以考虑使用分块的方式存储数据。

（2）调整内存分配策略

• 如果应用程序中不可避免地需要创建大对象，可以通过调整JVM参数来优化内存分配策略：
  • -XX:PretenureSizeThreshold：设置大对象的阈值。如果对象大小超过此阈值，将直接分配到老年代。
  • -XX:MaxDirectMemorySize：设置直接内存的最大值，避免大对象占用过多直接内存。
  • -XX:GCTimeRatio：调整GC时间与应用程序运行时间的比例，优化GC性能。

（3）使用对象池

• 对于频繁使用的大型对象，可以使用对象池来复用对象，避免频繁创建和销毁大对象。

（4）监控和分析

• 使用JVM监控工具（如VisualVM、MAT、GC日志等）定期监控堆内存的使用情况，分析大对象的分配和回收情况。
• 如果发现大对象频繁触发Full GC，可以进一步优化代码或调整JVM参数。

5. 总结

大对象容易直接进入老年代，是因为新生代的内存空间有限，无法容纳大对象，同时为了避免频繁的Minor GC，JVM会将大对象直接分配到老年代。这种机制虽然可以减少新生代的内存压力，但会增加老年代的内存占用，进而增加Full GC的频率和停顿时间。因此，优化大对象的创建和管理是减少Full GC的关键措施之一。

九. 垃圾回收调优

1. 确定调优目标

1. 低延迟：尽量减少垃圾回收过程中对应用程序的暂停时间（Stop-The-World，STW）。停顿时间过长会导致用户体验下降，尤其是在交互式应用（如Web服务器、实时系统等）中。
2. 高吞吐量：在单位时间内完成更多的垃圾回收任务，从而提高应用程序的整体性能。高吞吐量意味着应用程序可以更快地释放无用内存，减少内存泄漏的风险。
3. 平衡延迟和吞吐量：在延迟和吞吐量之间找到平衡，适合大多数应用。
4. 减少内存占用：优化内存使用，避免不必要的内存浪费。

2. 选择合适的垃圾回收器

1. 低延迟需求：

1. ZGC：几乎全并发，停顿时间极短（通常低于10ms），适合超大内存（16TB）。
2. Shenandoah GC：并发压缩，停顿时间在10ms_{100ms之间，适合中大型内存（1GB}10TB）。
3. G1 GC：分区回收，停顿时间可配置（通过-XX:MaxGCPauseMillis），适合大内存（4GB~16TB）。

2. 高吞吐量需求：

1. Parallel GC：多线程回收，适合多核CPU和高吞吐量需求。
2. G1 GC：分区回收，兼顾吞吐量和延迟。

3. 平衡延迟和吞吐量：

1. G1 GC：分区回收，通过参数调整平衡延迟和吞吐量。
2. Shenandoah GC：并发压缩，适合中大型内存应用。

3. 监控垃圾回收性能

使用命令行工具（如jstat、jcmd）或可视化工具（如VisualVM、JProfiler）监控垃圾回收的性能指标，如停顿时间、吞吐量、内存使用情况等。

1. jstat：监控JVM的内存使用和垃圾回收情况。例如，jstat -gc 1000每秒输出一次垃圾回收的统计信息。
2. jcmd：发送命令到JVM，如jcmd GC.run强制触发垃圾回收。
3. VisualVM：可视化监控工具，支持内存分析、线程监控等。可以实时查看垃圾回收的频率、停顿时间、内存使用情况等。
4. JProfiler：专业的性能分析工具，用于深入分析JVM性能，支持垃圾回收分析、内存泄漏检测等。
   

4. 分析垃圾回收日志

启用垃圾回收日志（通过-XX:+PrintGCDetails、-Xlog:gc*等参数），分析日志中的信息，了解垃圾回收的频率、耗时、内存回收情况等。

日志中常见的信息包括：

1. GC类型：如[GC pause (G1 Evacuation Pause)表示G1 GC的垃圾回收。
2. 停顿时间：如[0.001s]表示垃圾回收的停顿时间。
3. 内存回收情况：如[Eden: 768.0M(768.0M)->0.0B(768.0M) Survivor: 128.0M->128.0M Heap: 1.0G(1.0G)->1.0G(1.0G)]表示Eden区和Survivor区的内存回收情况。

5. 调整垃圾回收参数

根据监控和分析结果，调整垃圾回收器的参数，如堆内存大小（-Xms、-Xmx）、新生代大小（-Xmn）、垃圾回收线程数（-XX:ParallelGCThreads、-XX:ConcGCThreads）等

1. 调整堆内存大小

1. 初始堆大小（-Xms）和最大堆大小（-Xmx）：

1. 建议将初始堆大小和最大堆大小设置为相同值，避免堆动态扩展。
2. 根据应用需求和服务器资源，合理设置堆大小。例如，对于中等规模的应用，可以设置为-Xms4G -Xmx4G。

2. 新生代大小（-Xmn）：

1. 新生代的大小影响垃圾回收的频率和效率。建议设置为堆内存的1/3~1/4。例如，对于4GB的堆内存，可以设置为-Xmn1G。

3. Eden区和Survivor区的比例（-XX:SurvivorRatio）：

1. 默认值为8，表示每个Survivor区占新生代的1/10。可以根据应用特点调整该比例。例如，对于短生命周期对象较多的应用，可以适当减小-XX:SurvivorRatio。

2. 垃圾回收线程数（-XX:ParallelGCThreads、-XX:ConcGCThreads）：

1. 并行垃圾回收器（如Parallel GC、G1 GC）

1. 线程数默认值为CPU核心数的一半。可以根据服务器的CPU核心数和应用需求进行调整。例如，对于16核CPU，可以设置为-XX:ParallelGCThreads=8。

2. 并发垃圾回收器（如G1 GC、ZGC、Shenandoah GC）

并发线程数默认值为CPU核心数的1/4。根据应用需求调整该参数。例如，对于16核CPU，可以设置为-XX:ConcGCThreads=4。

6. 验证调优效果

通过压力测试（如使用JMeter、Gatling等工具）验证调优后的性能是否符合预期。如果不符合，继续调整参数并验证。

十. JVM调优

1. JVM调优的主要目标

1. 优化内存使用

1. 合理设置堆内存大小（-Xms 和 -Xmx），避免内存不足或浪费。
2. 调整新生代和老年代的比例（-Xmn、-XX:NewSize、-XX:MaxNewSize），优化内存分配。
3. 管理类元数据区（-XX:MetaspaceSize 和 -XX:MaxMetaspaceSize），避免元数据区溢出。

2. 优化垃圾回收

1. 选择合适的垃圾回收器（如G1、ZGC等），根据应用需求平衡延迟和吞吐量。
2. 调整GC参数（如-XX:MaxGCPauseMillis、-XX:GCTimeRatio），减少GC停顿时间。
3. 分析GC日志，了解垃圾回收的频率和耗时，根据分析结果调整策略。

3. 优化线程管理

1. 合理配置线程池大小，避免线程过多导致上下文切换频繁。
2. 使用线程优先级，确保关键任务优先执行。

4. 避免内存泄漏

1. 定期进行内存分析，使用工具（如jmap、MAT）查找内存泄漏。
2. 注意常见的内存泄漏场景，如静态集合、监听器未解除、线程池未关闭等。
3. 遵循良好的编码规范，及时释放资源，避免过长的对象生命周期。

2. 常用的JVM调优工具

1. 命令行工具

1. jps：查看正在运行的Java进程。
2. jstack：查看线程堆栈信息，用于检测线程死锁。
3. jmap：生成堆转储快照，用于分析内存使用情况。
4. jstat：监控JVM的内存使用和垃圾回收情况。

2. 可视化工具

1. jconsole：监控JVM的内存、线程、类加载等信息。
2. VisualVM：功能更强大的监控工具，支持内存分析、线程监控等。
3. JProfiler：专业的性能分析工具，用于深入分析JVM性能。

3. JVM调优的最佳实践

1. 合理设置堆大小

1. 根据应用需求和服务器资源，设置合适的初始堆大小和最大堆大小。
2. 建议将初始堆大小和最大堆大小设置为相同值，避免堆动态扩展。
3. 确保堆内存大小不超过物理内存的80%，为操作系统和其他应用留出空间。

2. 避免内存泄漏

1. 定期进行内存分析，及时发现和修复内存泄漏。
2. 遵循良好的编码规范，避免常见的内存泄漏场景。

3. 监控和调整

1. 使用监控工具（如jstat、VisualVM）实时监控JVM性能。
2. 根据监控结果和应用需求，持续调整JVM参数。

4. 内存泄露的场景以及解决方案

1. 静态集合类

1. 问题：静态集合（如HashMap、ArrayList）中存储大量对象，且未适时移除。
2. 解决方案：定期清理集合中的对象，避免不必要的内存占用。

2. 监听器和回调

1. 问题：对象注册了监听器或回调，但未解除注册。
2. 解决方案：在对象不再需要时，解除监听器和回调的注册。

3. ThreadLocal

1. 问题：线程结束后未清理ThreadLocal变量。
2. 解决方案：在使用完ThreadLocal变量后，手动清除其值。

4.总结

JVM调优是一个持续的过程，需要根据应用的实际运行情况进行动态调整。合理利用监控工具和调优策略，可以有效提升Java应用的性能和稳定性。