1请介绍一下JVM的主要组成部分及其作用

1.1背记

• 类加载器（Class Loader）：将*.class字节码文件加载到内存中
• 执行引擎（Execution Engine）：也叫解释器，负责解释命令，就是将字节码指令解释/编译为当前所在平台上的本地机器指令
• 本地接口（Native Interface）：本地接口的作用是融合不同的语言为Java所用
• 栈（Stack）：过去叫Java栈内存，现在叫虚拟机栈，Java程序中方法执行时使用的内存空间，用于存储局部变量表、操作栈、动态链接(即引

• 堆（Heap）：存放实例对象
• 方法区（Method Area）：它用于存储已被虚拟机加载的类的信息、常量、静态变量、即时编译器编译后的代码缓存等
• 程序计数器（PC Register）：每个线程都有一个程序计数器，就是一个指针，指向方法区中的方法字节码

1.2理解

1.2.1栈空间

1.2.2堆空间

• 永久区（即存储的是运行环境必须的类信息，被装载至此区域的数据是不会被垃圾回收掉的，只有关闭JVM释放此区域所占用的内存）
• 新生区
• 老年代

1.2.3方法区

1.2.4程序计数器

2说一下JVM运行时数据区？

2.1背记

• 程序计数器（Program Counter Register）
• Java 虚拟机栈（Java Virtual Machine Stacks）
• 本地方法栈（Native Method Stack）
• Java 堆（Java Heap）
• 方法区（Methed Area）

2.2理解

• 程序计数器：当前线程所执行的字节码的行号指示器，字节码解析器的工作是通过改变这个计数器的值，来选取下一条需要执行的字节码指令，分支、循环、跳转、异常处理、线程恢复等基础功能，都需要依赖这个计数器来完成；
• Java 虚拟机栈：用于存储局部变量表、操作数栈、动态链接、方法出口等信息
• 本地方法栈：与虚拟机栈的作用是一样的，只不过虚拟机栈是服务Java方法的，而本地方法栈是为虚拟机调用Native方法服务的
• Java 堆：Java虚拟机中内存最大的一块，是被所有线程共享的，存放对象实例
• 方法区：用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译后的代码等数据

3什么是类加载器？

3.1背记

• JDK8
  • 启动类加载器
  • 扩展类加载器
  • 应用类加载器
  • 用户自定义类加载器
• JDK9
  • 启动类加载器
  • 平台类加载器
  • 应用类加载器
  • 用户自定义类加载器

3.2理解

3.3JDK1.8的类加载器

3.3.1启动类加载器（Bootstrap）C++

3.3.2扩展类加载器（Extension）Java

3.3.3应用程序类加载器（AppClassLoader）

3.3.4用户自定义加载器

3.4JDK9的类加载器

• 应用类加载器的父加载器是：PlatformClassLoader
• PlatformClassLoader的父加载器是：启动类加载器

JDK 9 中的 PlatformClassLoader 和之前 JDK 版本中的 ExtClassLoader 具有相似的功能，但在一些细节上有所不同。

1. 命名和位置：ExtClassLoader 是 JDK 8 及之前版本中定义的扩展类加载器，而 PlatformClassLoader 是从 JDK 9 开始引入的。它们的命名和位置略有不同，但都属于应用程序类加载器的子类。
2. 类加载范围：ExtClassLoader 主要用于加载 Java 扩展库（Java Extension），即位于 JRE 的 "lib/ext" 目录下的 JAR 文件。而 PlatformClassLoader 主要用于加载模块化平台的类，包括 Java SE 平台的核心类和模块。
3. 模块化支持：PlatformClassLoader 是在 JDK 9 引入的模块化系统中新增的类加载器，它与 Java 平台模块系统（JPMS）紧密集成。PlatformClassLoader 被设计为按模块进行类加载，可以加载模块路径上的模块，并且具有更灵活的类路径处理能力。

4请谈谈你对双亲委派机制的理解

4.1背记

4.2理解

4.2.1总体说明

• 一个类加载器收到了加载某个类的请求
• 先看是否曾经加载过如果曾经加载过就直接返回，因为方法区里面已经有了
• 如果没有加载过，该类加载器并不会去加载该类，而是把这个请求委派给父类加载器
• 每一个层次的类加载器都是如此，因此所有的类加载请求最终都会传送到顶端的启动类加载器
• 只有当父类加载器在其搜索范围内无法找到所需的类，并将该结果反馈给子类加载器，子类加载器会尝试去自己加载

4.2.2举例说明

• 应用类加载器：判断之前是否加载过这个类，如果加载过则返回，如果没有加载过，则会向上委托给扩展类加载器；
• 扩展类加载器：判断之前是否加载过这个类，如果加载过则返回，如果没有加载过，则继续向上委托给引导类加载器；
• 引导类加载器：判断之前是否加载过这个类，如果加载过则返回，如果没有加载过，则到 jre/lib 目录下去查询是否有这个类，如果找不到则把任务返还给扩展类加载器；
• 扩展类加载器：到 jre/lib/ext 目录下去查询是否有这个类，如果有这个类则加载，如果没有这个类就向下回传给应用类加载器；
• 应用类加载器：到项目的类路径下（classPath）下去查询是否有这个类，如果有这个类则加载，如果没有这个类就会抛出经典的 ClassNotFoundException。

5请描述一下类加载的执行过程

5.1背记

• 加载：根据查找路径找到相应的class文件然后导入
• 验证：检查加载的 class 文件的正确性
• 准备：给类中的静态变量分配内存空间
• 解析：虚拟机将常量池中的符号引用替换成直接引用的过程
• 初始化：对静态变量和静态代码块执行初始化工作

5.2理解

• 加载：首先，类加载器会从指定的路径或URL中读取类的字节码文件（.class文件），并将其加载到内存中。这个过程涉及到文件I/O操作和字节码解析。
• 验证：在加载过程中，类加载器会对字节码进行验证，确保其符合Java虚拟机规范的要求。这包括检查字节码的格式、语义和安全性等方面。
• 准备：在这个阶段，类加载器会为类的静态变量分配内存空间，并设置默认值。这些静态变量包括基本数据类型（如int、float等）和引用类型（如对象引用）。
• 解析：在这个阶段，类加载器会将符号引用转换为直接引用。符号引用是指以字符串形式表示的类、字段和方法的引用，而直接引用则是指向内存中实际对象的指针。解析过程涉及到常量池的解析和动态链接。
• 初始化：在这个阶段，类加载器会执行类的静态代码块和静态变量的初始化操作。这是类加载的最后一步，也是类被完全加载的标志。

6Java中都有哪些引用类型？

6.1背记

• 强引用：只要引用指针还在，那么发生GC的时候就不会被回收
• 软引用：有用但不是必须的对象，在发生内存空间不够会被回收
• 弱引用：有用但不是必须的对象，只要遇到GC就会被回收，哪怕弱引用指针还在
• 虚引用（幽灵引用/幻影引用）：无法通过虚引用获得对象，用PhantomReference实现虚引用，虚引用的用途是在GC时返回一个通知——临死之前收到一个通知

6.2强引用

Object o = new Object();

6.3软引用

• 引用强度：软引用比弱引用稍强一些，但在所有引用类型中仍然属于较弱的一类。
• 垃圾回收：当JVM进行垃圾回收时，如果发现一个对象只被软引用所引用，并且内存不足时，才会回收这个对象。如果内存足够，则不会回收。
• 应用场景：通常用于实现缓存机制，例如缓存数据可以使用软引用来存储，当内存不足时，这些缓存数据会被自动回收，从而避免内存溢出。
• 使用方式：通过 java.lang.ref.SoftReference 类来创建软引用。

import java.lang.ref.SoftReference;

public class SoftReferenceExample {
    public static void main(String[] args) {
        // 创建一个对象
        Object obj = new Object();
        
        // 创建软引用
        SoftReference<Object> softRef = new SoftReference<>(obj);
        
        // 清除强引用
        obj = null;
        
        // 打印软引用的内容
        System.out.println("软引用对象: " + softRef.get());
        
        // 强制垃圾回收
        System.gc();
        
        // 再次打印软引用的内容
        System.out.println("垃圾回收后软引用对象: " + softRef.get());
        
        // 模拟内存不足的情况
        try {
            byte[] bytes = new byte[1024 * 1024 * 10]; // 分配10MB的内存
        } catch (OutOfMemoryError e) {
            System.out.println("内存不足");
        }
        
        // 再次打印软引用的内容
        System.out.println("内存不足后软引用对象: " + softRef.get());
    }
}

6.4弱引用

• 引用强度：弱引用是四种引用类型（强引用、软引用、弱引用、虚引用）中最弱的一种。
• 垃圾回收：当JVM进行垃圾回收时，如果发现一个对象只被弱引用所引用，那么无论当前内存是否足够，都会回收这个对象。
• 应用场景：通常用于实现缓存机制，例如缓存数据可以使用弱引用来存储，当内存不足时，这些缓存数据会被自动回收，从而避免内存溢出。
• 使用方式：通过 java.lang.ref.WeakReference 类来创建弱引用。

import java.lang.ref.WeakReference;

public class WeakReferenceExample {
    public static void main(String[] args) {
        // 创建一个对象
        Object obj = new Object();
        
        // 创建弱引用
        WeakReference<Object> weakRef = new WeakReference<>(obj);
        
        // 清除强引用
        obj = null;
        
        // 打印弱引用的内容
        System.out.println("弱引用对象: " + weakRef.get());
        
        // 强制垃圾回收
        System.gc();
        
        // 再次打印弱引用的内容
        System.out.println("垃圾回收后弱引用对象: " + weakRef.get());
    }
}

6.5虚引用

• 引用强度：虚引用是最弱的一种引用类型，甚至比弱引用和软引用还要弱。
• 垃圾回收：当一个对象仅持有虚引用时，它可以在任何时候被垃圾回收器回收。虚引用不能防止对象被回收，也不能通过虚引用来获取对象。
• 应用场景：虚引用主要用于在对象被垃圾回收时得到一个系统通知，常用于资源清理或执行其他清理操作。
• 使用方式：通过 java.lang.ref.PhantomReference 类来创建虚引用，并且通常需要与 ReferenceQueue 一起使用。

import java.lang.ref.PhantomReference;
import java.lang.ref.ReferenceQueue;

public class PhantomReferenceExample {
    public static void main(String[] args) {
        // 创建一个对象
        Object obj = new Object();
        
        // 创建引用队列
        ReferenceQueue<Object> queue = new ReferenceQueue<>();
        
        // 创建虚引用
        PhantomReference<Object> phantomRef = new PhantomReference<>(obj, queue);
        
        // 清除强引用
        obj = null;
        
        // 打印虚引用的内容
        System.out.println("虚引用对象: " + phantomRef.get()); // 输出 null
        
        // 强制垃圾回收
        System.gc();
        
        // 等待垃圾回收器将虚引用加入引用队列
        try {
            PhantomReference<Object> ref = (PhantomReference<Object>) queue.remove();
            System.out.println("对象被垃圾回收，虚引用已加入引用队列");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

• 最弱引用：虚引用是最弱的一种引用类型，不能防止对象被回收。
• 通知机制：虚引用主要用于在对象被垃圾回收时得到一个系统通知。
• 配合引用队列：通常需要与 ReferenceQueue 一起使用，以便在对象被回收时进行相应的处理。

7怎么判断对象是否可以被回收？

7.1核心思想

7.2基于不同引用类型分析

• 强引用：只要引用对象的强引用指针还在，那么就不能回收
• 软引用：当一个对象仅持有软引用时，如果GC是由于堆内存空间不足而触发的，那么即使软引用指针还在也会回收对象
• 弱引用：当一个对象仅持有弱引用时，不管GC是由于什么原因触发，这个对象都会被回收
• 虚引用：当一个对象仅持有虚引用时，它可以在任何时候被垃圾回收器回收。虚引用不能防止对象被回收，也不能通过虚引用来获取对象
• 无引用：当一个对象没有任何类型的指针指向它，那么它在GC中一定会被回收

8为什么不能使用引用计数法查找垃圾对象？

8.1引用计数法的概念

8.2引用计数法的缺陷

• 对象A引用计数器值：1
• 对象B引用计数器值：1

9开发中是否可以避免出现对象的循环引用？

9.1结论

9.2举例

9.2.1实体类之间的关联关系

public class Order {
    private Customer customer;
}
 订单实体

public class Customer {
    private List<Order> orderList;
} 客户实体

9.2.2框架源码

• IOC容器初始化完成之后，IOC容器对象会存入ServletContext域
• 为了获取ServletContext对象方便，ServletContext对象会被存入IOC容器

9.2.3结论

10哪些对象可以作为GC-Roots？

10.1背记

• 虚拟机栈（栈帧中的本地变量表）中的引用对象
• 方法区中的类静态属性引用的对象
• 方法区中的常量引用的对象
• 本地方法栈中JNI（Native方法）的引用对象

10.2理解

10.2.1虚拟机栈中的对象

public void test() {
    Object obj = new Object(); // obj是GC Roots
}

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

public class TestClass {
    private static Object obj = new Object(); // obj是GC Roots
}

10.2.3方法区中的常量引用的对象

public class TestClass {
    private static final Object obj = new Object(); // obj是GC Roots
}

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

public class TestClass {
    private native void nativeMethod(); // nativeMethod是本地方法
}

10.3小技巧

11说一下JVM有哪些垃圾回收算法？

11.1背记

• 标记复制算法
• 标记清除算法
• 标记整理算法
• 分代算法

11.2理解

11.2.1标记复制算法

11.2.1.1执行GC前

11.2.1.2执行标记

11.2.1.3执行复制

11.2.1.4交换指针

11.2.2标记清除算法

• 使用GC Roots可达性分析算法把不可达的对象标记出来
• 回收被标记的对象

11.2.3标记整理算法

11.2.4分代算法

12JVM有哪些垃圾回收器？

12.1背记

• 串行：Serial、Serial Old
• 并行：ParNew、Parallel、Parallel Old
• 并发：CMS、G1

12.2理解

12.2.1Serial收集器

12.2.2Parallel收集器

12.2.3CMS（Concurrent Mark Sweep）收集器

12.2.4G1（Garbage-First）收集器

13详细介绍一下CMS垃圾回收器？

13.1背记

• 初始标记（CMS initial mark）
• 并发标记（CMS concurrent mark）
• 重新标记（CMS remark）
• 并发清理（CMS concurrent sweep）

13.2理解

• 初始标记（CMS initial mark）
• 并发标记（CMS concurrent mark）
• 重新标记（CMS remark）
• 并发清理（CMS concurrent sweep）

• 对CPU资源敏感（会和服务抢资源，降低吞吐量）；当然，这是所有并发收集器的缺点
• 无法处理浮动垃圾（在并发标记和并发清理阶段又产生垃圾，这种浮动垃圾在本次收集中无法干掉他们，只能等到下一次GC再清理了，这一部分垃圾成为浮动垃圾）；
• 它使用的回收算法-“标记-清除”算法会导致收集结束时有大量空间碎片产生

14新生代垃圾回收器和老年代垃圾回收器都有哪些？有什么区别？

14.1背记

14.1.1名称列表

• 新生代回收器：Serial、ParNew、Parallel Scavenge
• 老年代回收器：Serial Old、Parallel Old、CMS整堆回收器

14.1.2区别

14.1.2.1应用场景

• 新生代通常采用复制算法，因为大部分新生成的对象会很快变得不可达，所以复制算法可以高效地处理这些朝生夕死的对象。
• 老年代则使用标记-清除或标记-整理算法，这些算法适用于处理长期存活的对象，可以减少内存碎片并提高内存利用率。

14.1.2.2内存分配和管理策略

• 新生代与老年代的比例默认为1:2，新生代又可细分为Eden、From Survivor、To Survivor三个区。
• 老年代中的对象通常占用较大的内存空间，因此需要能够有效地管理这些对象的内存分配和回收。

14.1.2.3设计目标

• 新生代垃圾回收器的设计目标是优化垃圾回收的性能，因为大多数新创建的对象会很快变得不可达。
• 老年代垃圾回收器的设计目标是处理长时间存活的对象，这些对象通常占用较大的内存空间。

14.2理解

14.2.1设计目标

• 新生代垃圾回收器的设计目标是优化垃圾回收的性能，因为大多数新创建的对象会很快变得不可达，所以新生代的回收器需要快速处理这些短生命周期的对象。
• 老年代垃圾回收器的设计目标是处理长时间存活的对象，这些对象通常占用较大的内存空间，因此老年代的回收器需要能够有效地管理这些对象的内存分配和回收。

14.2.2适用的回收算法

• 新生代通常使用复制（Copy）算法，这种算法适用于快速回收大量短期对象，但可能会导致内存利用率降低。
• 老年代通常使用标记-清除（Mark-Sweep）或标记-整理（Mark-Compact）算法，这些算法适用于处理长期存活的对象，可以减少内存碎片并提高内存利用率。

14.2.3垃圾回收器的选择：

• 新生代可以使用的垃圾回收器包括Serial、ParNew和Parallel Scavenge，这些回收器专注于快速清理新生代中的短期对象。
• 老年代可以使用的垃圾回收器包括Serial Old、CMS和Parallel Old，这些回收器专注于长期存活对象的内存管理。

14.2.4内存管理策略

• 在执行Minor GC之前，JVM会检查老年代的可用内存空间，确保有足够的空间容纳新生代中存活下来的对象，以避免内存溢出。
• 新生代和老年代的内存比例会根据应用程序的需求进行调整，以平衡垃圾回收的效率和内存的使用效率。

15简述分代垃圾回收器是怎么工作的？

15.1背记

• 把 Eden + From Survivor 存活的对象放入 To Survivor 区；
• 清空 Eden 和 From Survivor 分区；
• From Survivor 和 To Survivor 分区交换，From Survivor 变 To Survivor，To Survivor 变 From Survivor
• 每次在 From Survivor 到 To Survivor 移动时都存活的对象，年龄就 +1，当年龄到达 15（默认配置是15）时，升级为老年代。
• 大对象也会直接进入老年代。

15.2理解

1. 新生代：用于存放刚创建的对象。它的回收过程通常称为Minor GC或Young GC，采用复制算法来处理新生成对象的快速回收。
2. 老年代：用于存放长时间存活的对象。当对象经过一定次数的垃圾回收后依然存活，它们将从新生代晋升到老年代。老年代的回收过程通常称为Major GC或Old GC，采用标记-清除或标记-整理算法来处理长期存活的对象。

1. 对象分配：在新生代Eden区分配新对象。
2. 第一次垃圾回收：当Eden区满时，执行Minor GC，将存活的对象复制到From Survivor区。
3. 第二次垃圾回收：当From Survivor区满时，再次执行Minor GC，将存活的对象复制到To Survivor区。
4. 晋升：重复上述过程，每次回收后，存活的对象年龄增加。当对象的年龄达到某个阈值时，它们将被移动到老年代。
5. 老年代回收：当老年代被填满，或者无法满足内存分配需求时，触发Major GC，对老年代进行垃圾回收。

16垃圾回收器的比较

17请介绍一下什么是三色标记？

17.1三色标记算法介绍

17.2颜色定义

1. 白色（White）：表示尚未访问过的对象，初始状态下所有对象都是白色的。
2. 灰色（Gray）：表示已经访问过但其引用的对象尚未全部访问的对象。灰色对象作为标记过程中的“工作队列”。
3. 黑色（Black）：表示已经完全访问过的对象，即该对象及其引用的所有对象都已经被标记为存活。

17.3标记过程

1. 初始化
   • 将所有对象标记为白色。
   • 将根对象（如全局变量、栈中的对象引用等）标记为灰色，并加入到一个工作队列中。
2. 标记阶段
   • 从工作队列中取出一个灰色对象。
   • 将该对象标记为黑色。
   • 遍历该对象引用的所有对象：
     • 如果引用的对象是白色的，将其标记为灰色并加入工作队列。
     • 如果引用的对象已经是灰色或黑色，跳过。
   • 重复上述步骤，直到工作队列为空。
3. 清理阶段
   • 所有仍标记为白色的对象被认为是垃圾，可以被回收。
   • 黑色和灰色对象被认为是存活对象，保留下来。

17.4并发标记与SATB

• 在并发标记过程中，应用程序可能继续运行并修改对象图。为了确保标记的准确性，一些垃圾回收器（如G1和Shenandoah）使用了SATB (Snapshot-At-The-Beginning) 机制。
• SATB的基本思想是在标记开始时创建一个对象图的快照，并记录所有在标记过程中发生的修改，确保所有新创建的引用都能被正确标记。

额外说明：Shenandoah使用了SATB机制，但Shenandoah没有使用三色标记算法。Shenandoah垃圾回收器采用了一种称为颜色指针的技术，而不是传统的三色标记算法。这种技术通过在对象中嵌入额外的位来表示对象的状态，从而避免了在并发环境下对对象进行多次扫描的需求。具体来说，Shenandoah使用了一种名为Brooks Forwarding Pointer的技术，它允许在对象移动时更新引用，而不需要像传统垃圾回收器那样在对象之间复制引用。

17.5优点

• 高效性: 通过分阶段处理，减少了单次垃圾回收的停顿时间。
• 并发性: 可以与应用程序并发执行，减少对应用程序性能的影响。
• 准确性: 确保所有存活对象都能被正确标记，避免内存泄漏。

17.6缺点

• 复杂性: 实现并发标记和SATB机制增加了垃圾回收器的复杂性。
• 开销: 记录和处理并发修改会带来一定的额外开销。

17.7应用实例

• CMS（Concurrent Mark and Sweep）使用三色标记进行并发标记，减少停顿时间。
• G1（Garbage-First Garbage Collector）结合SATB机制，实现高效的并发标记。
• ZGC（Z Garbage Collector）利用读屏障和染色标记技术，实现低延迟的垃圾回收。这种染色标记技术是基于三色标记算法的一种优化实现
• Shenandoah基于颜色指针技术，实现几乎没有停顿的垃圾回收。颜色指针技术可以看做三色标记技术的优化、改进，但从最终形态来说颜色指针和三色标记已经相差很大了

18说说三色标记法工作过程中的多标问题

18.1多标的产生

18.2多标的危害

19说说三色标记法工作过程中的漏标问题

19.1漏标的产生

• D如果被灰色对象引用，那么在未来将会被扫描到（灰色表示该对象引用的对象尚未扫描完成）
• D如果被黑色对象引用，那么在未来讲不会被扫描到（黑色表示该对象引用的对象全部扫描完成了——但此时事实并非如此）

19.2漏标的危害

所以个人感觉“漏标”这个名字改成“误标”或“错标”或许会更好理解

19.3漏标的解决方案

19.3.1问题的本质

• 条件一：灰对象断开了一个连接到白对象的引用
• 条件二：黑对象引用了一个白对象，黑对象本身不会被再次检测，而白对象最终会被当做垃圾清理

19.3.2CMS解决方案：写屏障+增量更新（Incremental Update）

// 在写操作后执行
void post_write_barrier(oop* field, oop new_value) {
    remark_set.add(new_value); // 记录新引用的对象
}
 写屏障代码参考

19.3.3G1解决方案：写屏障+原始快照（SATB）

19.3.3.1方案执行流程

// 在写操作前执行（这里的写操作就是B对D断开引用）
void pre_write_barrier(oop* field) {
    oop old_value = *field; // 获取旧值
    remark_set.add(old_value); // 记录原来的引用对象
}
 写屏障代码参考

19.3.3.2方案存在的问题

20JVM常用的调优工具有哪些？

20.1背记

• JConsole：用于对JVM中的内存、线程和类等进行监控
• JVisualVM：JDK自带的全能分析工具，可以分析内存快照、线程快照、程序死锁、监控内存的变化、GC变化等

20.2理解

20.2.1JConsole

1. 监控本地或远程JVM：JConsole可以监控本地运行的Java应用程序，同时也可以连接到远程服务器上的Java应用程序进行监控。
2. MBean的管理：它提供了基于JMX（Java Management Extensions）的接口，允许用户查看和管理MBean，这是Java平台的一种资源管理机制。
3. 性能监控：通过JConsole，用户可以实时查看Java应用程序的内存使用情况、线程状态、类加载情况以及CPU使用率等信息。

20.2.2JVisualVM

1. 强大的分析功能：JVisualVM不仅可以进行监控，还能进行深入的性能分析，如堆内存溢出分析、虚拟机栈溢出分析和线程死锁检测等。
2. 插件支持：JVisualVM支持多种插件，这些插件可以提供更多的功能，如监控特定的应用服务器或框架。
3. 图形化界面：JVisualVM提供了一个直观的用户界面，使得查看和分析数据更加方便。

21常用的JVM调优的参数都有哪些？

21.1堆内存调优

21.2垃圾回收调优

21.3线程调优

21.4日志设置

22System.gc()能保证执行GC执行吗？

22.1背记

22.2理解

22.2.1System.gc()的作用

22.2.2垃圾回收的触发条件

22.2.3垃圾回收的不确定性

22.2.4JVM实现者的角色

23怎么获取Java程序使用的内存？堆使用的百分比？

1. 使用JVM内置工具：
   • jstat：这是一个命令行工具，可以用来监控JVM的各种性能指标，包括堆内存的使用情况。例如，运行jstat -gc <pid>可以查看指定进程的垃圾回收统计信息，其中包含了堆内存的使用情况。
   • jmap：这个工具可以用来生成堆转储快照（heap dump），或者查询堆的详细信息。例如，运行jmap -heap <pid>可以查看堆的配置和使用情况。
2. 使用Java代码：
   • 可以通过Runtime类来获取当前JVM的内存使用情况。例如：
     Runtime runtime = Runtime.getRuntime();
     
     long totalMemory = runtime.totalMemory(); // JVM总内存
     
     long freeMemory = runtime.freeMemory(); // JVM空闲内存
     
     long usedMemory = totalMemory - freeMemory; // 已使用的内存
     
     double usagePercentage = (double) usedMemory / totalMemory * 100; // 使用百分比

3. 使用第三方库：
   • 可以使用如SIGAR、OSHI等第三方库来获取系统和JVM的详细性能指标。这些库通常提供了更丰富的API来监控系统资源。
4. 使用JMX（Java Management Extensions）：
   • JMX是Java平台的一部分，用于管理和监控应用程序、系统对象、设备等。通过JMX，你可以连接到正在运行的JVM并查询各种管理数据，包括内存使用情况。可以使用JConsole或VisualVM这样的工具来访问JMX MBeans。
5. 集成到应用中：
   • 如果你的应用是一个Web应用，许多应用服务器（如Tomcat, Jetty等）都提供了监控和管理功能，包括内存使用情况。