初始JVM ! ! ! 相信我，中国人不骗中国人，这一篇也就入门了！！！

1.JVM到底是什么？

2.JVM的三大核心是什么？

1. 解释和运行

2. 内存管理

3. 即时编译（JIT）

3.常见的Jvm虚拟机有哪些？

1.3.1 Java虚拟机规范

1.3.2 Java虚拟机规范

4. JVM的组成

4.1、类的生命周期

4.1.1 加载阶段

4.1.2 连接阶段

4.1.3 初始化阶段

4.2、类加载器·

4.2.1 什么是类加载器

4.2.2类加载器的分类

JDK8及之前的类加载器

JDK9之后的类加载器

综上整理如下：

1. 启动类加载器（Bootstrap ClassLoader）

2. 扩展类加载器（Extension ClassLoader）

3. 系统类加载器（System ClassLoader 或 Application ClassLoader）

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

4.2.3、双亲委派机制

双亲委派机制的作用

4.2.4 、打破双亲委派机制

4.3、运行时数据区

1. 程序计数器（Program Counter Register）

2. Java虚拟机栈（Java Virtual Machine Stack）

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

4. 方法区（Method Area）

5. 堆（Heap）

静态变量存储在哪里呢？

6 直接内存

4.4、垃圾回收

4.4.1 方法区的回收

4.4.2 堆回收

4.4.2.1 如何判断对象可以回收

引用计数法

可达性分析法

4.4.2.2 常见的引用对象

1. 软引用（Soft Reference）

2. 弱引用（Weak Reference）

3. 虚引用（Phantom Reference）

4. 终结器引用（Finalizer Reference）

4.4.2.3 垃圾回收算法

垃圾回收算法的历史和分类

垃圾回收算法的评价标准

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

复制算法（Copying Algorithm）

标记整理算法（Mark-Compact Algorithm）

分代垃圾回收算法（Generational Garbage Collection）

4.4.2.4 垃圾回收器

年轻代-Serial垃圾回收器

老年代-SerialOld垃圾回收器

年轻代-ParNew垃圾回收器

老年代- CMS(Concurrent Mark Sweep)垃圾回收器

年轻代-Parallel Scavenge垃圾回收器

老年代-Parallel Old垃圾回收器

G1垃圾回收器

G1垃圾回收器-内存结构

G1垃圾回收有两种方式：

年轻代回收

混合回收

G1 – Garbage First 垃圾回收器

引言

"无论你是Java初学者，还是经验丰富的开发者，深入理解JVM都将为你的编程之路增添无限可能。从性能优化到故障排查，从内存管理到垃圾回收，JVM的知识将帮助你更好地驾驭Java应用。通过初始的学习，本人也有记录的习惯，So也花费点时间简单总结一下自己学习的记录！！！后续也会随着积累慢慢完善补充。话不多说，往下看！！！

1.JVM到底是什么？

JVM（Java Virtual Machine，Java虚拟机）是运行我们写的源程序编译后的Java字节码的虚拟计算机。它是一种规范，描述了Java程序如何被加载、验证、执行、优化和垃圾收集。JVM可以在不同的平台上（如Windows、Linux、macOS等）运行，只要该平台安装了对应的JVM实现，就能保证Java程序“一次编写，到处运行”（Write Once, Run Anywhere, WORA）的特性。

2.JVM的三大核心是什么？

1. 解释和运行

功能作用：

解释执行： JVM的主要功能之一是解释执行Java字节码（.class文件）。当Java程序被编译成字节码后，JVM负责读取这些字节码，并逐条解释执行它们。这种机制使得Java程序具有“一次编写，到处运行”（Write Once, Run Anywhere, WORA）的特性，因为只要目标平台安装了JVM，Java程序就可以在该平台上运行，而无需重新编译。
提供运行环境： JVM为Java程序提供了一个独立的运行环境，它模拟了一个计算机硬件和操作系统的功能，使得Java程序能够独立于实际的硬件和操作系统执行。

2. 内存管理

功能作用：

自动内存分配与回收： JVM负责Java程序的内存管理，包括自动分配内存给对象以及自动回收不再被使用的对象所占用的内存。这种机制大大减轻了开发者手动管理内存的负担，并降低了内存泄露和内存溢出的风险。
内存区域划分： JVM将内存划分为不同的区域，如堆（Heap）、栈（Stack）、方法区（Method Area）等，每个区域都有其特定的用途和管理策略。例如，堆是存储对象实例的主要区域，而栈则用于存储局部变量和方法的调用状态。
垃圾回收机制： JVM通过垃圾回收器（Garbage Collector）来自动回收不再被引用的对象所占用的内存。垃圾回收器有多种实现算法，如标记-清除（Mark-Sweep）、复制（Copying）、标记-整理（Mark-Compact）等，它们各有优缺点，JVM可以根据实际情况选择合适的算法进行垃圾回收。

3. 即时编译（JIT）

功能作用：

提高执行效率：即时编译（Just-In-Time Compilation, JIT）是JVM的一个重要功能，它能够在程序运行时将字节码编译成目标机器的机器码，从而提高程序的执行效率。虚拟机在运行过程中如果发现某一个方法甚至是循环是热点代码（被非常高频调用），即时编译器会优化这段代码并将优化后的机器码保存在内存中，如果第二次再去执行这段代码。Java虚拟机会将机器码从内存中取出来直接进行调用。这样节省了一次解释的步骤，同时执行的是优化后的代码，效率较高。
动态优化： JIT编译器还具备动态优化的能力，它可以根据程序的运行情况动态地调整编译策略和优化参数，以进一步提高程序的性能。例如，如果某个方法被频繁调用，JIT编译器可以优先将其编译成机器码；如果某个方法的调用频率降低，JIT编译器则可以减少对其的优化力度。

3.常见的Jvm虚拟机有哪些？

1.3.1 Java虚拟机规范

