常见面试题之垃圾收回

1. 简述`Java`垃圾回收机制？（`GC`是什么？为什么要`GC`？）

为了让程序员更专注于代码的实现，而不用过多的考虑内存释放的问题，所以，在Java语言中，有了自动的垃圾回收机制，也就是我们熟悉的GC(Garbage Collection)。

有了垃圾回收机制后，程序员只需要关心内存的申请即可，内存的释放由系统自动识别完成。

在进行垃圾回收时，不同的对象引用类型，GC会采用不同的回收时机。

换句话说，自动的垃圾回收的算法就会变得非常重要了，如果因为算法的不合理，导致内存资源一直没有释放，同样也可能会导致内存溢出的。

当然，除了Java语言，C#、Python等语言也都有自动的垃圾回收机制。

2. 对象什么时候可以被垃圾器回收？

在这里插入图片描述

简单一句就是：如果一个或多个对象没有任何的引用指向它了，那么这个对象现在就是垃圾，如果定位了垃圾，则有可能会被垃圾回收器回收。

如果要定位什么是垃圾，有两种方式来确定，第一个是引用计数法，第二个是可达性分析算法。

2.1 引用计数法

一个对象被引用了一次，在当前的对象头上递增一次引用次数，如果这个对象的引用次数为0，代表这个对象可回收。

String demo = new String("123");

在这里插入图片描述

String demo = null;

在这里插入图片描述

当对象间出现了循环引用的话，则引用计数法就会失效。

在这里插入图片描述

先执行右侧代码的前4行代码。

在这里插入图片描述

目前上方的引用关系和计数都是没问题的，但是，如果代码继续往下执行，如下图：

在这里插入图片描述

虽然a和b都为null，但是由于a和b存在循环引用，这样a和b永远都不会被回收。

优点：

实时性较高，无需等到内存不够的时候，才开始回收，运行时根据对象的计数器是否为0，就可以直接回收。
在垃圾回收过程中，应用无需挂起。如果申请内存时，内存不足，则立刻报OOM错误。
区域性，更新对象的计数器时，只是影响到该对象，不会扫描全部对象。

缺点：

每次对象被引用时，都需要去更新计数器，有一点时间开销。
浪费CPU资源，即使内存够用，仍然在运行时进行计数器的统计。
无法解决循环引用问题，会引发内存泄露。（最大的缺点）。

2.2 可达性分析算法

现在的虚拟机采用的都是通过可达性分析算法来确定哪些内容是垃圾。

会存在一个根节点【GC Roots】，引出它下面指向的下一个节点，再以下一个节点节点开始找出它下面的节点，依次往下类推。直到所有的节点全部遍历完毕。

根对象是那些肯定不能当做垃圾回收的对象，就可以当做根对象。

局部变量，静态方法，静态变量，类信息。

核心是：判断某对象是否与根对象有直接或间接的引用，如果没有被引用，则可以当做垃圾回收。

在这里插入图片描述

X,Y这两个节点是可回收的，但是并不会马上的被回收！！ 对象中存在一个方法【finalize】。当对象被标记为可回收后，当发生GC时，首先会判断这个对象是否执行了finalize方法，如果这个方法还没有被执行的话，那么就会先来执行这个方法，接着在这个方法执行中，可以设置当前这个对象与GC ROOTS产生关联，那么这个方法执行完成之后，GC会再次判断对象是否可达，如果仍然不可达，则会进行回收，如果可达了，则不会进行回收。

finalize方法对于每一个对象来说，只会执行一次。如果第一次执行这个方法的时候，设置了当前对象与RC ROOTS关联，那么这一次不会进行回收。那么等到这个对象第二次被标记为可回收时，那么该对象的finalize方法就不会再次执行了。

GC ROOTS：

虚拟机栈（栈帧中的本地变量表）中引用的对象。

/**
 * demo是栈帧中的本地变量，当 demo = null 时，由于此时 demo 充当了 GC Root 的作用，demo与原来指向的实例 new Demo() 断开了连接，对象被回收。
 */
public class Demo {
    public static  void main(String[] args) {
    	Demo demo = new Demo();
    	demo = null;
    }
}

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

/**
 * 当栈帧中的本地变量 b = null 时，由于 b 原来指向的对象与 GC Root (变量 b) 断开了连接，所以 b 原来指向的对象会被回收，而由于我们给 a 赋值了变量的引用，a在此时是类静态属性引用，充当了 GC Root 的作用，它指向的对象依然存活!
 */
