JVM完整图文学习笔记（含拓展知识广度学习）第二章：GC垃圾回收

目录

如何判断对象可以回收

引用计数法

工作流程

缺点：循环引用问题

引用计数法的优缺点

可达性分析算法

概念

分析思路

GC Roots 可以是哪些？ 

可达性算法解决循环依赖的原理

在可达性分析之后不可达的对象会立即判定为死亡吗？

总结

四种引用

概述 

① 强引用

② 软引用

软引用的实践理解：

③ 弱引用

④ 虚引用

⑤ 总结

垃圾回收算法

标记清除

标记阶段： 

清除阶段：

特点：

 标记整理

标记阶段：

整理阶段： 

特点：

复制回收

特点： 

分代垃圾回收

概述

步骤细化

启动新生代GC

进入老年代空间

记录集

老年代GC

相关 VM 参数

问题

当新生代进行了一次minor gc后晋升元素，但老年代的空间不足了，会执行什么步骤

Major GC和Full GC的区别

什么时候会执行Full GC 

一个大对象如果内存空间大于伊甸园空间会怎么样

一个线程导致了OOM（堆内存溢出）后会不会导致其他线程噶了

垃圾回收器

分类

串行回收器（Serial Collector）

吞吐量优先垃圾回收器（Throughput Collector）

响应时间优先垃圾回收器（Concurrent Collector）

串行回收器

吞吐量优先回收器

吞吐量优先回收器工作时，CPU会飙升到100%

响应时间优先回收器

细节

三色标记法

并发标记带来的问题

问题一：非垃圾变成了垃圾

问题二：垃圾变成了非垃圾

增量更新和原始快照(SATB)

读写屏障

增量更新

原始快照SATB

方案选择

总结

G1（Garbage First）（重点！）

G1 垃圾回收阶段

Young Collection

Young Collection + 并发标记

Mixed Collection

Full GC 

跨代引用

记忆集

卡表

DK8u20字符串去重 

DK8u60回收巨型对象

垃圾回收调优

选择恰当的垃圾回收器

最快的 GC 是没有GC

新生代调优

新生代的特点

调优策略 

增大新生代内存(-Xmn ：设置新生代的初始和最大值)

调节幸存区大小

晋升阈值

老年代调优

调优解决不了，那就升级硬件配置

案例实战

Full GC 和 Minor GC 频繁

请求高峰期发生 Full GC，单次暂停时间特别长（CMS） 

老年代充裕情况下，发生 Full GC（jdk1.7）

---

如何判断对象可以回收

引用计数法

        引用计数法是一种常见的垃圾回收算法，用于判断对象是否可以回收。它基于统计每个对象被引用的次数，当计数为零时，即表示对象不再被引用，可以被回收。（早期Python用，Java不用）

工作流程

        在程序中，每当创建一个对象引用，引用计数会增加。当引用被置为 null、对象被重新赋值或者超出作用域等情况时，引用计数会减少。当计数为零时，即表示对象不再被引用，可以被回收。

缺点：循环引用问题

        引用计数法在处理循环引用时遇到困难。如果两个对象相互引用，它们的引用计数永远不会变为零，导致内存泄漏。为了解决这个问题，可以通过其他机制如引入"根集"来辅助判断循环引用的存在。        

为了解决引用计数法的循环引用问题，可以采用辅助算法如可达性分析算法，通过标记和清除的方式识别出不再可达的对象。

引用计数法的优缺点

• 引用计数法的优点包括实时性高、回收对象的代价低、回收对象产生的停顿短。
• 它也存在一些缺点，如循环引用问题、计数器的维护开销、无法解决内存碎片化等。

 引用计数法更适合实时性要求高、分配和回收开销敏感的应用场景。但在处理循环引用和内存碎片问题上相对劣势。

可达性分析算法

• JVM 中的垃圾回收器通过可达性分析来探索所有存活的对象

概念

可达性分析算法：也可以称为根搜索算法、追踪性垃圾收集。

        相对于引用计数算法而言，可达性分析算法不仅同样具备实现简单和执行高效等特点，更重要的是该算法可以有效地解决在引用计数算法中循环引用的问题，防止内存泄漏的发生。

分析思路

所谓 "GC Roots”根集合就是一组必须活跃的引用（不会被垃圾回收的对象引用）。

