第四篇 Java垃圾回收相关算法 - 清除阶段

骑猪看日落 2022-11-03 11:16 217阅读 0赞

# 第四篇 Java垃圾回收相关算法 - 清除阶段 #

### 文章目录 ###

*  第四篇 Java垃圾回收相关算法 - 清除阶段
 *  前言
 *  一、标记清除算法
 *   *  1.概述
     *  2.执行过程
     *  3.缺点
     *  4.什么是清除
 *  二、复制算法
 *   *  1.概述
     *  2.执行过程
     *  3.优点
     *  4.缺点
     *  5.应用场景
 *  三、标记压缩算法
 *   *  1.概述
     *  2.执行过程
     *  3.特点
     *  4.优点
     *  5.缺点
     *  6.指针碰撞(Bump the Pointer)
 *  四、三种算法的对比

# 前言 #

*  当成功区分出内存中存活对象和死亡对象后，GC接下来的任务就是执行垃圾回收，释放掉无用对象所占用的内存空间，以便有足够的可用内存空间为新对象分配内存。
 *  目前在JVM中比较常见的三种垃圾收集算法是标记-清除算法(Mark-Sweep)、复制算法(Copying)、标记-压缩算法(Mark-Compact)

# 一、标记清除算法 #

## 1.概述 ##

*  标记-清除算法(Mark-Sweep)是一种非常基础和常见的垃圾收集算法，该算法被J.McCarthy等人在1960年提出并应用于Lisp语言。

## 2.执行过程 ##

*  当堆中的有效内存空间(available memory) 被耗尽的时候，就会停止整个程序(也被称为stop the world) ，然后进行两项工作，第一项则是标记，第二项则是清除。  
    1）标记: Collector从引用根节点开始递归遍历，标记所有被引用的对象。一般是在对象的Header中记录为可达对象。  
    2）清除: Collector对堆内存从头到尾进行线性的遍历，如果发现某个对象在其Header中没有标记为可达对象，则将其回收。  
    ![标记清除算法的内存示意图][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW4xMzMzMzMzNjY3Nw_size_16_color_FFFFFF_t_70_pic_center]

## 3.缺点 ##

*  效率不算高
 *  在进行GC的时候，需要停止整个应用程序，导致用户体验差
 *  这种方式清理出来的空闲内存是不连续的，产生内存碎片。需要维护一个空闲列表

## 4.什么是清除 ##

*  这里所谓的清除并不是真的置空，而是把需要清除的对象地址保存在空闲的地址列表里。下次有新对象需要加载时，判断垃圾的位置空间是否够，如果够，就存放。

# 二、复制算法 #

## 1.概述 ##

*  为了解决标记-清除算法在垃圾收集效率方面的缺陷，M.L.Minsky于1963年发表了著名的论文，“使用双存储区的Lisp语言垃圾收集器CA，LISP Garbage Collector Algorithm Using SerialSecondary Storage )”。M.L.Minsk们称为复制(Copying) 算法，它也被M. L.Minsky本人成功地引入到了Lisp语言的一个实现版本中。

## 2.执行过程 ##

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

## 3.优点 ##

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

## 4.缺点 ##

*  此算法的缺点也是很明显的，就是需要两倍的内存空间。
 *  对于G1这种分拆成为大量region的GC，复制而不是移动，意味着GC需要维护region之间对象引用关系，不管是内存占用或者时间开销也不小。
 *  如果系统中的垃圾对象很多，复制算法不会很理想。因为复制算法需要复制的存活对象数量并不会太大，或者说非常低才行。

## 5.应用场景 ##

*  在新生代，对常规应用的垃圾回收，一次通常可以回收70%-99%的内存空间。回收性价比很高。所以现在的商业虚拟机都是用这种收集算法回收新生代。  
    ![复制算法的应用][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW4xMzMzMzMzNjY3Nw_size_16_color_FFFFFF_t_70_pic_center 2]

# 三、标记压缩算法 #

## 1.概述 ##