《Java虚拟机规范》由Oracle制定，内容主要包含了Java虚拟机在设计和实现时需要遵守的规范，主要包含class字节码文件的定义、类和接口的加载和初始化、指令集等内容。
《Java虚拟机规范》是对虚拟机设计的要求，而不是对Java设计的要求，也就是说虚拟机可以运行在其他的语言比如Groovy、Scala生成的class字节码文件之上。
官网地址：https://docs.oracle.com/javase/specs/index.html

1.3.2 Java虚拟机规范

平时我们最常用的，就是Hotspot虚拟机。

名称	作者	支持版本	社区活跃度（github star）	特性	适用场景
HotSpot (Oracle JDK版)	Oracle	所有版本	高(闭源)	使用最广泛，稳定可靠，社区活跃JIT支持Oracle JDK默认虚拟机	默认
HotSpot (Open JDK版)	Oracle	所有版本	中(16.1k)	同上开源，Open JDK默认虚拟机	默认对JDK有二次开发需求
GraalVM	Oracle	11, 17,19企业版支持8	高（18.7k）	多语言支持高性能、JIT、AOT支持	微服务、云原生架构需要多语言混合编程
Dragonwell JDK龙井	Alibaba	标准版 8,11,17扩展版11,17	低(3.9k)	基于OpenJDK的增强高性能、bug修复、安全性提升JWarmup、ElasticHeap、Wisp特性支持	电商、物流、金融领域对性能要求比较高
Eclipse OpenJ9 (原 IBM J9)	IBM	8,11,17,19,20	低(3.1k)	高性能、可扩展JIT、AOT特性支持	微服务、云原生架构

4. JVM的组成

Java虚拟机主要分为以下几个组成部分：

类加载子系统：核心组件类加载器，负责将字节码文件中的内容加载到内存中。
运行时数据区：JVM管理的内存，创建出来的对象、类的信息等等内容都会放在这块区域中。
执行引擎：包含了即时编译器、解释器、垃圾回收器，执行引擎使用解释器将字节码指令解释成机器码，使用即时编译器优化性能，使用垃圾回收器回收不再使用的对象。
本地接口：本地库接口允许Java应用程序调用本地方法（即使用C、C++等语言编写的方法），也可以通过本地方法库调用Java代码。

简单jvm的执行流程

Java虚拟机通过类加载器加载字节码文件，经过链接和初始化后，由执行引擎中的解释器和即时编译器将字节码指令转换为机器码并执行。同时，垃圾回收器负责回收不再使用的对象，保证内存的有效利用。这一过程使得Java程序能够在各种平台上以“一次编写，到处运行”的方式执行。

其中：我们从一个源代码编译好的的字节码文件开始，当然字节码文件的来源很多种，可以是磁盘中读取，从网络上传输过来等...

当然简单描述下字节码组成部分“：

字节码文件总共可以分为以下几个部分：

基础信息：魔数、字节码文件对应的Java版本号、访问标识(public final等等)、父类和接口信息

常量池：保存了字符串常量、类或接口名、字段名，主要在字节码指令中使用

字段： 当前类或接口声明的字段信息

方法： 当前类或接口声明的方法信息，核心内容为方法的字节码指令

属性： 类的属性，比如源码的文件名、内部类的列表等

推荐使用 jclasslib工具查看字节码文件。 Github地址： https://github.com/ingokegel/jclasslib

也可以在Idea中下载插件使用安装路径

打开效果如下:

字节码中的方法区域是存放字节码指令的核心位置，字节码指令的内容存放在方法的Code属性中。

通过分析方法的字节码指令，可以清楚地了解一个方法到底是如何执行的

要理解这段字节码指令是如何执行的，我们需要先理解两块内存区域：操作数栈和局部变量表。

操作数栈: 是用来存放临时数据的内容，是一个栈式的结构，先进后出。

局部变量表: 是存放方法中的局部变量，包含方法的参数、方法中定义的局部变量，在编译期就已经可以确定方法有多少个局部变量。

如果不懂得指令的意思，可以右键jvm官网去查看有具体解析

通过指令我们可以简单知晓如何执行的步骤如下：

4.1、类的生命周期

类的生命周期描述了一个类加载、使用、卸载的整个过程。整体可以分为：

加载

连接，其中又分为验证、准备、解析三个子阶段

初始化

使用

卸载

4.1.1 加载阶段

1、加载(Loading)阶段第一步是类加载器根据类的全限定名（包名+类名）通过不同的渠道以二进制流的方式获取字节码信息，程序员可以使用Java代码拓展的不同的渠道。

从本地磁盘上获取文件

运行时通过动态代理生成，比如Spring框架

Applet技术通过网络获取字节码文件

2、类加载器在加载完类之后，Java虚拟机会将字节码中的信息保存到方法区中，方法区中生成一个InstanceKlass对象，保存类的所有信息，里边还包含实现特定功能比如多态的信息。

3、Java虚拟机同时会在堆上生成与方法区中数据类似的java.lang.Class对象，作用是在Java代码中去获取类的信息以及存储静态字段的数据（JDK8及之后）。

在堆中生成这个对象的原因是为了安全考虑，堆区中对象存储的数据是比方法区少的，堆区只存放程序员可以用到的数据。例如虚方法表，程序员不应该访问的，1.InstanceKlass对象是由c++编写的，我们java代码一般是不能去操作c++编写的对象，所以在堆中通过java来创建了一个包装的对象供我们去使用 2.出于安全起见，只复制我们需要用到的内容

4.1.2 连接阶段

连接阶段分为三个子阶段:

验证，验证内容是否满足《Java虚拟机规范》。
准备，给静态变量赋初值。
解析，将常量池中的符号引用替换成指向内存的直接引用。

4.1.3 初始化阶段

初始化阶段会先执行字节码文件中clinit（class init 类的初始化）方法的字节码指令，包含了静态代码块中的代码，并为静态变量赋值。<clinit>()方法负责执行类的静态初始化块（如果有的话）以及为静态变量赋值（即执行静态变量初始化语句）。

如下代码编译成字节码文件之后，会生成三个方法：


public class Demo1 {

    public static int value = 1;
    static {
        value = 2;
    }
   
    public static void main(String[] args) {

    }
}

