1、如何确定一个对象是垃圾？

对于某个对象而言，只要应用程序中持有该对象的引用，就说明该对象不是垃圾，如果一个对象没有任何指针对其引用，它就是垃圾。

1.1、引用计数法

引用计数法是指将对象的被引用次数保存起来，当被引用次数变为零时就将其释放。但是这种方法会存在一种问题：
如果AB相互持有引用，导致永远不能被回收，就会出现内存泄露。 目前主流的JVM厂商均不使用该方法。如下图实例1和实例2

1.2、可达性分析

通过GC Root的引用，开始向下寻找，看某个对象是否可达。如下图，obj7和obj8在可达性分析后被视为垃圾。能作为GC Root 有以下几个：

1. 虚拟机栈（栈帧中的本地变量表）中引用的对象。
2. 方法区中类静态属性引用的对象。
3. 方法区中常量引用的对象。
4. 本地方法栈中JNI（即一般说的Native方法）引用的对象。

2、对象被判定为不可达对象之后就“死”了吗？

首先我们看下对象的生命周期，通过下图可以看到在收集阶段会执行对象的finalize方法，如果finalize方法中会重新被建立引用，该对象则不会“死”。

finalize方法代码Demo：

public class Finalize {

    private static Finalize save_hook = null;//类变量

    public void isAlive() {
        System.out.println("我还活着");
    }

    @Override
    public void finalize() {
        System.out.println("finalize方法被执行");
        Finalize.save_hook = this;
    }

    public static void main(String[] args) throws InterruptedException {



        save_hook = new Finalize();//对象
        //对象第一次拯救自己
        save_hook = null;
        System.gc();
        //暂停0.5秒等待他
        Thread.sleep(500);
        if (save_hook != null) {
            save_hook.isAlive();
        } else {
            System.out.println("好了，现在我死了");
        }

        //对象第二次拯救自己
        save_hook = null;
        System.gc();
        //暂停0.5秒等待他
        Thread.sleep(500);
        if (save_hook != null) {
            save_hook.isAlive();
        } else {
        	//虚拟机已调用过finalize()
            System.out.println("我终于死亡了");
        }
    }
}

下面可以看下对象在各个阶段的状态

1. 创建阶段
   （1）为对象分配存储空间
   （2）开始构造对象
   （3）从超类到子类对static成员进行初始化
   （4）超类成员变量按顺序初始化，递归调用超类的构造方法
   （5）子类成员变量按顺序初始化，调用子类构造方法
   （6）一旦对象被创建，并被分派给某些变量赋值，这个对象的状态就切换到了应用阶段
2. 应用阶段
   （1）系统至少维护着对象的一个强引用
   （2）所有对该对象的引用全部是强引用（除非我们显式地使用了：软引用（Soft Reference）、弱引用（Weak Reference）或虚引用（Phantom Reference））

引用的定义：

1. 数据类型必须是引用类型
2. 这个类型的数据所存储的数据必须是另外一块内存的起始地址

引用类型参考Java基础面试题——面向对象和集合专题

3. 不可见阶段

不可见阶段的对象在虚拟机的对象根引用集合中再也找不到直接或者间接的强引用，最常见的就是线程或者函数中的临时变量。

4. 不可达阶段
   指对象不再被任何强引用持有，GC发现该对象已经不可达。下一步就是收集阶段。

3、都有哪些垃圾收集算法？

已经能够确定一个对象为垃圾之后，接下来要考虑的就是回收，怎么回收呢？得要有对应的算法，下面介绍常见的垃圾回收算法。

3.1、 标记-清除(Mark-Sweep)

• 标记
  找出内存中所有的存活对象，并且把它们标记出来。如下图蓝色的块是存活对象，而未标记的灰色块将要被清除。
  

• 清除
  清除掉被标记需要回收的对象，释放出对应的内存空间
  

缺点：

1. 标记和清除两个过程都比较耗时，效率不高
2. 会产生大量不连续的内存碎片，空间碎片太多可能会导致以后在程序运行过程中需要分配较大对象时，无法找到足够的连续内存而不得不提前触发另一次垃圾收集动作。

标记清除算法的衍生规则之分配（动态分区分配策略）