public class Demo {
    public static Demo a;
    public static  void main(String[] args) {
        Demo b = new Demo();
        b.a = new Demo();
        b = null;
    }
}

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

/**
 * 常量 a 指向的对象并不会因为 demo 指向的对象被回收而回收
 */
public class Demo {
    
    public static final Demo a = new Demo();
    
    public static  void main(String[] args) {
        Demo demo = new Demo();
        demo = null;
    }
}

本地方法栈中JNI（即一般说的Native方法）引用的对象。

3. `JVM`垃圾回收算法有哪些？

3.1 标记清除算法

标记清除算法，是将垃圾回收分为2个阶段，分别是标记和清除。

1.根据可达性分析算法得出的垃圾进行标记。

2.对这些标记为可回收的内容进行垃圾回收。

在这里插入图片描述

可以看到，标记清除算法解决了引用计数算法中的循环引用的问题，没有从root节点引用的对象都会被回收。

同样，标记清除算法也是有缺点的：

效率较低，标记和清除两个动作都需要遍历所有的对象，并且在GC时，需要停止应用程序，对于交互性要求比较高的应用而言这个体验是非常差的。
（重要）通过标记清除算法清理出来的内存，碎片化较为严重，因为被回收的对象可能存在于内存的各个角落，所以清理出来的内存是不连贯的。

3.2 复制算法

复制算法的核心就是，将原有的内存空间一分为二，每次只用其中的一块，在垃圾回收时，将正在使用的对象复制到另一个内存空间中，然后将该内存空间清空，交换两个内存的角色，完成垃圾的回收。

如果内存中的垃圾对象较多，需要复制的对象就较少，这种情况下适合使用该方式并且效率比较高，反之，则不适合。

在这里插入图片描述

1）将内存区域分成两部分，每次操作其中一个。

2）当进行垃圾回收时，将正在使用的内存区域中的存活对象移动到未使用的内存区域。当移动完对这部分内存区域一次性清除。

3）周而复始。

优点：

在垃圾对象多的情况下，效率较高。
清理后，内存无碎片。

缺点：

分配的2块内存空间，在同一个时刻，只能使用一半，内存使用率较低。

3.3 标记整理算法

标记压缩算法是在标记清除算法的基础之上，做了优化改进的算法。和标记清除算法一样，也是从根节点开始，对对象的引用进行标记，在清理阶段，并不是简单的直接清理可回收对象，而是将存活对象都向内存另一端移动，然后清理边界以外的垃圾，从而解决了碎片化的问题。
在这里插入图片描述

1）标记垃圾。

2）需要清除向右边走，不需要清除的向左边走。

3）清除边界以外的垃圾。

优缺点同标记清除算法，解决了标记清除算法的碎片化的问题，同时，标记压缩算法多了一步，对象移动内存位置的步骤，其效率也有有一定的影响。

与复制算法对比：复制算法标记完就复制，但标记整理算法得等把所有存活对象都标记完毕，再进行整理。

4. 分代收集算法

4.1 概述

在java 8时，堆被分为了两份：新生代和老年代【1：2】，在java 7时，还存在一个永久代。

在这里插入图片描述

对于新生代，内部又被分为了三个区域。Eden区，S0区，S1区【8：1：1】。

当对新生代产生GC：MinorGC【young GC】。

当对老年代代产生GC：Major GC 。

当对新生代和老年代产生FullGC：新生代 + 老年代完整垃圾回收，暂停时间长，应尽力避免。

4.2工作机制

在这里插入图片描述

新创建的对象，都会先分配到eden区。

在这里插入图片描述

当伊甸园内存不足，标记伊甸园与from（现阶段没有）的存活对象。
将存活对象采用复制算法复制到to中，复制完毕后，伊甸园和from内存都得到释放。

在这里插入图片描述

经过一段时间后伊甸园的内存又出现不足，标记eden区域to区存活的对象，将存活的对象复制到from区。

在这里插入图片描述

当幸存区对象熬过几次回收（最多15次），晋升到老年代（幸存区内存不足或大对象会导致提前晋升）。

MinorGC、 Mixed GC 、 FullGC的区别是什么？

在这里插入图片描述

MinorGC【young GC】发生在新生代的垃圾回收，暂停时间短（STW）
Mixed GC 新生代 + 老年代部分区域的垃圾回收，G1收集器特有。
FullGC：新生代 + 老年代完整垃圾回收，暂停时间长（STW），应尽力避免？