基本思路：

• 可达性分析算法是以根对象集合（GCRoots）为起始点，按照从上至下的方式搜索被根对象集合所连接的目标对象是否可达。

• 使用可达性分析算法后，内存中的存活对象都会被根对象集合直接或间接连接着，搜索所走过的路径称为引用链（Reference Chain）。

• 如果目标对象没有任何引用链相连，则是不可达的，就意味着该对象己经死亡，可以标记为垃圾对象。

• 在可达性分析算法中，只有能够被根对象集合直接或者间接连接的对象才是存活对象。，即 GC Root 到该对象不可达，则认为该对象不可用。

GC Roots 可以是哪些？ 

• 虚拟机栈中引用的对象           

                比如：各个线程被调用的方法中使用到的参数、局部变量等。

• 本地方法栈内 JNI（通常说的本地方法）引用的对象

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

                比如：Java类的引用类型静态变量

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

                比如：字符串常量池（string Table）里的引用

• 所有被同步锁 synchronized 持有的对象

• Java虚拟机内部的引用。

           基本数据类型对应的 Class 对象，一些常驻的异常对象（如：NullPointerException、OutOfMemoryError），系统类加载器。

• 反映 java 虚拟机内部情况的 JMXBean、JVMTI 中注册的回调、本地代码缓存等。

---

可达性算法解决循环依赖的原理

1. 根集的识别：可达性分析算法首先确定根集（GC Roots），这些根对象是整个程序的起点。根集包括栈中的本地变量、静态变量、系统类等。通过标识出根集对象，可以从这些对象开始追踪可达的对象。

2. 标记阶段：从根集对象出发，进行对象的标记。通过追踪对象之间的引用关系，可达性分析算法遍历对象图，标记可达对象。在标记过程中，标记已经访问过的对象。

3. 辅助数据结构：为了解决循环依赖问题，可达性分析算法使用辅助数据结构，如记忆集（Remembered Set）或者存活对象集合（Live Object Set）。这些数据结构用于记录可能存在循环依赖的对象，而不会重复遍历该循环依赖路径。

4. 对象标记过程中的检测：当可达性分析算法在标记过程中访问到一个对象时，它会检测该对象是否处于记忆集或者存活对象集合中。如果该对象已经标记过或者已在集合中，就不再继续遍历该对象的引用关系，从而避免无限循环。

5. 非可达对象的回收：在标记阶段完成后，未被标记的对象即为非可达对象，可以被回收。这些非可达对象很可能是循环依赖关系中的对象。

        通过使用辅助数据结构和检测机制，可达性算法能够有效解决循环依赖带来的回收问题。它能够正确地判断对象的可达性，并进行垃圾回收。这样，即使存在循环依赖关系，也能够保证引用计数为零的对象被正确回收，避免内存泄漏的问题。

---

在可达性分析之后不可达的对象会立即判定为死亡吗？

        如果一个对象被判定为不可达，这时候会再判断一下该对象是否有必要执行 finalize() 方法，如果没有该方法，或者方法已经被执行过，则没有必要被执行，直接标记为死亡，否则会把该对象放入 F-Queue 队列。如果该方法正常执行，则标记为死亡；如果在该方法内又重新把自己与引用链上的任何对象建立关联，则该对象会重新复活。

总结

总结一句话就是，堆空间外的一些结构，比如虚拟机栈、本地方法栈、方法区、字符串常量池等地方对堆空间进行引用的，都可以作为 GC Roots 进行可达性分析。

        除了这些固定的 GC Roots 集合以外，根据用户所选用的垃圾收集器以及当前回收的内存区域不同，还可以有其他对象“临时性”地加入，共同构成完整 GC Roots 集合。比如：分代收集和局部回收（Partial GC）。

        如果只针对 Java 堆中的某一块区域进行垃圾回收（比如：典型的只针对新生代），必须考虑到内存区域是虚拟机自己的实现细节，更不是孤立封闭的，这个区域的对象完全有可能被其他区域的对象所引用，这时候就需要一并将关联的区域对象也加入 GCRoots 集合中去考虑，才能保证可达性分析的准确性。

---

四种引用

概述 

① 强引用

• Java编程中经常new的一个对象就是强引用，例如Student stu = new Student("张三");中stu就是一个强引用。
• 强引用具有以下特点：