具体详解参考https://lisxpq12rl7.feishu.cn/wiki/F2AFw0doOiW89Fkr8kGcCTyVnLh

4.2、类加载器·

4.2.1 什么是类加载器

类加载器（ClassLoader）是Java虚拟机提供给应用程序去实现获取类和接口字节码数据的技术，类加载器只参与加载过程中的字节码获取并加载到内存这一部分。

类加载器会通过二进制流的方式获取到字节码文件的内容，接下来将获取到的数据交给Java虚拟机，虚拟机会在方法区和堆上生成对应的对象保存字节码信息。

4.2.2类加载器的分类

类加载器分为两类，一类是Java代码中实现的，一类是Java虚拟机底层源码实现的。

虚拟机底层实现：源代码位于Java虚拟机的源码中，实现语言与虚拟机底层语言一致，比如Hotspot使用C++。主要目的是保证Java程序运行中基础类被正确地加载，比如java.lang.String，Java虚拟机需要确保其可靠性。
JDK中默认提供或者自定义：JDK中默认提供了多种处理不同渠道的类加载器，程序员也可以自己根据需求定制，使用Java语言。所有Java中实现的类加载器都需要继承ClassLoader这个抽象类。

JDK8及之前的类加载器

、类加载器的设计JDK8和8之后的版本差别较大，首先来看JDK8及之前的版本，这些版本中默认的类加载器有如下几种：

JDK8的时候一共有三种类加载器:

1)启动类加载器(Bootstrap ClassLoader), 它是属于虚拟机自身的一部分，用C++实现的(JDK9 后用java实现)，主要负责加载<JAVA_ HOME> \ib目录中或被 Xbootclasspath指定的路径中的并且文件名是被虚拟机识别的文件，它是所有类加载器的父亲。

2)扩展类加载器(Extension ClassLoader),它是Java 实现的，独立于虚拟机，主要负责加载<JAVA_ HOME>\lib\ext目录中或被java.ext.dirs系统变量所指定的路径的类库。

3)应用程序类加载器(Application ClassLoader),它是Java 实现的，独立于虚拟机。主要负责加载用户类路径(classPath). 上的类库，如果我们没有实现自定义的类加载器那这个加载器就是我们程序中的默认加载器。

JDK9之后的类加载器

JDK8及之前的版本中，扩展类加载器和应用程序类加载器的源码位于rt.jar包中的sun.misc.Launcher.java

由于JDK9引入了module的概念，类加载器在设计上发生了很多变化。

1.启动类加载器使用Java编写，位于jdk.internal.loader.ClassLoaders类中。

Java中的BootClassLoader继承自BuiltinClassLoader实现从模块中找到要加载的字节码资源文件。

启动类加载器依然无法通过java代码获取到，返回的仍然是null，保持了统一。

2、扩展类加载器被替换成了平台类加载器（Platform Class Loader）。

平台类加载器遵循模块化方式加载字节码文件，所以继承关系从URLClassLoader变成了BuiltinClassLoader，BuiltinClassLoader实现了从模块中加载字节码文件。平台类加载器的存在更多的是为了与老版本的设计方案兼容，自身没有特殊的逻辑。

及jdk9之后类加载负责模块：

综上整理如下：

1. 启动类加载器（Bootstrap ClassLoader）

实现：由C++编写，（JDK9后用java实现）是JVM的一部分，不是Java类。
功能：负责加载Java的核心类库，如java.lang.*、java.util.*等，这些类库位于$JAVA_HOME/jre/lib下的rt.jar等文件中。
特点：由于是用C++编写的，所以在Java代码中无法直接获取到它的引用，调用null.getClass().getClassLoader()等尝试获取其引用的方法都会返回null。

2. 扩展类加载器（Extension ClassLoader）

实现：在JDK 9之前，通常使用Java编写，继承自URLClassLoader。但在JDK 9及更高版本中，扩展类加载器的概念被平台类加载器（Platform ClassLoader）所取代。
功能：负责加载JDK的扩展目录（Extension Directories）中的JAR包和类库，这些目录通常由系统属性java.ext.dirs指定。
特点：在JDK 9之前，它是类加载器层次结构中的一个重要环节；在JDK 9及更高版本中，随着模块化系统的引入，其角色被平台类加载器所取代。

3. 系统类加载器（System ClassLoader 或 Application ClassLoader）

实现：使用Java编写，继承自URLClassLoader。
功能：负责加载用户类路径（Classpath）上的所有类。这是开发者最常打交道的类加载器，因为它负责加载开发者自己编写的类和第三方库中的类。
特点：它是ClassLoader.getSystemClassLoader()方法的返回值，也是双亲委派模型中默认的最终委派类加载器。

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

实现：开发者可以根据需要继承自ClassLoader类或其子类（如URLClassLoader），实现自己的类加载逻辑。
功能：加载指定路径下的类文件，或者从网络、数据库等非文件系统来源动态加载类。
特点：提供了高度的灵活性和扩展性，是Java热部署、模块化开发等高级特性的基础。

4.2.3、双亲委派机制

双亲委派机制指的是：当一个类加载器接收到加载类的任务时，会自底向上查找是否加载过，

再由顶向下进行加载。

详细流程：

每个类加载器都有一个父类加载器。父类加载器的关系如下，启动类加载器没有父类加载器：

在类加载的过程中，每个类加载器都会先检查是否已经加载了该类，如果已经加载则直接返回，否则会将加载请求委派给父类加载器。

双亲委派机制的作用

1.保证类加载的安全性。通过双亲委派机制避免恶意代码替换JDK中的核心类库，比如java.lang.String，确保核心类库的完整性和安全性。（区别在核心类库，核心类库一般是启动类加载器加载，你再写一个包名类名方法名都一样的一般是启动类加载器去加载，是没用的。避免恶意替换）

2.避免重复加载。双亲委派机制可以避免同一个类被多次加载。

问：类的双亲委派机制是什么？

答：

