Java虚拟机垃圾回收机制

左手的ㄟ右手 2022-02-01 02:53 326阅读 0赞

# 垃圾收集 #

垃圾收集主要是针对堆和方法区进行。

程序计数器、虚拟机栈和本地方法栈这三个区域属于线程私有的，只存在于线程的生命周期内，线程结束之后也会消失，因此不需要对这三个区域进行垃圾回收。

判断一个对象是否可被回收

### 1. 引用计数算法 ###

给对象添加一个引用计数器，当对象增加一个引用时计数器加 1，引用失效时计数器减 1。引用计数为 0 的对象可被回收。

两个对象出现循环引用的情况下，此时引用计数器永远不为 0，导致无法对它们进行回收。

正因为循环引用的存在，因此 Java 虚拟机不使用引用计数算法。

public class ReferenceCountingGC {
    
        public Object instance = null;
    
        public static void main(String[] args) {
            ReferenceCountingGC objectA = new ReferenceCountingGC();
            ReferenceCountingGC objectB = new ReferenceCountingGC();
            objectA.instance = objectB;
            objectB.instance = objectA;
        }
    }

### 2. 可达性分析算法 ###

通过 GC Roots 作为起始点进行搜索，能够到达到的对象都是存活的，不可达的对象可被回收。

Java 虚拟机使用该算法来判断对象是否可被回收，在 Java 中 GC Roots 一般包含以下内容：

*  虚拟机栈中局部变量表中引用的对象
 *  本地方法栈中 JNI 中引用的对象
 *  方法区中类静态属性引用的对象
 *  方法区中的常量引用的对象

![0635cbe8.png][]

### 3. 方法区的回收 ###

因为方法区主要存放永久代对象，而永久代对象的回收率比新生代低很多，因此在方法区上进行回收性价比不高。

主要是**对常量池的回收**和**对类的卸载**。

在大量使用反射、动态代理、CGLib 等 ByteCode 框架、 动态生成 JSP 以及 OSGi 这类频繁自定义 ClassLoader 的场景都需要虚拟机具备类卸载功能，以保证不会出现内存溢出。

类的卸载条件很多，需要满足以下三个条件，并且满足了也不一定会被卸载：

*  该类所有的实例都已经被回收，也就是**堆中不存在该类的任何实例**。
 *  加载该类的 **ClassLoader 已经被回收**。
 *  该类对应的 **Class 对象没有在任何地方被引用**，也就无法在任何地方通过反射访问该类方法。

可以通过 -Xnoclassgc 参数来控制是否对类进行卸载。

### 4. finalize() ###

finalize() 类似 C++ 的析构函数，用来做关闭外部资源等工作。但是 try-finally 等方式可以做的更好， 并且该方法运行代价高昂，不确定性大，无法保证各个对象的调用顺序，因此最好不要使用。

当一个对象可被回收时，如果需要执行该对象的 finalize() 方法， 那么就有可能在该方法中让对象重新被引用，从而实现自救。 **自救只能进行一次**，如果回收的对象之前调用了 finalize() 方法自救，后面回收时不会调用 finalize() 方法。

## 引用类型 ##

无论是通过引用计算算法判断对象的引用数量，还是通过可达性分析算法判断对象是否可达， 判定对象是否可被回收都与引用有关。

Java 提供了四种强度不同的引用类型。

### 1. 强引用 ###

被强引用关联的对象**不会被回收**。

使用 new 一个新对象的方式来创建强引用。

Object obj = new Object();

### 2. 软引用 ###

被软引用关联的对象只有**在内存不够的情况下才会被回收**。

使用 SoftReference 类来创建软引用。

Object obj = new Object();
    SoftReference<Object> sf = new SoftReference<Object>(obj);
    obj = null;  // 使对象只被软引用关联

### 3. 弱引用 ###

被弱引用关联的对象**一定会被回收**，也就是说它只能存活到下一次垃圾回收发生之前。

使用 WeakReference 类来实现弱引用。

Object obj = new Object();
    WeakReference<Object> wf = new WeakReference<Object>(obj);
    obj = null;

### 4. 虚引用 ###

又称为幽灵引用或者幻影引用。一个对象是否有虚引用的存在， 完全**不会对其生存时间构成影响**，也无法通过虚引用取得一个对象。

为一个对象设置虚引用关联的唯一目的就是能**在这个对象被回收时收到一个系统通知**。

使用 PhantomReference 来实现虚引用。

Object obj = new Object();
    PhantomReference<Object> pf = new PhantomReference<Object>(obj);
    obj = null;

## 垃圾收集算法 ##

### 1. 标记 - 清除 ###

![a4248c4b-6c1d-4fb8-a557-86da92d3a294.jpg][]

将存活的对象进行标记，然后清理掉未被标记的对象。

