java垃圾回收机制（二）

垃圾回收

什么是垃圾？

​ 对内存资源的申请之后，使用完成之后没即使处理，就会一直占用资源，不及时回收导致内存溢出，

C/C++没有垃圾回收

​ new申请，delete删除 若不删除就会一直占用，导致内存不够用，溢出

java的垃圾回收：

自动回收垃圾，就是JVM的GC机制。

程序员只是申请资源，不需要释放，JVM会自动执行垃圾回收，所以显得垃圾回收就很重要，就是垃圾回收机制的算法问题

C#、python也有

垃圾回收机制常见的算法

1. 引用计数法

2. 标记清除法

   

3. 标记压缩法(标记整理法)

4. 复制算法

5. 分代算法

   …

引用计数法：

（最早的算法）

​ 1960年

​ 每个对象有一个对象计数器，若有其他对象引用此对象，则对象计数器+1；反之不引用就是-1；如果一个对象的引用计数器为0，则这个对象就会被回收，反之不回收，就是有对象在引用此对象，不能回收。

优点：

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

缺点：

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

什么是循环引用？

class TestA{
    
    
public TestB b;
}
class TestB{
    
    
public TestA a;
}
public class Main{
    
    
public static void main(String[] args){
    
    
A a = new A();
B b = new B();
a.b=b;
b.a=a;
a = null;
b = null;
}
}

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

计数器不为0

标记清除法

​ 标记：从根结点开始标记引用的对象

​ 清除：未被标记的对象就是垃圾对象，可以清除

JVM暂停所有的应用程序并开启GC线程。STW Stop The World

为什么要暂停所有的程序，标记清除要从头开始对对象梳理进行标记，如果有进程在运行，若产生了其他对象，会扰乱标记的问题

​ 无法确定引用关系，导致标记有错标或者漏标现象，在清除的时候，对应用产生中断或其它问题。

从根节点开始向外标记（从Root对象可达的对象就为可以存活对象）

然后清除未标记的对象

最后将标记位置重新归0，然后结束STW，继续运行程序。

优点：

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

缺点：

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

标记压缩法（标记整理法）

在标记清除的基础上优化，解决了标记清除法的产生碎片的问题，将回收的空间进行压缩到一起。方便内存分配和管理。

优缺点

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

复制算法

原理：是将内存一分为二，只是用其中一块，将正在使用的内存复制到另一块内存里面，将原有内存的空间进行清除，交换两个内存的对象（from成为to，to成为from），实现垃圾回收。

​ 如果此内存的使用率较低（即正在使用的空间比较少）的情况下，使用复制算法复制的对象就较少，清除的内存空间多，当然效率也高效，没有碎片、内存空间连续；反正不适合，浪费空间。

​ JVM中的年轻代内存空间 ，就是使用的复制算法；将伊甸园区存活的对象复制到from（S0）区，根据他们的年龄阈值判断是否转移到To区（S1）；之后from和伊甸园区为空，直到To区满了转移到老年区。

优点：

• 在垃圾对象多的情况下，效率较高

• 清理后，内存无碎片

缺点

• 在垃圾对象少的情况下，不适用，如：老年代内存
• 分配的2块内存空间，在同一个时刻，只能使用一半，内存使用率较低

分代算法

根据回收对象的选择，在JVM中，年轻代适合复制算法，老年代适合标记清除算法或者标记压缩算法。

垃圾收集器和内存分配

串行的垃圾收集器

​ 是指使用单线程进行垃圾回收，中有一个线程在工作，并且java中的所有引用需要暂停等待垃圾回收的完成，此现象成为CTW。

​ 对于交互性强的应用不会使用次垃圾回收器。

​ 一般javaWeb应用不会采取

• ​ 测试代码

  import java.util.ArrayList;
  import java.util.List;
  import java.util.Properties;
  import java.util.Random;
  public class TestGC {
        
        
  public static void main(String[] args) throws Exception {
        
        
  List<Object> list = new ArrayList<Object>();
  while (true){
        
        
  int sleep = new Random().nextInt(100);
  if(System.currentTimeMillis() % 2 ==0){
        
        
  list.clear();
  }else{
        
        
  for (int i = 0; i < 10000; i++) {
        
        
  Properties properties = new Properties();
  properties.put("key_"+i, "value_" +
  System.currentTimeMillis() + i);
  list.add(properties);
  }
  }
  // System.out.println("list大小为：" + list.size());
  	Thread.sleep(sleep);
  			}
  		}
  }
  
  

  设置垃圾回收为串行收集器

  在程序运行参数中添加2个参数，如下：

  -XX:+UseSerialGC

  指定年轻代和老年代都使用串行垃圾收集器

  -XX:+PrintGCDetails

  打印垃圾回收的详细信息

