JVM垃圾收集上（概述和算法）

1.什么是垃圾？

2.为什么需要垃圾收集

3.发展里程

4.垃圾回收的好处

5.垃圾回收算法

5.1 标记阶段

5.1.1 引用计数算法(GC没有该类算法)

5.1.2 可达性分析算法

5.1.2.1 可达性分析

5.1.2.2 如何找GC Roots

5.1.3 如何标记（finalization方法）

5.2 清除阶段

5.2.1 标记-清除算法(Mark-Sweep)

5.2.2 复制算法(Copying)

5.2.3 标记-压缩算法(Mark-Compact)

5.3 其他算法

5.3.1 分代收集算法

5.3.2 增量收集算法和分区算法

5.3.2.1 增量收集算法

5.3.2.2 增量收集算法

1.什么是垃圾？

• 垃圾是指在运行程序中没有任何指针指向的对象，这个对象就是需要被回收的垃圾。

• 官网解释:An object is considered garbage when it can no longer be reached from any pointer in the running program.

2.为什么需要垃圾收集

​ 不及时对内存中的垃圾进行清理，那么，这些垃圾对象所占的内存空间会一直保留到应用程序结束，被保留的空间无法被其他对象使用。甚至可能导致内存溢出。

3.发展里程

1. 早期C/C++时代垃圾回收基本上是手工进行的，可以灵活控制内存释放的时间，但是会给开发人员带来频繁申请和释放内存的管理负担。
2. 自动垃圾回收
3. 自动垃圾回收成为标准

4.垃圾回收的好处

自动内存管理的优点

1. 自动内存管理，无需开发人员手动参与内存的分配与回收，这样降低内存泄漏和内存溢出的风险
2. 没有垃圾回收器，java也会和cpp一样，各种悬垂指针，野指针，泄露问题让你头疼不已。
3. 自动内存管理机制，将程序员从繁重的内存管理中释放出来，可以更专心地专注于业务开发

GC 的作用区域

1. 垃圾收集器可以对年轻代回收，也可以对老年代回收，甚至是全栈和方法区的回收，其中，Java堆是垃圾收集器的工作重点
2. 从次数上讲：
   1. 频繁收集Young区
   2. 较少收集Old区
   3. 基本不收集Perm区（元空间）
3. GC主要关注于方法区和堆中的垃圾收集

5.垃圾回收算法

​ JVM四大算法

1. 引用计数器算法(JAVA不使用该算法)
2. 标记-清除算法
3. 复制算法
4. 标记-压缩算法

5.1 标记阶段

标记阶段目的：判断对象是否存活

判断对象存活两种方式：引用计数算法和可达性分析算法

5.1.1 引用计数算法(GC没有该类算法)

本质:对象中有一个引用计算器若该对象被引用一次则计算器加1，若引用失效则减一，若引用计数器为0则进行回收

1. 优点：实现简单，垃圾对象便于辨识；判定效率高，回收没有延迟性。
2. 缺点：
   • 它需要单独的字段存储计数器，这样的做法增加了存储空间的开销。
   • 每次赋值都需要更新计数器，伴随着加法和减法操作，这增加了时间开销。
   • 引用计数器有一个严重的问题，即无法处理循环引用的情况。这是一条致命缺陷，导致在JVM内存溢出。

5.1.2 可达性分析算法

5.1.2.1

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

1. 相对于引用计数算法而言，可达性分析算法不仅同样具备实现简单和执行高效等特点，更重要的是该算法可以有效地解决在引用计数算法中循环引用的问题，防止内存泄漏的发生。
2. 相较于引用计数算法，这里的可达性分析就是Java、C#选择的。这种类型的垃圾收集通常也叫作追踪性垃圾收集（Tracing Garbage Collection）

原理思路