不足：

*  标记和清除过程效率都不高；
 *  会产生大量不连续的内存碎片，导致无法给大对象分配内存。

### 2. 标记 - 整理 ###

![902b83ab-8054-4bd2-898f-9a4a0fe52830.jpg][]

让所有存活的对象都向一端移动，然后直接清理掉端边界以外的内存。

### 3. 复制 ###

![e6b733ad-606d-4028-b3e8-83c3a73a3797.jpg][]

将内存划分为大小相等的两块，每次只使用其中一块，当这一块内存用完了就将还存活的对象复制到另一块上面，然后再把使用过的内存空间进行一次清理。

主要不足是只使用了内存的一半。

现在的商业虚拟机都采用这种收集算法来回收新生代，但是并不是将新生代划分为大小相等的两块，而是分为一块较大的 Eden 空间和两块较小的 Survivor 空间，每次使用 Eden 空间和其中一块 Survivor。在回收时，将 Eden 和 Survivor 中还存活着的对象一次性复制到另一块 Survivor 空间上，最后清理 Eden 和使用过的那一块 Survivor。

HotSpot 虚拟机的 Eden 和 Survivor 的大小比例默认为 8:1，保证了内存的利用率达到 90%。如果每次回收有多于 10% 的对象存活，那么一块 Survivor 空间就不够用了，此时需要依赖于老年代进行分配担保，也就是借用老年代的空间存储放不下的对象。

### 4. 分代收集 ###

现在的商业虚拟机采用分代收集算法，它根据对象存活周期将内存划分为几块，不同块采用适当的收集算法。

一般将堆分为新生代和老年代。

*  新生代使用：复制算法
 *  老年代使用：标记 - 清除 或者 标记 - 整理 算法

## 垃圾收集器 ##

![c625baa0-dde6-449e-93df-c3a67f2f430f.jpg][]

以上是 HotSpot 虚拟机中的 7 个垃圾收集器，连线表示垃圾收集器可以配合使用。

*  单线程与多线程：单线程指的是垃圾收集器只使用一个线程进行收集，而多线程使用多个线程；
 *  串行与并行：串行指的是垃圾收集器与用户程序交替执行，这意味着在执行垃圾收集的时候需要停顿用户程序；并行指的是垃圾收集器和用户程序同时执行。除了**CMS** 和 **G1**之外，其它垃圾收集器都是以串行的方式执行。

### 1. Serial 收集器 ###

![22fda4ae-4dd5-489d-ab10-9ebfdad22ae0.jpg][]

Serial 翻译为串行，也就是说它以串行的方式执行。

它是单线程的收集器，只会使用一个线程进行垃圾收集工作。

它的优点是简单高效，对于单个 CPU 环境来说，由于**没有线程交互的开销**，因此拥有最高的单线程收集效率。

它是 Client 模式下的**默认新生代收集器**，因为在该应用场景下，分配给虚拟机管理的内存一般来说不会很大。Serial 收集器收集几十兆甚至一两百兆的新生代停顿时间可以控制在一百多毫秒以内，只要不是太频繁，这点停顿是可以接受的。

### 2. ParNew 收集器 ###

![81538cd5-1bcf-4e31-86e5-e198df1e013b.jpg][]

它是 Serial 收集器的多线程版本。

是 Server 模式下的虚拟机首选新生代收集器，除了性能原因外，主要是因为除了 Serial 收集器，只有它能与 CMS 收集器配合工作。

默认开启的线程数量与 CPU 数量相同，可以使用 -XX:ParallelGCThreads 参数来设置线程数。

### 3. Parallel Scavenge 收集器 ###

与 ParNew 一样是多线程收集器。

其它收集器关注点是尽可能缩短垃圾收集时用户线程的停顿时间，而它的目标是达到一个可控制的吞吐量，它被称为“吞吐量优先”收集器。这里的吞吐量指 CPU 用于运行用户代码的时间占总时间的比值。

停顿时间越短就越适合需要与用户交互的程序，良好的响应速度能提升用户体验。而高吞吐量则可以高效率地利用 CPU 时间，尽快完成程序的运算任务，适合在后台运算而不需要太多交互的任务。

缩短停顿时间是以牺牲吞吐量和新生代空间来换取的：新生代空间变小，垃圾回收变得频繁，导致吞吐量下降。

可以通过一个开关参数打开 GC 自适应的调节策略（GC Ergonomics）， 就不需要手工指定新生代的大小（-Xmn）、Eden 和 Survivor 区的比例、晋升老年代对象年龄等细节参数了。 虚拟机会根据当前系统的运行情况收集性能监控信息， 动态调整这些参数以提供最合适的停顿时间或者最大的吞吐量。 自适应调节策略是 Parallel Scavenge 收集器和 ParNew 收集器的一个重要区别。