• 为了测试GC，将堆的初始和最大内存都设置为16M

  ‐XX:+UseSerialGC ‐XX:+PrintGCDetails ‐Xms16m ‐Xmx16m
  

• GC日志信息解读

  1. 日志信息

     [GC (Allocation Failure) [DefNew: 4416K‐>512K(4928K), 0.0046102 secs] 4416K‐>1973K(15872K), 0.0046533 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
     
     [Full GC (Allocation Failure) [Tenured: 10944K‐>3107K(10944K), 0.0085637 secs] 15871K‐>3107K(15872K), [Metaspace: 3496K‐>3496K(1056768K)], 0.0085974 secs] [Times: user=0.02 sys=0.00, real=0.01 secs]
     

  2. 年轻代的内存GC前后的大小

  DefNew

  • 表示使用的是串行垃圾收集器。

  4416K->512K(4928K)

  • ​ 表示，年轻代GC前，占有4416K内存，GC后，占有512K内存，总大小4928K

  0.0046102 secs

  • 表示，GC所用的时间，单位为毫秒。

  4416K->1973K(15872K)

  • 表示，GC前，堆内存占有4416K，GC后，占有1973K，总大小为15872K

  Full GC

  • 表示，内存空间全部进行GC

  ​

并行的垃圾收集器

​ 是把单线程回收垃圾改变成多线程回收垃圾，可以缩短垃圾回收的时间（针对于电脑性能比较好的来说）

​ 并且此方式也会产生STW，会缩短时间，执行效率更快。

1. ParNew垃圾回收器

   ParNew垃圾回收器工作在年轻代上，只是把串行的变为了并行的。老年代还是串行的

   返回的参数类似SerialGC垃圾回收器的参数

2. ParallelGC回收器

   相关参数如下：

   -XX:+UseParallelGC

   • 年轻代使用ParallelGC垃圾回收器，老年代使用串行回收器。

   -XX:+UseParallelOldGC

   • 年轻代使用ParallelGC垃圾回收器，老年代使用ParallelOldGC垃圾回收器。

   -XX:MaxGCPauseMillis

   • 设置最大的垃圾收集时的停顿时间，单位为毫秒
   • 需要注意的时，ParallelGC为了达到设置的停顿时间，可能会调整堆大小或其他的参数，如果堆的大小设置的较小，就会导致GC工作变得很频繁，反而可能会 影响到性能。
   • 该参数使用需谨慎。

   -XX:GCTimeRatio

   • 设置垃圾回收时间占程序运行时间的百分比，公式为1/(1+n)。
   • 它的值为0~100之间的数字，默认值为99，也就是垃圾回收时间不能超过1%

   -XX:UseAdaptiveSizePolicy

   • 自适应GC模式，垃圾回收器将自动调整年轻代、老年代等参数，达到吞吐量、 堆大小、停顿时间之间的平衡。

   • 一般用于，手动调整参数比较困难的场景，让收集器自动进行调整。

   参数

   ‐XX:+UseParallelGC ‐XX:+UseParallelOldGC ‐XX:MaxGCPauseMillis=100 ‐ XX:+PrintGCDetails ‐Xms16m ‐Xmx16m

CMS垃圾收集器

Concurrent Mark Sweep 主要针对于老年代。

参数：-XX:+UseConcMarkSweepGC

• 初始化标记(CMS-initial-mark) ,标记root，会导致stw；
• 并发标记(CMS-concurrent-mark)，与用户线程同时运行；
• 预清理（CMS-concurrent-preclean），与用户线程同时运行；
• 重新标记(CMS-remark) ，会导致stw；
• 并发清除(CMS-concurrent-sweep)，与用户线程同时运行；
• 调整堆大小，设置CMS在清理之后进行内存压缩，目的是清理内存中的碎片；
• 并发重置状态等待下次CMS的触发(CMS-concurrent-reset)，与用户线程同时运行；

G1垃圾收集器 （重点）

是jdk1.7提出的全新的垃圾回收器，计划1.9作为默认的垃圾回收器，代替CMS；

G1的设计原则是JVM性能调优，开发人员只需三步进行操作：

• 开启G1回收器
• 设置堆的最大内存
• 设置最大的停顿时间

G1中有三个机制，Young GC、Mixed GC、FUll GC，在不同的条件下触发；

原理：

以前的分代模型编程分区模型

​ 不用对哪个内存设置，不用担心内部才能不足；

每一个区域再回收时，使用的类似复制算法一样的回收垃圾，拷贝到old区或者幸存区，完成垃圾回收的操作；意味着在操作就是将内存进行了压缩，不再产生碎片。

在G1中，维护了一个Humongous区域，用于存放大对象的区域

• 如果一个对象的占用超过一个区域的50%（根据内存可以设置的大对象的百分比），则认为此对象是一个大对象；
• 一般情况下将大对象放置于Old老年区，如果这个大对象不是一个长期存储的对象，那么放在Old区是不合适的；
• 在G1中将此大对象放入H区，如果一个H区放不下则会寻找连续的H区，有事不得不会触发FUll GC。

Young GC

​ Young GC主要针对的是Eden区域，他在Eden区内存不足时触发

• Eden区的数据转移到Survivor区，如果Survivor装不下，Eden区的数据转移到老年区；
• Survivor区的数据转到新的Survivor区，不够的话，Survivor区的数据之间转移到老年区；
• 最后Eden区的数据成为空，产生STW，然后进行垃圾回收。

​

Remembered Set（已记忆集合）

在进行垃圾回收，如何找到Root对象？

此对象可能在年轻代中，也可能在老年代中，如果进行回收时，遍历所有对象，则大大降低了回收效率；

所以引用了Rset集合，作用是跟踪某个堆的引用对象。

原理基本有点类似静态链表的实现方法（自我感觉）

每个Region在初始化时，都有一个Rset集合（就是set集合），主要用于记录并跟踪其他Region指向该Region中的对象，每个Region默认按照512k划分一个Card，所以Rset记录的就是某某Region的某某Card。

然后只扫描某个区域的Rset集合即可；

Mixed GC

当老年代越拉越多的内存，为了避免堆内存被耗尽，JVM会触发一个混合垃圾回收器，会回收年轻代的垃圾和一部分老年代的垃圾，对老年代的垃圾可以进行选择回收。

由参数 -XX:InitiatingHeapOccupancyPercent=n 决定。默认45%；

Mixed GC的触发时机：当老年代占堆内存的45%的时候进行触发。

执行步骤有两大步：

1. 全局并发标记
2. 拷贝存活对象

全局并发标记（和CMS类似）

• 初始标记（STW）
  • 标记从ROOT可达的对象
• 跟区域扫描
  • 扫描在初始标记存活区对老年代的引用，并标记；
  • 不产生STW
• 并发标记
  • 无STW，G1 GC在整个堆内存找标记的对象
• 重新标记
  • STW，对上面并发执行的进行修改
• 清除垃圾
  • STW，等待拷贝存活对象执行。

拷贝存活对象

Evacuation阶段是全暂停的。该阶段把一部分Region里的活对象拷贝到另一部分Region 中，从而实现垃圾的回收清理。

G1收集器相关参数

• -XX:+UseG1GC
  • 使用 G1 垃圾收集器
• -XX:MaxGCPauseMillis
  • 设置期望达到的最大GC停顿时间指标（JVM会尽力实现，但不保证达到），默认 值是 200 毫秒。
• -XX:G1HeapRegionSize=n
  • 设置的 G1 区域的大小。值是 2 的幂，范围是 1 MB 到 32 MB 之间。目标是根 据最小的 Java 堆大小划分出约 2048 个区域。 默认是堆内存的1/2000。
• -XX:ParallelGCThreads=n
  • 设置 STW 工作线程数的值。将 n 的值设置为逻辑处理器的数量。n 的值与逻辑 处理器的数量相同，最多为 8。
• -XX:ConcGCThreads=n
  • 设置并行标记的线程数。将 n 设置为并行垃圾回收线程数 (ParallelGCThreads) 的 1/4 左右。
• -XX:InitiatingHeapOccupancyPercent=n
  • 设置触发标记周期的 Java 堆占用率阈值。默认占用率是整个 Java 堆的 45%。

如何减少Full GC 发生？

• 方法区空间增大
• 老年代空间增大
• 新生代空间减小
• 禁止使用System.gc()方法（或者少使用）
  • 在代码中调用System.gc()方法会建议JVM进行Full GC，但是注意这只是建议，JVM执行不执行是另外一回事儿，不过在大多数情况下会增加Full GC的次数，导致系统性能***下降***，一般建议不要手动进行此方法的调用。
• 使用标记整理算法，尽量让连续空间保持最大
• 排查代码中的无用大对象(内存泄漏)