1. 可达性分析算法是以根对象集合（GCRoots）为起始点，按照从上至下的方式搜索被根对象集合所连接的目标对象是否可达。
2. 使用可达性分析算法后，内存中的存活对象都会被根对象集合直接或间接连接着，搜索所走过的路径称为引用链（Reference Chain）
3. 如果目标对象没有任何引用链相连，则是不可达的，就意味着该对象己经死亡，可以标记为垃圾对象。
4. 在可达性分析算法中，只有能够被根对象集合直接或者间接连接的对象才是存活对象

• GC Roots可以是哪些元素？总体可以称为:mutator(不准确)****

1. 虚拟机栈中引用的对象，比如：各个线程被调用的方法中使用到的参数、局部变量等。
2. 本地方法栈内JNI（通常说的本地方法）引用的对象方法区中类静态属性引用的对象，比如：Java类的引用类型静态变量
3. 方法区中常量引用的对象，比如：字符串常量池（StringTable）里的引用
4. 所有被同步锁synchronized持有的对象
5. Java虚拟机内部的引用。
6. 基本数据类型对应的Class对象，一些常驻的异常对象（如：NullPointerException、OutofMemoryError），系统类加载器。
7. 反映java虚拟机内部情况的JMXBean、JVMTI中注册的回调、本地代码缓存等。

这…这么多记不住呀,来个小总结(不清不楚,慢慢了解)

1. 总结一句话就是，除了堆空间外的一些结构，比如：虚拟机栈、本地方法栈、方法区、字符串常量池等地方对堆空间进行引用的，都可以作为GC Roots进行可达性分析
2. 除了这些固定的GC Roots集合以外，根据用户所选用的垃圾收集器以及当前回收的内存区域不同，还可以有其他对象“临时性”地加入，共同构成完整GC Roots集合。比如：分代收集和局部回收（PartialGC）。
3. 如果只针对Java堆中的某一块区域进行垃圾回收（比如：典型的只针对新生代），必须考虑到内存区域是虚拟机自己的实现细节，更不是孤立封闭的，这个区域的对象完全有可能被其他区域的对象所引用，这时候就需要一并将关联的区域对象也加入GC Roots集合中去考虑，才能保证可达性分析的准确性。
4. 由于Root采用栈方式存放变量和指针，所以如果一个指针，它保存了堆内存里面的对象，但是自己又不存放在堆内存里面，那它就是一个Root。

可达性分析算法的注意事项

1. 如果要使用可达性分析算法来判断内存是否可回收，那么分析工作必须在一个能保障一致性的快照中进行。这点不满足的话分析结果的准确性就无法保证。
2. 这点也是导致GC进行时必须“Stop The World”的一个重要原因。即使是号称（几乎）不会发生停顿的CMS收集器中，枚举根节点时也是必须要停顿的。

5.1.2.2 如何找GC Roots

• MAT
• demo文件
  1. 命令行使用jmap
  2. JVisualVM
  3. Jprofiler

5.1.3 如何标记（finalization方法）

Object 类中 finalize() 源码

// 等待被重写
protected void finalize() throws Throwable { }

finalize() 方法为回调函数:

• 提供自定义处理逻辑，可重写finalize方法
• 若对象没有被引用–>则对象为垃圾–>回收前调用该方法(我的理解是:第二次标记作用)

注意事项:

• 不主动调用
  1. 主动调用会导致对象复活。
  2. 若不发生GC，则finalize()方法将没有执行机会。
  3. 优先级低，不会直接回收。
• 一个糟糕的finalize()会严重影响GC的性能。
• Java采用的是基于垃圾回收器的自动内存管理机制

说了这么多finalize()不主动使用，那它是不是没有用呢？

答案是不是。下面请了解finalize()的执行流程及会对象的三种状态。

三种状态

由于finalize()方法的存在，虚拟机中的对象一般处于三种可能的状态。

1. 可触及的：从根节点开始，可以到达这个对象。
2. 可复活的：对象的所有引用都被释放，但是对象有可能在finalize()中复活。
3. 不可触及的：对象的finalize()被调用，并且没有复活，那么就会进入不可触及状态。不可触及的对象不可能被复活，因为finalize()只会被调用一次。

根节点??不了解的同学可以先看看可达性分析。

执行过程