### 4. Serial Old 收集器 ###

![08f32fd3-f736-4a67-81ca-295b2a7972f2.jpg][]

是 Serial 收集器的老年代版本，也是给 Client 模式下的虚拟机使用，采用标记-整理算法。如果用在 Server 模式下，它有两大用途：

*  在 JDK 1.5 以及之前版本（Parallel Old 诞生以前）中与 Parallel Scavenge 收集器搭配使用。
 *  作为 CMS 收集器的后备预案，在并发收集发生 Concurrent Mode Failure 时使用。

### 5. Parallel Old 收集器 ###

![278fe431-af88-4a95-a895-9c3b80117de3.jpg][]

是 Parallel Scavenge 收集器的老年代版本，采用标记-整理算法。

在注重吞吐量以及 CPU 资源敏感的场合，都可以优先考虑 Parallel Scavenge 加 Parallel Old 收集器。

### 6. CMS 收集器 ###

![62e77997-6957-4b68-8d12-bfd609bb2c68.jpg][]

CMS（Concurrent Mark Sweep），**Mark Sweep 指的是标记 - 清除算法**。

分为以下四个流程：

*  初始标记：仅仅只是标记一下 GC Roots 能直接关联到的对象，速度很快，需要停顿。
 *  并发标记：进行 GC Roots Tracing 的过程，它在整个回收过程中耗时最长，不需要停顿。
 *  重新标记：为了修正并发标记期间因用户程序继续运作而导致标记产生变动的那一部分对象的标记记录，需要停顿。
 *  并发清除：不需要停顿。

在整个过程中耗时最长的并发标记和并发清除过程中，收集器线程都可以与用户线程一起工作，不需要进行停顿，具有**并发收集、低停顿**的优点。

具有以下缺点：

*  吞吐量低：低停顿时间是以牺牲吞吐量为代价的，导致 **CPU 利用率不够高**。
 *  **无法处理浮动垃圾**，可能出现 Concurrent Mode Failure。**浮动垃圾是指并发清除阶段由于用户线程继续运行而产生的垃圾，这部分垃圾只能到下一次 GC 时才能进行回收**。 由于浮动垃圾的存在，因此需要预留出一部分内存，意味着 CMS 收集不能像其它收集器那样等待老年代快满的时候再回收。如果预留的内存不够存放浮动垃圾，就会出现 Concurrent Mode Failure，这时虚拟机将临时启用 Serial Old 来替代 CMS。
 *  标记 - 清除算法导致的**空间碎片**，往往出现老年代空间剩余，但无法找到足够大连续空间来分配当前对象，不得不提前触发一次 Full GC。

> CMS 已经在 JDK 9 中被标记为废弃（ deprecated ）。

### 7. G1 收集器 ###

G1（Garbage-First），它是一款面向服务端应用的垃圾收集器，在多 CPU 和大内存的场景下有很好的性能。HotSpot 开发团队赋予它的使命是未来可以替换掉 CMS 收集器。

堆被分为新生代和老年代，其它收集器进行收集的范围都是整个新生代或者老年代，而 **G1 可以直接对新生代和老年代一起回收**。

![4cf711a8-7ab2-4152-b85c-d5c226733807.png][]

G1 把堆划分成多个大小相等的独立区域（Region），Region的大小是一致的，数值是在1M到32M字节之间的一个2的幂值数，JVM会尽量划分2048个左右、同等大小的Region，**新生代和老年代不再物理隔离**。

![9bbddeeb-e939-41f0-8e8e-2b1a0aa7e0a7.png][]

通过引入 Region 的概念，从而将原来的一整块内存空间划分成多个的小空间，使得每个小空间可以单独进行垃圾回收。这种划分方法带来了很大的灵活性，使得可预测的停顿时间模型成为可能。通过记录每个 Region 垃圾回收时间以及回收所获得的空间（这两个值是通过过去回收的经验获得），并维护一个优先列表，每次根据允许的收集时间，优先回收价值最大的 Region。

每个 Region 都有一个 **Remembered Set**，用来记录该 Region 对象的引用对象所在的 Region。通过使用 Remembered Set，在做可达性分析的时候就可以避免全堆扫描。

![f99ee771-c56f-47fb-9148-c0036695b5fe.jpg][]

如果不计算维护 Remembered Set 的操作，G1 收集器的运作大致可划分为以下几个步骤：

*  初始标记
 *  并发标记
 *  最终标记：为了修正在并发标记期间因用户程序继续运作而导致标记产生变动的那一部分标记记录，虚拟机将这段时间对象变化记录在线程的 Remembered Set Logs 里面，最终标记阶段需要把 Remembered Set Logs 的数据合并到 Remembered Set 中。这阶段需要停顿线程，但是可并行执行。
 *  筛选回收：首先对各个 Region 中的回收价值和成本进行排序，根据用户所期望的 GC 停顿时间来制定回收计划。此阶段其实也可以做到与用户程序一起并发执行，但是因为只回收一部分 Region，时间是用户可控制的，而且停顿用户线程将大幅度提高收集效率。