当一个类加载器去加载某个类的时候，会自底向上查找是否加载过，如果加载过就直接返回，如果一直到最顶层的类加载器都没有加载，再由顶向下进行加载。
应用程序类加载器的父类加载器是扩展类加载器，扩展类加载器的父类加载器是启动类加载器。
双亲委派机制的好处有两点：第一是避免恶意代码替换JDK中的核心类库，比如java.lang.String，确保核心类库的完整性和安全性。第二是避免一个类重复地被加载。

问：如果一个类重复出现在三个类加载器的加载位置，应该由谁来加载？

答：

启动类加载器加载，根据双亲委派机制，3个类位置都加载过，因为会向上查找，所以肯定到达了启动类加载器了。此时由启动类加载

4.2.4 、打破双亲委派机制

ClassLoader中包含了4个核心方法，双亲委派机制的核心代码就位于loadClass方法中。

public Class<?> loadClass(String name)
类加载的入口，提供了双亲委派机制。内部会调用findClass   重要

protected Class<?> findClass(String name)
由类加载器子类实现,获取二进制数据调用defineClass ，比如URLClassLoader会根据文件路径去获取类文件中的二进制数据。重要

protected final Class<?> defineClass(String name, byte[] b, int off, int len)
做一些类名的校验，然后调用虚拟机底层的方法将字节码信息加载到虚拟机内存中

protected final void resolveClass(Class<?> c)
执行类生命周期中的连接阶段

打破双亲委派机制历史上有三种方式，但本质上只有第一种算是真正的打破了双亲委派机制：

自定义类加载器并且重写loadClass方法。Tomcat通过这种方式实现应用之间类隔离，（

1. 自定义类加载器可以重写findClass方法来自定义获取字节码信息的途径。

2. 如果想通过自定义类加载器来打破双亲委派机制则需要重写loadClass方法，不再实现双亲委派机制。

）
线程上下文类加载器。利用上下文类加载器加载类，比如JDBC和JNDI等。
Osgi框架的类加载器。历史上Osgi框架实现了一套新的类加载器机制，允许同级之间委托进行类的加载，目前很少使用。

4.3、运行时数据区

Java虚拟机在运行Java程序过程中管理的内存区域，称之为运行时数据区。《Java虚拟机规范》中规定了每一部分的作用。

主要包括程序计数器、Java虚拟机栈、本地方法栈、方法区和堆等部分。每个部分都有其特定的作用，以下是它们的详细解释：

1. 程序计数器（Program Counter Register）

作用：程序计数器是一块较小的内存区域，用于记录当前线程所执行的字节码指令的地址或下一条需要执行的指令地址。它是线程私有的，确保了多线程并发执行的正确性。
特点：
- 内存占用小：只占用很小的内存空间。
- 不存在内存溢出异常：因为它只记录指令地址，不涉及数据存储。
- 线程私有：每个线程都有自己独立的程序计数器。
- 同线程共存亡：随着线程的创建而创建，随线程的销毁而销毁。
- 运行速度快：因为它只涉及简单的地址记录，所以运行速度很快。

2. Java虚拟机栈（Java Virtual Machine Stack）

作用：Java虚拟机栈是Java虚拟机运行时数据区的一部分，用于存储方法执行的局部变量、操作数栈、动态链接、方法出口等信息。采用栈的数据结构来管理方法调用中的基本数据，先进后出（First In Last Out）,每一个方法的调用使用一个栈帧（Stack Frame）来保存，每个线程在执行Java程序时都有一个自己的Java虚拟机栈。
特点：
- 后进先出（LIFO）的数据结构：每个栈帧对应一个被调用的方法，方法调用时压栈，执行完毕后出栈。
- 线程私有：每个线程都有自己的虚拟机栈。
- 栈空间大小可设置：通过命令行参数-Xss来指定栈的大小。
- 抛出异常：如果栈中的空间被用尽，会抛出StackOverflowError异常；如果无法分配新的栈帧，会抛出OutOfMemoryError异常。

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

作用：本地方法栈用于支持native方法的执行。Native方法是使用非Java语言编写的代码，可以直接访问操作系统或硬件资源。
特点：
- 结构与Java虚拟机栈类似：也使用栈帧来存储方法调用的信息。
- 线程私有：每个线程在JVM中都有一个本地方法栈。
- 抛出异常：当栈空间不足时，可能会抛出StackOverflowError或OutOfMemoryError异常。

4. 方法区（Method Area）

作用：方法区是存放基础信息的位置，线程共享，主要包含三部分内容：
类的元信息，保存了所有类的基本信息
运行时常量池，保存了字节码文件中的常量池内容（JDK7之前都在方法区的实现为永久代，及之后移除了永久代用元空间取而代之）
字符串常量池，保存了字符串常量（JDK7之前包含在运行时常量池中在方法区中，及JDK7以及之后字符串常量池一直在堆中，其他运行时常量池JDK8开始转移到元空间，并删除永久代。）
题型参考：神奇的intern
特点：
- 线程共享：被所有线程共享。
- 存储内容：包括类信息、常量池、静态变量、JIT编译后的代码等。
- 抛出异常：当加载的类过多时，可能会出现内存溢出异常（OutOfMemoryError）
  注：方法区的实现：
  
  方法区是《Java虚拟机规范》中设计的虚拟概念，每款Java虚拟机在实现上都各不相同。Hotspot设计如下：
  
  JDK7及之前的版本将方法区存放在堆区域中的永久代空间，堆的大小由虚拟机参数来控制。
  
  JDK8及之后的版本将方法区存放在元空间中，元空间位于操作系统维护的直接内存中，默认情况下只要不超过操作系统承受的上限，可以一直分配。

5. 堆（Heap）

作用：堆是Java虚拟机中最大的一块内存区域，用于存放Java对象实例和数组等数据结构。它是程序运行时唯一一个被所有线程共享的内存区域。
特点：
- 动态扩展和缩减：堆的大小可以动态地扩展和缩减，通过命令行参数-Xms和-Xmx进行控制。
- 垃圾回收：堆中存在着垃圾回收机制，用于回收不再使用的对象，防止内存溢出。
- 分区管理：堆通常被分为新生代和老年代等区域，以便进行更有效的垃圾回收。
- 抛出异常：当堆中无法继续分配内存时（堆内存的溢出），会抛出OutOfMemoryError异常。