• 首次适应算法（Fisrt-fit）
  首次适应算法（Fisrt-fit）就是在遍历空闲链表的时候，一旦发现有大小大于等于需要的大小之后，就立即把该块分配给对象，并立即返回。
• 最佳适应算法（Best-fit）
  最佳适应算法（Best-fit）就是在遍历空闲链表的时候，返回刚好等于需要大小的块。
• 最差适应算法（Worst-fit）
  最差适应算法（Worst-fit）就是在遍历空闲链表的时候，找出空闲链表中最大的分块，将其分割给申请的对象，其目的就是使得分割后分块的最大化，以便下次好分配，不过这种分配算法很容易产生很多很小的分块，这些分块也不能被使用

3.2、标记-复制(Mark-Copying)

将内存划分为两块相等的区域，每次只使用其中一块，当其中一块内存使用完了，就将还存活的对象复制到另外一块上面，然后把已经使用过的内存空间一次清除掉。如下图所示：

缺点:

1. 空间利用率降低。

3.3、标记-整理(Mark-Compact)

与"标记-清除"算法一样，但是后续步骤不是直接对可回收对象进行清理，而是让所有存活的对象都向一端移动，然后直接清理掉端边界以外的内存。

3.4、分代收集算法

既然上面介绍了3中垃圾收集算法，那么在堆内存中到底用哪一个呢？

Young区：复制算法(对象在被分配之后，生命周期比较短，Young区复制效率比较高)

Old区：标记清除或标记整理(Old区对象存活时间比较长，复制来复制去没必要，不如做个标记再清理)

3.5、三色标记

在并发标记的过程中，因为标记期间应用线程还在继续跑，对象间的引用可能发生变化，多标和漏标的情况就有可能发生。
三色标记是把gc roots可达性分析遍历对象过程中遇到的对象， 按照“是否访问过”这个条件标记成以下三种颜色：

• 黑色： 表示对象已经被垃圾收集器访问过， 且这个对象的所有引用都已经扫描过，它是安全存活的。
• 灰色： 表示对象已经被垃圾收集器访问过， 但是至少存在一个引用还未被扫描过。
• 白色： 表示对象尚未被垃圾收集器访问过。

标记过程：

1. 初识时，所有对象都在【白色集合中】
2. 将GC Roots 直接引用到的对象 挪到 【灰色集合】中；
3. 从灰色集合中获取对象：将本对象 引用到的 其他对象 全部挪到 【灰色集合】中。
4. 直至【灰色集合】为空时结束，将本对象 挪到 【黑色集合】里面。

结束后，仍在【白色集合】的对象即为GC Roots 不可达，可以进行回收

4、什么是STW（stop the world）？

Stop-The-World 简称 STW。是在垃圾回收算法执行过程中，所有的线程都是停止运行的（表现就是程序没响应 ），直到GC线程结束才会继续任务。

STW是不可避免的，最好的解决办法就是减少停顿的时间，GC各种算法的优化重点就是为了减少STW，这也是JVM调优的重点。

5、你知道哪些垃圾收集器？

如果说收集算法是内存回收的方法论，那么垃圾收集器就是内存回收的具体实现。

5.1、Serial

Serial收集器是最基本、发展历史最悠久的收集器，曾经（在JDK1.3.1之前）是虚拟机新生代收集的唯一选择。

它是一种单线程收集器，不仅仅意味着它只会使用一个CPU或者一条收集线程去完成垃圾收集工作，更重要的是其在进行垃圾收集的时候需要暂停其他线程。

优点：简单高效，拥有很高的单线程收集效率
缺点：收集过程需要暂停所有线程
算法：复制算法
适用范围：新生代
应用：Client模式下的默认新生代收集器

5.2、Serial Old

Serial Old收集器是Serial收集器的老年代版本，也是一个单线程收集器，不同的是采用"标记-整理算法"，运行过程和Serial收集器一样。

5.3、ParNew

可以把这个收集器理解为Serial收集器的多线程版本。

优点：在多CPU时，比Serial效率高。
缺点：收集过程暂停所有应用程序线程，单CPU时比Serial效率差。
算法：复制算法
适用范围：新生代
应用：运行在Server模式下的虚拟机中首选的新生代收集器

5.4、Parallel Scavenge