(1) 首先，大致描述一下finalize流程：当对象变成(GC Roots)不可达时，GC会判断该对象是否覆盖了finalize方法，若未覆盖，则直接将其回收。否则，若对象未执行过finalize方法，将其放入F-Queue队列，由一低优先级线程执行该队列中对象的finalize方法。执行finalize方法完毕后，GC会再次判断该对象是否可达，若不可达，则进行回收，否则，对象“复活”。

(2) 具体的finalize流程：

注意:一个对象finalize()只能执行一次!!!

​ 可触及对象不会触发finalize方法

1. 如果对象objA到GC Roots没有引用链(不可触及对象临死挣扎)，则进行第一次标记。
2. 不可触及对象是否执行finalize方法。
   • 若没有执行或已经执行过–>对象视为垃圾
   • 若对象重写了finalize方法且还未执行–>对象放到–F-Queue队列中触发finalize方法执行。
3. GC对F-Queue队列中对象进行第二次标记,标记对象与引用链任何对象建立联系–>成功复活，避免垃圾回收。
4. 之后再没有被引用或与引用链没有联系–>对象变为不可触及状态–>等着被回收。

5.2 清除阶段

5.2.1 标记-清除算法(Mark-Sweep)

原理

标记-清除算法分为两个阶段，标记(mark)和清除(sweep).

在标记阶段，collector从mutator根对象开始进行遍历，对从mutator根对象可以访问到的对象都打上一个标识，一般是在对象的header中，将其记录为可达对象。

而在清除阶段，collector对堆内存(heap memory)从头到尾进行线性的遍历，如果发现某个对象没有标记为可达对象-通过读取对象的header信息，则就将其回收。

清除的两种方式

1. 如果内存规整
   • 采用指针碰撞的方式进行内存分配
2. 如果内存不规整
   • 虚拟机需要维护一个空闲列表
   • 采用空闲列表分配内存

缺点

1. 标记清除算法的效率不算高
2. 在进行GC的时候，需要停止整个应用程序，用户体验较差
3. 这种方式清理出来的空闲内存是不连续的，产生内碎片，需要维护一个空闲列表

5.2.2 复制算法(Copying)

原理

将活着的内存空间分为两块，每次只使用其中一块，在垃圾回收时将正在使用的内存中的存活对象复制到未被使用的内存块中，之后清除正在使用的内存块中的所有对象，交换两个内存的角色，最后完成垃圾回收。

应用

Young区的Survivor0和Survivor1区

1. 如果系统中的垃圾对象很多，复制算法需要复制的存活对象数量并不会太大，效率较高
2. 老年代大量的对象存活，那么复制的对象将会有很多，效率会很低
3. 在新生代，对常规应用的垃圾回收，一次通常可以回收70% - 99% 的内存空间。回收性价比很高。所以现在的商业虚拟机都是用这种收集算法回收新生代。

优缺点

优点

1. 没有标记和清除过程，实现简单，运行高效
2. 复制过去以后保证空间的连续性，不会出现“碎片”问题。

---

缺点

1. 此算法的缺点也是很明显的，就是需要两倍的内存空间。
2. 对于G1这种分拆成为大量region的GC，复制而不是移动，意味着GC需要维护region之间对象引用关系，不管是内存占用或者时间开销也不小

5.2.3 标记-压缩算法(Mark-Compact)

原理

结合前面两种算法先标记后复制整理

执行流程

1. 第一阶段和标记清除算法一样，从根节点开始标记所有被引用对象
2. 第二阶段将所有的存活对象压缩到内存的一端，按顺序排放。之后，清理边界外所有的空间。

优缺点

优点

1. 消除了标记-清除算法当中，内存区域分散的缺点，我们需要给新对象分配内存时，JVM只需要持有一个内存的起始地址即可。
2. 消除了复制算法当中，内存减半的高额代价。

---

缺点

1. 从效率上来说，标记-整理算法要低于复制算法。
2. 移动对象的同时，如果对象被其他对象引用，则还需要调整引用的地址
3. 移动过程中，需要全程暂停用户应用程序。即：STW