从 GC 算法的角度， G1 选择的是复合算法，可以简化理解为：

*  在新生代，G1采用的仍然是**并行的复制算法**，所以同样会发生Stop-The-World的暂停。
 *  在老年代，大部分情况下都是并发标记，而整理（Compact）则是和新生代GC时捎带进行，并且不是整体性的整理，而是**增量**进行的。

具备如下特点：

*  空间整合：**整体来看是基于“标记 - 整理”算法**实现的收集器，从局部（两个 Region 之间）上来看是基于“复制”算法实现的，这意味着运行期间不会产生内存空间碎片。
 *  可预测的停顿：能让使用者明确指定在一个长度为 M 毫秒的时间片段内，消耗在 GC 上的时间不得超过 N 毫秒。

> 目前尚处于开发中的 JDK 11， JDK 又增加了两种全新的 GC 方式，分别是：
> 
>  *  Epsilon GC，简单说就是个不做垃圾收集的GC，似乎有点奇怪，有的情况下，例如在进行性能测试的时候，可能需要明确判断GC本身产生了多大的开销，这就是其典型应用场景。
>  *  ZGC，这是Oracle开源出来的一个超级GC实现，具备令人惊讶的扩展能力，比如支持T bytes级别的堆大小，并且保证绝大部分情况下，延迟都不会超过10 ms。虽然目前还处于实验阶段，仅支持 Linux 64 位的平台，但其已经表现出的能力和潜力都非常令人期待。

[0635cbe8.png]: https://github.com/DuHouAn/Java/raw/master/JVM/notes/pics/0635cbe8.png
[a4248c4b-6c1d-4fb8-a557-86da92d3a294.jpg]: https://github.com/DuHouAn/Java/raw/master/JVM/notes/pics/a4248c4b-6c1d-4fb8-a557-86da92d3a294.jpg
[902b83ab-8054-4bd2-898f-9a4a0fe52830.jpg]: https://github.com/DuHouAn/Java/raw/master/JVM/notes/pics/902b83ab-8054-4bd2-898f-9a4a0fe52830.jpg
[e6b733ad-606d-4028-b3e8-83c3a73a3797.jpg]: https://github.com/DuHouAn/Java/raw/master/JVM/notes/pics/e6b733ad-606d-4028-b3e8-83c3a73a3797.jpg
[c625baa0-dde6-449e-93df-c3a67f2f430f.jpg]: https://github.com/DuHouAn/Java/raw/master/JVM/notes/pics/c625baa0-dde6-449e-93df-c3a67f2f430f.jpg
[22fda4ae-4dd5-489d-ab10-9ebfdad22ae0.jpg]: https://github.com/DuHouAn/Java/raw/master/JVM/notes/pics/22fda4ae-4dd5-489d-ab10-9ebfdad22ae0.jpg
[81538cd5-1bcf-4e31-86e5-e198df1e013b.jpg]: https://github.com/DuHouAn/Java/raw/master/JVM/notes/pics/81538cd5-1bcf-4e31-86e5-e198df1e013b.jpg
[08f32fd3-f736-4a67-81ca-295b2a7972f2.jpg]: https://github.com/DuHouAn/Java/raw/master/JVM/notes/pics/08f32fd3-f736-4a67-81ca-295b2a7972f2.jpg
[278fe431-af88-4a95-a895-9c3b80117de3.jpg]: https://github.com/DuHouAn/Java/raw/master/JVM/notes/pics/278fe431-af88-4a95-a895-9c3b80117de3.jpg
[62e77997-6957-4b68-8d12-bfd609bb2c68.jpg]: https://github.com/DuHouAn/Java/raw/master/JVM/notes/pics/62e77997-6957-4b68-8d12-bfd609bb2c68.jpg
[4cf711a8-7ab2-4152-b85c-d5c226733807.png]: https://github.com/DuHouAn/Java/raw/master/JVM/notes/pics/4cf711a8-7ab2-4152-b85c-d5c226733807.png
[9bbddeeb-e939-41f0-8e8e-2b1a0aa7e0a7.png]: https://github.com/DuHouAn/Java/raw/master/JVM/notes/pics/9bbddeeb-e939-41f0-8e8e-2b1a0aa7e0a7.png
[f99ee771-c56f-47fb-9148-c0036695b5fe.jpg]: https://github.com/DuHouAn/Java/raw/master/JVM/notes/pics/f99ee771-c56f-47fb-9148-c0036695b5fe.jpg