名词解释：

STW（Stop-The-World）：暂停所有应用程序线程，等待垃圾回收的完成。

5. 说一下`JVM`有哪些垃圾回收器？

在jvm中，实现了多种垃圾收集器，包括：

串行垃圾收集器
并行垃圾收集器
CMS（并发）垃圾收集器
G1垃圾收集器

5.1 串行垃圾收集器

Serial和Serial Old串行垃圾收集器，是指使用单线程进行垃圾回收，堆内存较小，适合个人电脑。

Serial作用于新生代，采用复制算法。
Serial Old作用于老年代，采用标记-整理算法。

垃圾回收时，只有一个线程在工作，并且java应用中的所有线程都要暂停（STW），等待垃圾回收的完成。

在这里插入图片描述

5.2 并行垃圾收集器

Parallel New和Parallel Old是一个并行垃圾回收器，JDK8默认使用此垃圾回收器。

Parallel New作用于新生代，采用复制算法。
Parallel Old作用于老年代，采用标记-整理算法。

垃圾回收时，多个线程在工作，并且java应用中的所有线程都要暂停（STW），等待垃圾回收的完成。

在这里插入图片描述

5.2 `CMS`（并发）垃圾收集器

CMS全称Concurrent Mark Sweep，是一款并发的、使用标记-清除算法的垃圾回收器，该回收器是针对老年代垃圾回收的，是一款以获取最短回收停顿时间为目标的收集器，停顿时间短，用户体验就好。其最大特点是在进行垃圾回收时，应用仍然能正常运行。

在这里插入图片描述

6. 详细聊一下`G1`垃圾回收器？

6.1 概述

应用于新生代和老年代，在JDK9之后默认使用G1。
划分成多个区域，每个区域都可以充当eden，survivor，old，humongous，其中humongous专为大对象准备。
采用复制算法。
响应时间与吞吐量兼顾。
分成三个阶段：新生代回收、并发标记、混合收集。
如果并发失败（即回收速度赶不上创建新对象速度），会触发Full GC。

在这里插入图片描述

6.2 `Young Collection`(年轻代垃圾回收)

初始时，所有区域都处于空闲状态。
创建了一些对象，挑出一些空闲区域作为伊甸园区存储这些对象。
当伊甸园需要垃圾回收时，挑出一个空闲区域作为幸存区，用复制算法复制存活对象，需要暂停用户线程。
随着时间流逝，伊甸园的内存又有不足。
将伊甸园以及之前幸存区中的存活对象，采用复制算法，复制到新的幸存区，其中较老对象晋升至老年代。

6.3 `Young Collection + Concurrent Mark` (年轻代垃圾回收+并发标记)

当老年代占用内存超过阈值(默认是45%)后，触发并发标记，这时无需暂停用户线程。

在这里插入图片描述

并发标记之后，会有重新标记阶段解决漏标问题，此时需要暂停用户线程。
这些都完成后就知道了老年代有哪些存活对象，随后进入混合收集阶段。此时不会对所有老年代区域进行回收，而是根据暂停时间目标优先回收价值高（存活对象少）的区域（这也是Gabage First名称的由来）。

6.4 `Mixed Collection` (混合垃圾回收)

复制完成，内存得到释放。进入下一轮的新生代回收、并发标记、混合收集。

在这里插入图片描述

其中H叫做巨型对象，如果对象非常大，会开辟一块连续的空间存储巨型对象。

在这里插入图片描述

7. 强引用、软引用、弱引用、虚引用的区别？

7.1 强引用

强引用：只有所有GC Roots对象都不通过【强引用】引用该对象，该对象才能被垃圾回收。

User user = new User();

在这里插入图片描述

7.2 软引用

软引用：仅有软引用引用该对象时，在垃圾回收后，内存仍不足时会再次出发垃圾回收。

User user = new User();
SoftReference softReference = new SoftReference(user);

在这里插入图片描述

7.3 弱引用

弱引用：仅有弱引用引用该对象时，在垃圾回收时，无论内存是否充足，都会回收弱引用对象。

User user = new User();
WeakReference weakReference = new WeakReference(user);

在这里插入图片描述

延伸话题：ThreadLocal内存泄漏问题

ThreadLocal用的就是弱引用，看以下源码：

static class Entry extends WeakReference<ThreadLocal<?>> {
    Object value;

    Entry(ThreadLocal<?> k, Object v) {
         super(k);
         value = v; //强引用，不会被回收
     }
}