Parallel Scavenge收集器是一个新生代收集器，它也是使用复制算法的收集器，又是并行的多线程收集器，看上去和ParNew一样，但是Parallel Scanvenge更关注系统的吞吐量。

吞吐量=运行用户代码的时间/(运行用户代码的时间+垃圾收集时间)

比如虚拟机总共运行了100分钟，垃圾收集时间用了1分钟，吞吐量=(100-1)/100=99%。

若吞吐量越大，意味着垃圾收集的时间越短，则用户代码可以充分利用CPU资源，尽快完成程序的运算任务。

-XX:MaxGCPauseMillis控制最大的垃圾收集停顿时间，
-XX:GCRatio直接设置吞吐量的大小。

5.5、Parallel Old

Parallel Old收集器是Parallel Scavenge收集器的老年代版本，使用多线程和标记-整理算法进行垃圾回收，也是更加关注系统的吞吐量。

5.6、CMS

官网： https://docs.oracle.com/javase/8/docs/technotes/guides/vm/gctuning/cms.html#concurrent_mark_sweep_cms_collector

CMS(Concurrent Mark Sweep)收集器是一种以获取 最短回收停顿时间为目标的收集器。

采用的是"标记-清除算法",整个过程分为4步

(1)初始标记 CMS initial mark     标记GC Roots直接关联对象，不用Tracing，速度很快
(2)并发标记 CMS concurrent mark  进行GC Roots Tracing
(3)重新标记 CMS remark           修改并发标记因用户程序变动的内容
(4)并发清除 CMS concurrent sweep 清除不可达对象回收空间，同时有新垃圾产生，留着下次清理称为浮动垃圾

由于整个过程中，并发标记和并发清除，收集器线程可以与用户线程一起工作，所以总体上来说，CMS收集器的内存回收过程是与用户线程一起并发地执行的。

优点：并发收集、低停顿
缺点：产生大量空间碎片、并发阶段会降低吞吐量

5.7、G1(Garbage-First)

官网： https://docs.oracle.com/javase/8/docs/technotes/guides/vm/gctuning/g1_gc.html#garbage_first_garbage_collection

**使用G1收集器时，Java堆的内存布局与就与其他收集器有很大差别，它将整个Java堆划分为多个大小相等的独立区域（Region），虽然还保留有新生代和老年代的概念，但新生代和老年代不再是物理隔离的了，它们都是一部分Region（不需要连续）的集合。 **

每个Region大小都是一样的，可以是1M到32M之间的数值，但是必须保证是2的n次幂

如果对象太大，一个Region放不下[超过Region大小的50%]，那么就会直接放到H中

设置Region大小：-XX:G1HeapRegionSize=M

所谓Garbage-Frist，其实就是优先回收垃圾最多的Region区域

其优点为：

（1）分代收集（仍然保留了分代的概念）
（2）空间整合（整体上属于“标记-整理”算法，不会导致空间碎片）
（3）可预测的停顿（比CMS更先进的地方在于能让使用者明确指定一个长度为M毫秒的时间片段内，消耗在垃圾收集上的时间不得超过N毫秒）

工作过程可以分为如下几步

初始标记（Initial Marking）      标记以下GC Roots能够关联的对象，并且修改TAMS的值，需要暂停用户线程
并发标记（Concurrent Marking）   从GC Roots进行可达性分析，找出存活的对象，与用户线程并发执行
最终标记（Final Marking）        修正在并发标记阶段因为用户程序的并发执行导致变动的数据，需暂停用户线程
筛选回收（Live Data Counting and Evacuation） 对各个Region的回收价值和成本进行排序，根据用户所期望的GC停顿时间制定回收计划

5.8、ZGC

官网： https://docs.oracle.com/en/java/javase/11/gctuning/z-garbage-collector1.html#GUID-A5A42691-095E-47BA-B6DC-FB4E5FAA43D0

JDK11新引入的ZGC收集器，不管是物理上还是逻辑上，ZGC中已经不存在新老年代的概念了

会分为一个个page，当进行GC操作时会对page进行压缩，因此没有碎片问题

只能在64位的linux上使用，目前用得还比较少

其优点为：

（1）可以达到10ms以内的停顿时间要求
（2）支持TB级别的内存
（3）堆内存变大后停顿时间还是在10ms以内