补充：

静态变量存储在哪里呢？

JDK6及之前的版本中，静态变量是存放在方法区中的，也就是永久代。
JDK7及之后的版本中，静态变量是存放在堆中的Class对象中，脱离了永久代。

6 直接内存

直接内存（Direct Memory）并不在《Java虚拟机规范》中存在，所以并不属于Java运行时的内存区域。

在 JDK 1.4 中引入了 NIO 机制，使用了直接内存，主要为了解决以下两个问题:

1、Java堆中的对象如果不再使用要回收，回收时会影响对象的创建和使用。

2、IO操作比如读文件，需要先把文件读入直接内存（缓冲区）再把数据复制到Java堆中。

现在直接放入直接内存即可，同时Java堆上维护直接内存的引用，减少了数据复制的开销。写文件也是类似的思路。

4.4、垃圾回收

4.4.1 方法区的回收

方法区中能回收的内容主要就是不再使用的类。

判定一个类可以被卸载。需要同时满足下面三个条件：

1、此类所有实例对象都已经被回收，在堆中不存在任何该类的实例对象以及子类对象。

这段代码中就将局部变量对堆上实例对象的引用去除了，所以对象就可以被回收。

2、加载该类的类加载器已经被回收。

这段代码让局部变量对类加载器的引用去除，类加载器就可以回收。

3、该类对应的 java.lang.Class 对象没有在任何地方被引用。

4.4.2 堆回收

4.4.2.1 如何判断对象可以回收

垃圾回收器要回收对象的第一步就是判断哪些对象可以回收。Java中的对象是否能被回收，是根据对象是否被引用来决定的。如果对象被引用了，说明该对象还在使用，不允许被回收。

判断对象是否可以回收，主要有两种方式：引用计数法和可达性分析法。

引用计数法

解释引用计数法的基本思想：为每个对象维护一个引用计数，每当有一个新的引用指向该对象时，计数增加；每当一个引用不再指向该对象时（如引用被覆盖或设为null），计数减少。
当对象的引用计数降至0时，表示该对象不再被任何活动引用所指向，因此可以安全地回收其内存。

比如下图中，对象A的计数器初始为0，局部变量a1对它引用之后，计数器加1就变成了1。同样A对B产生了引用，B的计数器也是1。

优点

实现简单，容易理解。
回收及时，一旦引用计数为0，即可立即回收。

缺点

每次引用和取消引用都需要维护计数器，对系统性能会有一定的影响
存在循环引用问题，所谓循环引用就是当A引用B，B同时引用A时会出现对象无法回收的问题，出现内存泄漏。

当然java虚拟机采用的是第二种方式：

可达性分析法

介绍可达性分析法的核心思想：可达性分析将对象分为两类：垃圾回收的根对象（GC Root）和普通对象，对象与对象之间存在引用关系。从一系列被称为“根集合”（Root Set）的对象（如静态变量、活跃线程的栈帧中的局部变量等）开始，沿着引用链向下搜索，所走过的路径称为“引用链”。
如果一个对象到根集合没有任何引用链相连，即该对象是不可达的，则判断为可回收对象。

优点

可以准确识别并回收所有不再被使用的对象，包括处理循环引用的情况。
现代JVM多采用此方法，因为它更加灵活和强大。

缺点

需要暂停所有应用线程（Stop-The-World），以遍历整个堆来查找可达对象，这可能会影响应用的响应性。
实现相对复杂，需要维护根集合和引用链的信息。

下图中A到B再到C和D，形成了一个引用链，可达性分析算法指的是如果从某个到GC Root对象是可达的，对象就不可被回收。

哪些对象被称之为GC Root对象呢？

线程Thread对象，引用线程栈帧中的方法参数、局部变量等。
系统类加载器加载的java.lang.Class对象，引用类中的静态变量。

监视器对象，用来保存同步锁synchronized关键字持有的对象。
本地方法调用时使用的全局对象。

4.4.2.2 常见的引用对象

可达性算法中描述的对象引用，一般指的是强引用，即是GCRoot对象对普通对象有引用关系，只要这层关系存在，普通对象就不会被回收。除了强引用之外，Java中还设计了几种其他引用方式：

软引用
弱引用
虚引用
终结器引用

1. 软引用（Soft Reference）

定义：软引用是一种比强引用更弱的引用类型，用于描述一些还有用但并非必须的对象。
特点：当JVM内存足够时，软引用对象不会被回收；但当内存不足时，JVM会回收这些对象的内存，以保证程序的正常运行。软引用通常用于实现内存敏感的缓存。在JDK 1.2版之后提供了SoftReference类来实现软引用，软引用常用于缓存中。
使用场景：图片缓存框架中的“内存缓存”常以软引用来保存图片，确保在JVM发生OutOfMemoryError之前可以回收这部分缓存。
特别注意：软引用对象本身，也需要被强引用，否则软引用对象也会被回收掉。
软引用的使用方法

软引用的执行过程如下：

1.将对象使用软引用包装起来，new SoftReference<对象类型>(对象)。

2.内存不足时，虚拟机尝试进行垃圾回收。

3.如果垃圾回收仍不能解决内存不足的问题，回收软引用中的对象。

4.如果依然内存不足，抛出OutOfMemory异常。

代码示例：

/**
 * 软引用案例 - 基本使用
 */
public class SoftReferenceDemo2 {
    public static void main(String[] args) throws IOException {

        byte[] bytes = new byte[1024 * 1024 * 100];
        SoftReference<byte[]> softReference = new SoftReference<byte[]>(bytes);
        bytes = null;
        System.out.println(softReference.get());

        byte[] bytes2 = new byte[1024 * 1024 * 100];
        System.out.println(softReference.get());

    }
}

软引用对象本身怎么回收呢？

如果软引用对象里边包含的数据已经被回收了，那么软引用对象本身其实也可以被回收了。