1. 被强引用关联的对象不会被垃圾回收器回收。注意： 当JVM的内存空间不足时，宁愿抛出OutOfMemoryError异常使得程序止，也不愿意回收具有强引用对象来解决内存不足的问题！
2. 强引用可能会发生内存泄露

② 软引用

• 软引用的生命周期比强引用短，使用 SoftReference 类来创建软引用，具体方法如下。这里的sf才是软引用，而stu是sf软引用的对象。

  Student stu = new Student();
  SoftReference sf = new SoftReference(stu);
  stu = null;  // 使对象只被软引用关联
  

• 软引用的特点：

  1. 如果一个对象只具备软引用，当JVM内存空间足够时，不会被回收；当JVM内存空间不足了，就会GC该对象。
  2. 软引用可用来实现内存敏感的高速缓存，例如图片缓存框架中缓存图片就是通过软引用的。
  3. 软引用可以和一个引用队列（ReferenceQueue） 联合使用：如果软引用所关联的对象被垃圾回收器回收， JVM就会把这个软引用加入到与之关联的引用队列中。

软引用的实践理解：

假设我们现在要在网上下载一些图片资源（这里用指定大小byte【】来模拟图片资源的所占空间）

如果我们采用的是强引用的方式来进行：

/**
 * 演示 软引用
 * -Xmx20m -XX:+PrintGCDetails -verbose:gc  // 设置堆内存为20M
 */
public class Code_08_SoftReferenceTest {

    public static int _4MB = 4 * 1024 * 1024;

    public static void main(String[] args) throws IOException {
        method2();
    }

    // 设置 -Xmx20m , 演示堆内存不足,
    public static void method1() throws IOException {
        ArrayList list = new ArrayList<>();

        for(int i = 0; i < 5; i++) {
            list.add(new byte[_4MB]);
        }
        System.in.read();
    }

        运行 mehtod1 方法，会抛堆内存溢出异常，因为 mehtod1 中的 list 都是强引用。哪怕内存满了触发垃圾回收也不能回收这些强引用的对象，最后导致内存溢出。

        但是实际场景中，对于这种内存敏感的操作，我们要求哪怕是再其他时间重试获取都不要他内存溢出，为此，我们可以将其引用改为一个软引用，确保内存不足时可以回收掉这些对象进行一个内存释放，避免内存溢出

// 演示 软引用
    public static void method2() throws IOException {
        ArrayList> list = new ArrayList<>();
        for(int i = 0; i < 5; i++) {
            SoftReference ref = new SoftReference<>(new byte[_4MB]);
            System.out.println(ref.get());
            list.add(ref);
            System.out.println(list.size());
        }
        System.out.println("循环结束：" + list.size());
        for(SoftReference ref : list) {
            System.out.println(ref.get());
        }
    }

上面的代码中，当软引用引用的对象被回收了，但是软引用还存在，所以，一般软引用需要搭配一个引用队列一起使用。这样子才能收集那些无意义的软引用对象（关联了引用队列，当软引用所关联的 byte[] 被回收时，这个无用的软引用自己会加入到 queue 中去，最终queue中的对象都是那些无用的软引用对象，可以直接移除掉）

// 演示 软引用 搭配引用队列
    public static void method3() throws IOException {
        ArrayList> list = new ArrayList<>();
        // 引用队列
        ReferenceQueue queue = new ReferenceQueue<>();

        for(int i = 0; i < 5; i++) {
            // 关联了引用队列，当软引用所关联的 byte[] 被回收时，软引用自己会加入到 queue 中去
            SoftReference ref = new SoftReference<>(new byte[_4MB], queue);
            System.out.println(ref.get());
            list.add(ref);
            System.out.println(list.size());
        }

        // 从队列中获取无用的 软引用对象，并移除
        Reference poll = queue.poll();
        while(poll != null) {
            list.remove(poll);
            poll = queue.poll();
        }

        System.out.println("=====================");
        for(SoftReference ref : list) {
            System.out.println(ref.get());
        }
    }

 

③ 弱引用

• 弱引用的生命周期比软引用还要短，弱引用是通过WeakReference类实现的，ThreadLocal中的key就用到了弱引用

• 弱引用的具体实现如下：

  Object obj = new Object();
  WeakReference