Entry的key是当前ThreadLocal，value值是我们要设置的数据。

WeakReference表示的是弱引用，当JVM进行GC时，一旦发现了只具有弱引用的对象，不管当前内存空间是否足够，都会回收它的内存。但是value是强引用，它不会被回收掉。

ThreadLocal使用建议：使用完毕后注意调用清理方法。

7.4 虚引用

虚引用：必须配合引用队列使用，被引用对象回收时，会将虚引用入队，由Reference Handler线程调用虚引用相关方法释放直接内存。

在这里插入图片描述

8. 面试现场

8.1 简述`Java`垃圾回收机制？（`GC`是什么？为什么要`GC`？）

有了垃圾回收机制后，程序员只需要关心内存的申请即可，内存的释放由系统自动识别完成。

在进行垃圾回收时，不同的对象引用类型，GC会采用不同的回收时机。

8.2 强引用、软引用、弱引用、虚引用的区别？

强引用最为普通的引用方式，表示一个对象处于有用且必须的状态，如果一个对象具有强引用，则GC并不会回收它。即便堆中内存不足了，宁可出现OOM，也不会对其进行回收。

软引用表示一个对象处于有用且非必须状态，如果一个对象处于软引用，在内存空间足够的情况下，GC机制并不会回收它，而在内存空间不足时，则会在OOM异常出现之间对其进行回收。但值得注意的是，因为GC线程优先级较低，软引用并不会立即被回收。

弱引用表示一个对象处于可能有用且非必须的状态。在GC线程扫描内存区域时，一旦发现弱引用，就会回收到弱引用相关联的对象。对于弱引用的回收，无关内存区域是否足够，一旦发现则会被回收。同样的，因为GC线程优先级较低，所以弱引用也并不是会被立刻回收。

虚引用表示一个对象处于无用的状态。在任何时候都有可能被垃圾回收。虚引用的使用必须和引用队列Reference Queue联合使用。

8.3 对象什么时候可以被垃圾器回收？

如果一个或多个对象没有任何的引用指向它了，那么这个对象现在就是垃圾，如果定位了垃圾，则有可能会被垃圾回收器回收。

如果要定位什么是垃圾，有两种方式来确定，第一个是引用计数法，第二个是可达性分析算法。

通常都使用可达性分析算法来确定是不是垃圾。

8.4 `JVM`垃圾回收算法有哪些？

我记得一共有四种，分别是标记清除算法、复制算法、标记整理算法、分代回收。

8.5 你能详细聊一下分代回收吗？

关于分代回收是这样的。

在java8时，堆被分为了两份：新生代和老年代，它们默认空间占用比例是1:2。

对于新生代，内部又被分为了三个区域。Eden区，S0区，S1区默认空间占用比例是8:1:1。

具体的工作机制是有些情况：

1）当创建一个对象的时候，那么这个对象会被分配在新生代的Eden区。当Eden区要满了时候，触发YoungGC。

2）当进行YoungGC后，此时在Eden区存活的对象被移动到S0区，并且当前对象的年龄会加1，清空Eden区。

3）当再一次触发YoungGC的时候，会把Eden区中存活下来的对象和S0中的对象，移动到S1区中，这些对象的年龄会加1，清空Eden区和S0区。

4）当再一次触发YoungGC的时候，会把Eden区中存活下来的对象和S1中的对象，移动到S0区中，这些对象的年龄会加1，清空Eden区和S1区。

5）对象的年龄达到了某一个限定的值（默认15岁 ），那么这个对象就会进入到老年代中。

当然也有特殊情况，如果进入Eden区的是一个大对象，在触发YoungGC的时候，会直接存放到老年代

当老年代满了之后，触发FullGC。FullGC同时回收新生代和老年代，当前只会存在一个FullGC的线程进行执行，其他的线程全部会被挂起。我们在程序中要尽量避免FullGC的出现。

8.6 讲一下新生代、老年代、永久代的区别？

新生代主要用来存放新生的对象。

老年代主要存放应用中生命周期长的内存对象。

永久代指的是永久保存区域。主要存放Class和Meta（元数据）的信息。在Java8中，永久代已经被移除，取而代之的是一个称之为“元数据区”（元空间）的区域。元空间和永久代类似，不过元空间与永久代之间最大的区别在于：元空间并不在虚拟机中，而是使用本地内存。因此，默认情况下，元空间的大小仅受本地内存的限制。