SoftReference提供了一套队列机制：

1、软引用创建时，通过构造器传入引用队列
2、在软引用中包含的对象被回收时，该软引用对象会被放入引用队列
3、通过代码遍历引用队列，将SoftReference的强引用删除

2. 弱引用（Weak Reference）

定义：弱引用的整体机制和软引用基本一致，弱引用是一种比软引用更弱的引用类型，用于描述非必需的对象。
特点：无论当前内存是否足够，只要垃圾回收器运行，弱引用对象就会被回收。弱引用通常用于实现一些特殊的缓存策略，如虚拟机中的ThreadLocal类。
使用场景：在静态内部类中，经常使用弱引用来保存外部类的引用，以防止外部类因内部类的生命周期而无法被回收，从而避免内存泄漏。

3. 虚引用（Phantom Reference）

定义：虚引用是Java中最弱的一种引用类型，无法通过虚引用来访问对象的任何属性或方法。
特点：虚引用主要用于跟踪对象被垃圾回收器回收的活动，当一个对象仅持有虚引用时，它就像没有任何引用一样，随时可能被垃圾回收器回收。虚引用必须和引用队列（ReferenceQueue）联合使用，当对象被回收时，虚引用会被加入到引用队列中。
使用场景：虚引用主要用于内存管理和对象销毁监控，如释放资源、记录日志等。

4. 终结器引用（Finalizer Reference）

注意：终结器引用并不是Java语言层面直接提供的引用类型，而是JVM内部用于追踪待终结（finalize）对象的特殊引用。
特点：当一个对象没有强引用、软引用或弱引用时，它可能会被垃圾回收器回收。在回收之前，JVM会检查该对象是否覆盖了finalize()方法。如果覆盖了，JVM会将其放入一个名为“终结队列”（F-Queue）的队列中，并在稍后由Finalizer线程调用其finalize()方法。在这个过程中，对象会短暂地持有一个终结器引用，以防止其被立即回收。
使用场景：虽然finalize()方法提供了一种对象被销毁前的清理机制，但由于性能问题和不确定性（如finalize()方法被调用多次或不被调用），现代Java编程中通常不推荐使用它进行资源清理。相反，建议使用try-with-resources语句或显式关闭资源等方法来管理资源。

4.4.2.3 垃圾回收算法

Java是如何实现垃圾回收的呢？简单来说，垃圾回收要做的有两件事：

1、找到内存中存活的对象

2、释放不再存活对象的内存，使得程序能再次利用这部分空间

垃圾回收算法的历史和分类

1960年John McCarthy发布了第一个GC算法：标记-清除算法。

1963年Marvin L. Minsky 发布了复制算法。

本质上后续所有的垃圾回收算法，都是在上述两种算法的基础上优化而来。

垃圾回收算法的评价标准

Java垃圾回收过程会通过单独的GC线程来完成，但是不管使用哪一种GC算法，都会有部分阶段需要停止所有的用户线程。这个过程被称之为Stop The World简称STW，如果STW时间过长则会影响用户的使用。

如下图，用户代码执行和垃圾回收执行让用户线程停止执行（STW）是交替执行的。

1.吞吐量

吞吐量指的是 CPU 用于执行用户代码的时间与 CPU 总执行时间的比值，即吞吐量 = 执行用户代码时间 /（执行用户代码时间 + GC时间）。吞吐量数值越高，垃圾回收的效率就越高。

2.最大暂停时间

最大暂停时间指的是所有在垃圾回收过程中的STW时间最大值。比如如下的图中，黄色部分的STW就是最大暂停时间，显而易见上面的图比下面的图拥有更少的最大暂停时间。最大暂停时间越短，用户使用系统时受到的影响就越短。

3.堆使用效率

不同垃圾回收算法，对堆内存的使用方式是不同的。比如标记清除算法，可以使用完整的堆内存。而复制算法会将堆内存一分为二，每次只能使用一半内存。从堆使用效率上来说，标记清除算法要优于复制算法。

上述三种评价标准：堆使用效率、吞吐量，以及最大暂停时间不可兼得。

一般来说，堆内存越大，最大暂停时间就越长。想要减少最大暂停时间，就会降低吞吐量。

没有一个垃圾回收算法能兼顾上述三点评价标准，所以不同的垃圾回收算法它的侧重点是不同的，适用于不同的应用场景。

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

描述：

1. 标记阶段：此阶段的主要任务是遍历所有的对象，并标记出所有从根集合（GC Roots）可达的对象。GC Roots通常包括虚拟机栈中的局部变量表、方法区中的静态属性等。标记过程通常通过递归或迭代的方式进行，确保所有可达对象都被标记。
2. 清除阶段：在标记完成后，清除阶段会遍历堆中的所有对象，回收那些未被标记的对象（即垃圾对象）。清除并不是真正地从内存中删除这些对象，而是将这些对象占用的内存空间标记为可重新使用。

优缺点：

优点：实现简单，清除速度快。需要在第一阶段给每个对象维护标志位，第二阶段删除对象即可。
缺点 1：容易产生内存碎片，降低内存利用率。当需要分配大块内存时，很有可能这些内存单元的大小过小无法进行分配,可能因为没有足够的连续空间而失败。
如下图，红色部分已经被清理掉了，总共回收了9个字节，但是每个都是一个小碎片，无法为5个字节的对象分配空间。
缺点 2：分配速度慢。由于内存碎片的存在，需要维护一个空闲链表，极有可能发生每次需要遍历到链表的最后才能获得合适的内存空间。我们需要用一个链表来维护，哪些空间可以分配对象，很有可能需要遍历这个链表到最后，才能发现这块空间足够我们去创建一个对象。如下图，遍历到最后才发现有足够的空间分配3个字节的对象了。如果链表很长，遍历也会花费较长的时间。

复制算法（Copying Algorithm）

描述：

复制算法将可用内存分为两个大小相等的区域，通常称为From区和To区。在任意时刻，只有其中一个区域被使用，而另一个区域则保留为空。
当From区满时，GC会启动，将From区中的所有存活对象复制到To区，并清除From区的所有对象。然后，交换From区和To区的角色，继续使用新的From区。