对比三种清除阶段的算法

	标记清除	标记整理	复制
速率	中等	最慢	最快
空间开销	少（但会堆积碎片）	少（不堆积碎片）	通常需要活对象的2倍空间（不堆积碎片）
移动对象	否	是	是

5.3 其他算法

5.3.1 分代收集算法

分代收集算法的分代依据

目前几乎所有的GC都采用分代手机算法执行垃圾回收的

在HotSpot中，基于分代的概念，GC所使用的内存回收算法必须结合年轻代和老年代各自的特点。

1. 年轻代（Young Gen）
   • 年轻代特点：区域相对老年代较小，对象生命周期短、存活率低，回收频繁。
   • 这种情况复制算法的回收整理，速度是最快的。复制算法的效率只和当前存活对象大小有关，因此很适用于年轻代的回收。而复制算法内存利用率不高的问题，通过hotspot中的两个survivor的设计得到缓解。
2. 老年代（Tenured Gen）
   • 老年代特点：区域较大，对象生命周期长、存活率高，回收不及年轻代频繁。
   • 这种情况存在大量存活率高的对象，复制算法明显变得不合适。一般是由标记-清除或者是标记-清除与标记-整理的混合实现。
     • Mark阶段的开销与存活对象的数量成正比。
     • Sweep阶段的开销与所管理区域的大小成正相关。
     • Compact阶段的开销与存活对象的数据成正比。

Hotspot CMS 回收器

1. 以HotSpot中的CMS回收器为例，CMS是基于Mark-Sweep实现的，对于对象的回收效率很高。
2. 对于碎片问题，CMS采用基于Mark-Compact算法的Serial Old回收器作为补偿措施：当内存回收不佳（碎片导致的Concurrent Mode Failure时），将采用Serial Old执行Full GC以达到对老年代内存的整理。
3. 分代的思想被现有的虚拟机广泛使用。几乎所有的垃圾回收器都区分新生代和老年代

5.3.2 增量收集算法和分区算法

5.3.2.1 增量收集算法

增量收集算法

1. 上述现有的算法，在垃圾回收过程中，应用软件将处于一种Stop the World的状态。在Stop the World状态下，应用程序所有的线程都会挂起，暂停一切正常的工作，等待垃圾回收的完成。
2. 如果垃圾回收时间过长，应用程序会被挂起很久，将严重影响用户体验或者系统的稳定性。为了解决这个问题，即对实时垃圾收集算法的研究直接导致了增量收集（Incremental Collecting）算法的诞生。

增量收集算法的基本思想

1. 如果一次性将所有的垃圾进行处理，需要造成系统长时间的停顿，那么就可以让垃圾收集线程和应用程序线程交替执行。每次，垃圾收集线程只收集一小片区域的内存空间，接着切换到应用程序线程。依次反复，直到垃圾收集完成。
2. 总的来说，增量收集算法的基础仍是传统的标记-清除和复制算法。增量收集算法通过对线程间冲突的妥善处理，允许垃圾收集线程以分阶段的方式完成标记、清理或复制工作

增量收集算法的缺点

1. 使用这种方式，由于在垃圾回收过程中，间断性地还执行了应用程序代码，所以能减少系统的停顿时间。
2. 但是，因为线程切换和上下文转换的消耗，会使得垃圾回收的总体成本上升，造成系统吞吐量的下降。

5.3.2.2 增量收集算法

1. 一般来说，在相同条件下，堆空间越大，一次GC时所需要的时间就越长，有关GC产生的停顿也越长。
2. 为了更好地控制GC产生的停顿时间，将一块大的内存区域分割成多个小块，根据目标的停顿时间，每次合理地回收若干个小区间，而不是整个堆空间，从而减少一次GC所产生的停顿。
3. 分代算法将按照对象的生命周期长短划分成两个部分，分区算法将整个堆空间划分成连续的不同小区间。每一个小区间都独立使用，独立回收。这种算法的好处是可以控制一次回收多少个小区间。