*  复制算法的高效性是建立在存活对象少、垃圾对象多的前提下的。这种情况在新生代经常发生，但是在老年代，更常见的情况是大部分对象都是存活对象。如果依然使用复制算法,由于存活对象较多，复制的成本也将很高。因此，基于老年代垃圾回收的特性，需要使用其他的算法。
 *  标记-清除算法的确可以应用在老年代中，但是该算法不仅执行效率低下，而且在执行完内存回收后还会产生内存碎片，所以JVM的设计者需要在此基础之上进行改进。标记-压缩(Mark - Compact) 算法由此诞生。1970年前后，G. L. Steele 、C. J. Chene 和D.S. Wise等研究者发布标记-压缩算法。在许多现代的垃圾收集器中，人们都使用了标记-压缩算法或其改进版本。

## 2.执行过程 ##

1）标记: Collector从引用根节点开始递归遍历，标记所有被引用的对象。一般是在对象的Header中记录为可达对象。  
2）压缩: Collector对堆内存从头到尾进行线性的遍历，如果发现某个对象在其Header中没有标记为可达对象，如果是存活定的对象则将其压宿到内存的一端(利用指针碰撞)，按顺序排放，最后遍历完所有的对象后根据维护的指针，清理指针后边的所有的空间。**即标记压缩算法中压缩阶段他是遍历堆空间中所有的对象，然后找到头信息中有可达性的对象，然后去利用指针碰撞去移动可达性的对象，如果指针碰撞的指针的下一个地址有对象，然后再判断对象是否是可达性的，如果是继续将指针往后移动，如果不是直接覆盖，遍历完堆空间的所有对象，然后再清除指针碰撞的指针后续的所有对象，因为指针前是存活的对象，指针后是不可存活的对象，当然还得将移动后的对象的引用给更改下地址。**  
![标记整理算法内存示意图][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW4xMzMzMzMzNjY3Nw_size_16_color_FFFFFF_t_70_pic_center 3]

## 3.特点 ##

*  标记-压缩算法的最终效果等同于标记清除算法执行完成后，再进行一次内存碎片整理，因此，也可以把它称为标记-清除-压缩(Mark- Sweep-Compact)算法。
 *  二者的本质差异在于标记-清除算法是一种非移动式的回收算法，标记-压缩是移动式的。是否移动回收后的存活对象是一项优缺点并存的风险决策。
 *  可以看到，标记的存活对象将会被整理，按照内存地址依次排列，而未被标记的内存会被清理掉。如此一来，当我们需要给新对象分配内存时，JVM只需要持有一个内存的起始地址即可，这比维护一个空闲列表显然少了许多开销。

## 4.优点 ##

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

## 5.缺点 ##

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

## 6.指针碰撞(Bump the Pointer) ##

*  如果内存空间以规整和有序的方式分布，即已用和未用的内存都各自一边，彼此之间维系着一个记录下一次分配起始点的标记指针，当为新对象分配内存时，只需要通过修改指针的偏移量将新对象分配在第一个空闲内存位置上，这种分配方式就叫做指针碰撞(Bump the Pointer) 。

# 四、三种算法的对比 #

<table> 
 <thead> 
  <tr> 
   <th></th> 
   <th>Mark-Sweep</th> 
   <th>Mark-Compact</th> 
   <th>Copying</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>速度</td> 
   <td>中等</td> 
   <td>最慢</td> 
   <td>最快</td> 
  </tr> 
  <tr> 
   <td>空间开销</td> 
   <td>少（但会堆积碎片）</td> 
   <td>少（不堆积碎片）</td> 
   <td>通常需要活对象的2倍大小（不堆积碎片）</td> 
  </tr> 
  <tr> 
   <td>移动对象</td> 
   <td>否</td> 
   <td>是</td> 
   <td>是</td> 
  </tr> 
 </tbody> 
</table>

*  效率上来说，复制算法是当之无愧的老大，但是却浪费了太多内存。
 *  而为了尽量兼顾上面提到的三个指标，标记-整理算法相对来说更平滑一-些，但是效率上不尽如人意，它比复制算法多了一个标记的阶段，比标记-清除多了一个整理内存的阶段。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW4xMzMzMzMzNjY3Nw_size_16_color_FFFFFF_t_70_pic_center]: /images/20221024/bc82df4103944ce5b40b33eb77b0513a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW4xMzMzMzMzNjY3Nw_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221024/1d65e66a3f764ef79b3d479a90a9f939.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW4xMzMzMzMzNjY3Nw_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221024/85940152075d49d4a4699e8c4a3a37cd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW4xMzMzMzMzNjY3Nw_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221024/ad9881c0bcb54d6f80f1d752e86937cd.png