优缺点：

优点：避免了内存碎片的产生，因为每次GC后内存都是紧凑的。同时，复制算法可以高效地利用CPU的缓存，因为存活对象被连续存放。
缺点：内存利用率低，因为只有一半的内存空间被用于存放对象。此外，如果存活对象较多，复制过程将耗费大量时间。

标记整理算法（Mark-Compact Algorithm）

描述：

标记整理算法结合了标记清除算法和内存整理的思想。在标记阶段，该算法与标记清除算法相同，都是遍历所有对象并标记出所有可达对象。
但在清除阶段，标记整理算法不会直接清除垃圾对象，而是将所有存活对象向内存的一端移动，使得存活对象在内存中连续存放。移动完成后，再清除边界外的内存空间。

优缺点：

优点 1：内存使用效率高，整个堆内存都可以使用，不会像复制算法只能使用半个堆内存
优点 2 ：不会发生碎片化，在整理阶段可以将对象往内存的一侧进行移动，剩下的空间都是可以分配对象的有效空间
缺点：整理过程中需要移动对象，这可能导致性能开销，并需要更新引用这些对象的指针。

分代垃圾回收算法（Generational Garbage Collection）

描述：

分代垃圾回收算法是基于对象存活周期的不同而提出的。它将堆内存划分为几个不同的区域（如年轻代、老年代），每个区域使用不同的垃圾回收算法。
年轻代中的对象存活率低，通常使用复制算法进行垃圾回收。而老年代中的对象存活率高，且回收不频繁，通常使用标记清除或标记整理算法进行垃圾回收。

优缺点：

优点：根据不同代的特点选择合适的垃圾回收算法，提高了垃圾回收的效率。
缺点：需要维护多个内存区域，增加了管理的复杂性。同时，不同代之间的对象晋升和跨代引用也可能带来额外的性能开销。

回收步骤：

1、分代回收时，创建出来的对象，首先会被放入Eden伊甸园区。

2、随着对象在Eden区越来越多，如果Eden区满，新创建的对象已经无法放入，就会触发年轻代的GC，称为Minor GC或者Young GC。

Minor GC会把需要eden中和From需要回收的对象回收，把没有回收的对象放入To区。

解释：

eden[首次]满时，会触发垃圾回收，根据可达性判断存活的对象，将存活的对象复制到某个幸存区（假设为From区），同时Eden区清空。当后续eden再满时，就会将eden和From区的对象进行回收然后将幸存的对象复制到To区。

3、接下来，S0会变成To区，S1变成From区。当eden区满时再往里放入对象，依然会发生Minor GC。

此时会回收eden区和S1(from)中的对象，并把eden和from区中剩余的对象放入S0。

注意：每次Minor GC中都会为对象记录他的年龄，初始值为0，每次GC完加1。

4、如果Minor GC后对象的年龄达到阈值（最大15，默认值和垃圾回收器有关），对象就会被晋升至老年代。

解释：

对象进入老年代的几种情况：

1. Minor GC后对象的年龄达到阈值

2. To区空间不够容纳所有复制后的存活对象

3. 大对象直接进入老年代

4. 动态对象年龄判定

当老年代中空间不足，无法放入新的对象时，先尝试minor gc如果还是不足，就会触发Full GC，Full GC会对整个堆进行垃圾回收。

如果Full GC依然无法回收掉老年代的对象，那么当对象继续放入老年代时，就会抛出Out Of Memory异常。

4.4.2.4 垃圾回收器

为什么分代GC算法要把堆分成年轻代和老年代？首先我们要知道堆内存中对象的特性：

系统中的大部分对象，都是创建出来之后很快就不再使用可以被回收，比如用户获取订单数据，订单数据返回给用户之后就可以释放了。
老年代中会存放长期存活的对象，比如Spring的大部分bean对象，在程序启动之后就不会被回收了。
在虚拟机的默认设置中，新生代大小要远小于老年代的大小。

分代GC算法将堆分成年轻代和老年代主要原因有：

1、可以通过调整年轻代和老年代的比例来适应不同类型的应用程序，提高内存的利用率和性能。

2、新生代和老年代使用不同的垃圾回收算法，新生代一般选择复制算法，老年代可以选择标记-清除和标记-整理算法，由程序员来选择灵活度较高。

3、分代的设计中允许只回收新生代（minor gc），如果能满足对象分配的要求就不需要对整个堆进行回收(full gc),STW时间就会减少。

垃圾回收器是垃圾回收算法的具体实现。

由于垃圾回收器分为年轻代和老年代，除了G1之外其他垃圾回收器必须成对组合进行使用。

具体的关系图总结如下：

年轻代-Serial垃圾回收器

Serial收集器是最基础、历史最悠久的收集器，它是一个单线程收集器，在进行垃圾回收时，必须暂停其他所有的工作线程，直到收集结束，这是其主要缺点。

回收年代和算法：

老年代

标记-整理算法

优点

单线程避免了多线程复杂的上下文切换，因此在单线程环境下收集效率非常高，由于这个优点，迄今为止，其仍然是HotSpot虚拟机在客户端模式下默认的新生代收集器:

缺点

多CPU下吞吐量不如其他垃圾回收器，堆如果偏大会让用户线程处于长时间的等待

适用场景

与Serial垃圾回收器搭配使用，或者在CMS特殊情况下使用

回收年代和算法：

年轻代

复制算法

优点

单CPU处理器下吞吐量非常出色

缺点

多CPU下吞吐量不如其他垃圾回收器，堆如果偏大会让用户线程处于长时间的等待

适用场景

Java编写的客户端程序或者硬件配置有限的场景

老年代-SerialOld垃圾回收器

从名字也能看出来，它是Serial收集器的老年代版本，同样是一个单线程收集器，采用标记整理算法，主要用于给客户端模式下的HotSpot使用:

-XX:+UseSerialGC 新生代、老年代都使用串行回收器。

回收年代和算法：

老年代

标记-整理算法

优点

单CPU处理器下吞吐量非常出色

缺点

多CPU下吞吐量不如其他垃圾回收器，堆如果偏大会让用户线程处于长时间的等待

适用场景

与Serial垃圾回收器搭配使用，或者在CMS特殊情况下使用

年轻代-ParNew垃圾回收器

ParNew垃圾回收器本质上是对Serial在多CPU下的优化，使用多线程进行垃圾回收

-XX:+UseParNewGC 新生代使用ParNew回收器，老年代使用串行回收器

回收年代和算法：

年轻代

复制算法

优点

多CPU处理器下停顿时间较短

缺点

吞吐量和停顿时间不如G1，所以在JDK9之后不建议使用

适用场景

JDK8及之前的版本中，与CMS老年代垃圾回收器搭配使用

老年代- CMS(Concurrent Mark Sweep)垃圾回收器

CMS垃圾回收器关注的是系统的暂停时间，允许用户线程和垃圾回收线程在某些步骤中同时执行，减少了用户线程的等待时间。

参数：XX:+UseConcMarkSweepGC

回收年代和算法：

老年代

标记清除算法

优点

系统由于垃圾回收出现的停顿时间较短，用户体验好

缺点

1、内存碎片问题

2、退化问题

3、浮动垃圾问题

适用场景

大型的互联网系统中用户请求数据量大、频率高的场景，比如订单接口、商品接口等

CMS执行步骤：

1.初始标记，用极短的时间标记出GC Roots能直接关联到的对象。

2.并发标记, 标记所有的对象，用户线程不需要暂停。

3.重新标记，由于并发标记阶段有些对象会发生了变化，存在错标、漏标等情况，需要重新标记。

4.并发清理，清理死亡的对象，用户线程不需要暂停。

缺点：

1、CMS使用了标记-清除算法，在垃圾收集结束之后会出现大量的内存碎片，CMS会在Full GC时进行碎片的整理。这样会导致用户线程暂停，可以使用-XX:CMSFullGCsBeforeCompaction=N 参数（默认0）调整N次Full GC之后再整理。

2.、无法处理在并发清理过程中产生的“浮动垃圾”，不能做到完全的垃圾回收。

3、如果老年代内存不足无法分配对象，CMS就会退化成Serial Old单线程回收老年代。

年轻代-Parallel Scavenge垃圾回收器

Parallel Scavenge是JDK8默认的年轻代垃圾回收器，多线程并行回收，关注的是系统的吞吐量。具备自动调整堆内存大小的特点。

回收年代和算法：

年轻代

复制算法

优点

吞吐量高，而且手动可控。为了提高吞吐量，虚拟机会动态调整堆的参数

缺点

不能保证单次的停顿时间

适用场景

后台任务，不需要与用户交互，并且容易产生大量的对象。比如：大数据的处理，大文件导出

老年代-Parallel Old垃圾回收器

Parallel Old是为Parallel Scavenge收集器设计的老年代版本，利用多线程并发收集。

参数： -XX:+UseParallelGC 或

-XX:+UseParallelOldGC可以使用Parallel Scavenge + Parallel Old这种组合。

回收年代和算法：

老年代

标记-整理算法

优点

并发收集，在多核CPU下效率较高

缺点

暂停时间会比较长

适用场景

与Parallel Scavenge配套使用

G1垃圾回收器

JDK9之后默认的垃圾回收器是 G1（Garbage First）垃圾回收器。Parallel Scavenge关注吞吐量，允许用户设置最大暂停时间，但是会减少年轻代可用空间的大小。CMS关注暂停时间，但是吞吐量方面会下降。

而G1设计目标就是将上述两种垃圾回收器的优点融合：

1.支持巨大的堆空间回收(6个g以上的堆空间G1也可以处理非常好)，并有较高的吞吐量。

2.支持多CPU并行垃圾回收（提升垃圾回收的效率）。

3.允许用户设置最大暂停时间（G1垃圾回收器会满足垃圾回收的时间在这个最大暂停时间之内）。

JDK9之后强烈建议使用G1垃圾回收器。

G1垃圾回收器-内存结构

G1的整个堆会被划分成多个大小相等的区域，称之为区Region，区域不要求是连续的。分为Eden、Survivor、Old区。Region的大小通过堆空间大小/2048计算得到，也可以通过参数-XX:G1HeapRegionSize=32m指定(其中32m指定region大小为32M)，Region size必须是2的指数幂，取值范围从1M到32M。

G1垃圾回收有两种方式：

1、年轻代回收（Young GC）：只回收年轻代

2、混合回收（Mixed GC）：回收年轻代和老年代

年轻代回收

年轻代回收（Young GC），回收Eden区和Survivor区中不用的对象。会导致STW，G1中可以通过参数-XX:MaxGCPauseMillis=n（默认200）设置每次垃圾回收时的最大暂停时间毫秒数，G1垃圾回收器会尽可能地保证暂停时间。

1、新创建的对象会存放在Eden区。当G1判断年轻代区不足（max默认60%）Eden园区和Survivor辛存区占总堆的百分之60，无法分配对象时需要回收时会执行Young GC。

2、标记出Eden和Survivor区域中的存活对象，

3、根据配置的最大暂停时间选择某些区域将存活对象复制到一个新的Survivor区中（年龄+1），清空这些区域。

注：这是G1与其他垃圾回收器的最大区别，其他垃圾回收器会在回收的阶段对整个堆进行回收，但是G1垃圾回收器是有所选择的，G1在进行Young GC的过程中会去记录每次垃圾回收时每个Eden区和Survivor区的平均耗时，以作为下次回收时的参考依据。这样就可以根据配置的最大暂停时间计算出本次回收时最多能回收多少个Region区域了。

比如配置最大暂停时间-XX:MaxGCPauseMillis=n（默认200），每个Region回收耗时40ms，那么这次回收最多只能回收4个Region

4、后续Young GC时与之前相同，只不过Survivor区中存活对象会被搬运到另一个Survivor区。