JVM垃圾回收

识别垃圾算法

• 引用计数法
• 可达性算法

清除垃圾算法

• 标记清除算法
• 复制算法
• 标记整理算法
• 分代回收

一、引用计数法

1.原理

统计每一个对象被引用的次数，如果引用次数为0就释放对象。能立即回收无用内存。

2.实现

当一个对象要重新赋值引用时：

• 把新对象引用计数+1
• 老对象引用计数-1
• 赋值

伪代码：

3.存在的问题

• 并发场景下，对引用计数的修改需要和对象指针的修改保证同步，往往需要加锁或者复杂的无锁算法
• 有时会引发连锁式的回收
• 无法有效解决循环引用

注意：要先加，再减，否则如果刚好减到0的话就会被回收了。

二、可达性分析算法（Java使用）

Java 虚拟机中的垃圾回收器采用可达性分析来探索所有存活的对象
扫描堆中的对象，看是否能够沿着 GC Root对象 为起点的引用链找到该对象，找不到，表示可以回收

哪些对象可以作为 GC Root ?

• System Class:启动类加载器加载的类（Object ，HashMap，String）
• Native Stack
• Thread：活动线程（局部变量所引用的对象）
• Busy Monitor：被加锁的对象

public class GCRootsTest {
    public static void main(String[] args) throws InterruptedException, IOException {
        List<Object> list1 = new ArrayList<>();
        list1.add("a");
        list1.add("b");
        System.out.println(1);
        System.in.read();

        list1 = null;
        System.out.println(2);
        System.in.read();
        System.out.println("end...");
    }
}

hongcaixia@hongcaixiadeMacBook-Pro stringtable % jmap -dump:format=b,live,file=1.bin 66669
Dumping heap to /Users/hongcaixia/Documents/work/workspace/demo/target/classes/jvm/stringtable/1.bin ...
Heap dump file created
hongcaixia@hongcaixiadeMacBook-Pro stringtable % jmap -dump:format=b,live,file=2.bin 66669
Dumping heap to /Users/hongcaixia/Documents/work/workspace/demo/target/classes/jvm/stringtable/2.bin ...
Heap dump file created

三、复制算法

1.原理

把程序运行的堆分成大小相同的两半，一半为from空间，一半为to空间。利用from空间进行分配，当空间不足以分配对象的时候，触发GC。GC会把存活的对象全部复制到to空间。复制完成以后，会把from和to互换。

2.特点

• 1.分配采用bump the pointer，每次都把top指针向后移动即可。复制的存活对象多大，指针就移动多大。
• 2.回收是否高效取决于存活对象的比例。存活对象越少，效率越高
• 3.无内存碎片
• 4.需要浪费一半内存空间
• 5.需要停顿
• 6.实现简单

在整理的过程 需要停顿业务线程，因为在整理对象的过程，指针会发生改变。

3.对象位置发生变化，指向的引用维护方法

1⃣️引入中间层

虽然在复制的过程中变得简单，但是中间层的分配和回收并不容易做；而且每次访问对象属性都变成了再次访问，性能的退化也是不能接受的。

2⃣️使用forwarding指针

1.A复制到to空间
2.因为A指向着C，所以C也直接复制到to空间，修改C的引用，让A指向C’
3.B复制到to空间，但是B的指针还是指向的from空间的C；
4.在第二步C复制到to空间时，让C指向新的C’地址（forwarding指针）。
5.B从C中的对象头中拿到forwarding，指向新的C’。

4.提高空间利用率

将Eden空间分配成Eden，Survivor0和Survivor1区域。这样Survivor空间的浪费就可以减少了。
配置Survivor空间大小是JVM GC调参中的重要参数。
例如 -XX:SurvivorRatio=8 代表Eden:S0:S1=8:1:1

from：S1+Eden
to：S0
第一次：把s1+Eden一起经过回收存活的放入S1；

from：S0+Eden
to：S1
第二次：把S0+Eden一起经过回收存活的放入S0；

浪费的空间就只有S0或者S1的大小。

四、标记清除法

1.原理

使用链表管理所有的空闲区域。在Mark阶段（标在对象头），将所有的存活对象识别出来，将不存活的对象所占用的内存还给链表。

回收的这些对象所占用的内存地址的起始和结束地址纪录下来，放入空闲地址列表，下次再分配内存时，在空闲地址列表中找是否有足够的空闲空间容纳新对象，有则使用。

2.特点

• 1.分配和回收都要操作链表
  分配要查询链表哪个位置可以放得下这个对象，回收再将内存还给链表
• 2.有内存碎片
• 3.总体的内存空间利用率较高
• 4.可以用很小的代价实现并发标记和清除（在标记的过程中对象指针不会发生变化，不需要停止业务线程）
• 5.速度快

五、标记整理

没有内存碎片，利用率高，算法相对复杂，速度慢

1.找出需要回收的
2.把存活的对象放到回收的地方

分代算法：三色标记+写屏障
ZGC：颜色指针+读屏障

新生代Serial和老年代Serial Old的组合

六、分代回收

1.新创建的对象尝试放到eden,如果该对象比eden总量都大，那么直接放到老年代
2.eden没有足够的空间，触发一次minorGC，将eden和from区的存活对象，移动到to区，对象年龄+1。然后将eden和from区进行回收。最后 from区和to区互换3、如果to去没有足够的空间，那么将满足条件的对象移入到老年代，对象的年龄达到了一定数值，6、15
4、移动过程中老年代空间也不足了。需要回收老年代的mojorGC,往往回收老年代的时候需要将整个堆空间一并回收fullGC

新生代：Serial，ParNew，Parallel Scavenge
老年代：Serial Old，CMS，Parallel Old

即可在新生代，也可在老年代：G1，ZGC

分代回收：三色标记+写屏障
ZGC：颜色指针+读屏障

垃圾回收器

1. 串行单线程
   堆内存较小，适合个人电脑
2. 吞吐量优先
   多线程
   堆内存较大，多核 cpu
   让单位时间内，STW 的时间最短 0.2 0.2 = 0.4，垃圾回收时间占比最低，这样就吞吐量高
3. 响应时间优先
   多线程
   堆内存较大，多核 cpu
   尽可能让单次 STW 的时间最短 0.1 0.1 0.1 0.1 0.1 = 0.5

Serial+Serial Old

-XX:+UseSerialGC = Serial + SerialOld

没有内存碎片

新生代 Parallel Scavenge/ParNew和年老代Serial Old搭配

新生代Parallel Scavenge和老年代 Parallel Old

-XX:+UseParallelGC ~ -XX:+UseParallelOldGC(只要开启一个，另一个自动开启)

-XX:ParallelGCThreads=n 控制垃圾回收的线程数
-XX:+UseAdaptiveSizePolicy 采用自适应大小调整策略（新生代大小）
-XX:GCTimeRatio=ratio 调整吞吐量，垃圾回收时间和总时间的占比（达不到目标则调整堆空间大小）
-XX:MaxGCPauseMillis=ms 最大暂停毫秒数（默认200毫秒）

七、CMS

-XX:+UseConcMarkSweepGC ~ -XX:+UseParNewGC ~ SerialOld（并发失败退化为SerialOld）
（并发：用户线程和垃圾回收线程可以一起执行）

响应时间优先：
-XX:ParallelGCThreads=n（并行的线程数） ~ -XX:ConcGCThreads=threads（并发线程数）
-XX:CMSInitiatingOccupancyFraction=percent（执行垃圾回收的内存占比，需要预留空间给浮动垃圾）
-XX:+CMSScavengeBeforeRemark（在重新标记之前对新生代进行一次垃圾回收，减少重新标记时要扫描的对象）

• 初始标记：stop-the-world,标记GCRoots直接关联的对象
• 并发标记：并发追溯标记，程序不会停顿
• 重新标记：暂停虚拟机，扫描CMS堆中的剩余对象
• 并发清理：清理垃圾对象，程序不会停顿
• 并发重置：重置CMS收集器的数据结构

Promotion Fail:
当年轻代进行minor gc时，把eden和from放到to区的时候，to区不够用了，需要把存活的对象移动至老年代，当老年代没有足够的空间或者有足够的空间但是太碎片化（标记-清除算法）时，就会发生Promotion Fail。
此时，会将CMS降级为Serial Old。执行full gc
解决办法：当标记清除了一定次数之后，把老年代进行整理。调大老年代/调大新生代。

标记算法：三色标记法

• 黑：已经完成标记
• 灰：标记了一部分（类中某些成员还未标记）
• 白：未标记
  由于GC线程和业务线程同时执行，就会导致漏标和错标。
  漏标：再重新标记
  错标：Incremental Update

当已经标记完的对象又被某个线程重新指向的时候，将黑色换成灰色。

八、G1

-XX:+UseG1GC
适用场景

• 同时注重吞吐量（Throughput）和低延迟（Low latency），默认的暂停目标是 200 ms
• 超大堆内存，会将堆划分为多个大小相等的 Region
• 整体上是 标记+整理 算法，两个区域之间是 复制 算法

1、G1垃圾收集器将整个 JVM 内存分为多个大小相等的region,年轻代和老年代逻辑分区 。
2、G1 是 Java9 以后的默认垃圾回收器
3、G1 在整体上使用标记整理算法，局部使用复制算法
4、G1 的每个 Region 大小在 1-32M 之间，可以通过-XX:G1HeapRegionSize=n指定区大小。
5、总的 Region 个数最大可以存在 2048 个，即heap最大能够达到32M*2048=64G
6、0.5<obj<1,那么放到old区，old标记为H
1<obj<n,连续的n个region,作为H

逻辑分区，三色标记+写屏障
借助SATB算法，snapshot at the begins

第一阶段：YoungGC的过程:

会 STW

第二阶段：YoungGC+concurrent mark

在 Young GC 时会进行 GC Root 的初始标记
老年代占用堆空间比例达到阈值时，进行并发标记（不会 STW），由下面的 JVM 参数决定-XX:InitiatingHeapOccupancyPercent=percent （默认45%）

第三阶段：MixGC过程

会对 E、S、O 进行全面垃圾回收
最终标记（Remark）会 STW
拷贝存活（Evacuation）会 STW
-XX:MaxGCPauseMillis=ms

根据最大暂停时间有选择的回收

• 初始标记：标记出GCRoot对象，以及GCRoot所在的Region(RootRegion)
• Root Region Scanning:扫表整个old的Region（查看root region的rset是否有引用）
• 并发标记：并发追溯标记，进行GCRootsTracing的过程（只标记gcroot中的rset这部分）
• 最终标记：修正并发标记期间，因程序运行导致标记发生变化的那一部分对象（SATB算法）
• 清理回收：根据时间来进行价值最大化的回收，重置rset

1.标记gcroot和gc root 所在的region
2.扫描gc root region和rset中的root
3.对rset进行标记
4.针对漏标，错标，使用SATB算法重新标记
5.回收，重置rset

G1相关的参数配置：

• -XX:+UseG1GC ：设置使用 G1 垃圾回收器
• -XX:MaxGCPauseMillis=n ：最大 GC 停顿时间，毫秒值
• -XX:InitatingHeapOccupancyPercent=n：当堆空间占用到 n 兆时就触发 GC(45)
• -XX:GoncGCThreads=n：并发 GC 使用的线程数
• -XX：G1ReserverPercent=n：设置作为空闲空间的预留内存百分比(10%)
  -XX:G1HeapRegionSize=size（设置每个region大小）

YoungGC跨代引用问题

• 卡表与 Remembered Set
• 在引用变更时通过 post-write barrier + dirty card queue（当有引用新生代时标记为脏card，减少扫描范围）
• concurrent refinement threads 更新 Remembered Set

Remark

pre-write barrier + satb_mark_queue

当引用发生改变时，加入写屏障，把发生了引用的对象加入到队列中，将对象的颜色改为灰色，重新标记阶段会把队列中的对象再标记一次。

优化点1:JDK 8u20 字符串去重

• 优点：节省大量内存
• 缺点：略微多占用了 cpu 时间，新生代回收时间略微增加

-XX:+UseStringDeduplication

String s1 = new String("hello"); // char[]{'h','e','l','l','o'}
String s2 = new String("hello"); // char[]{'h','e','l','l','o'}

• 将所有新分配的字符串放入一个队列
• 当新生代回收时，G1并发检查是否有字符串重复
• 如果它们值一样，让它们引用同一个 char[]
• 注意，与 String.intern() 不一样
  • String.intern() 关注的是字符串对象
  • 而字符串去重关注的是 char[]
  • 在 JVM 内部，使用了不同的字符串表

优化点2:DK 8u40 并发标记类卸载

所有对象都经过并发标记后，就能知道哪些类不再被使用，当一个类加载器的所有类都不再使用，则卸载它所加载的所有类

-XX:+ClassUnloadingWithConcurrentMark 默认启用

优化点3:JDK 8u60 回收巨型对象

• 一个对象大于 region 的一半时，称之为巨型对象
• G1 不会对巨型对象进行拷贝
• 回收时被优先考虑
• G1 会跟踪老年代所有 incoming 引用，这样老年代 incoming 引用为0 的巨型对象就可以在新生代垃圾回收时处理掉

优化点4: JDK 9 并发标记起始时间的调整

• 并发标记必须在堆空间占满前完成，否则退化为 FullGC
• JDK 9 之前需要使用 -XX:InitiatingHeapOccupancyPercent
• JDK 9 可以动态调整
  • -XX:InitiatingHeapOccupancyPercent 用来设置初始值
  • 进行数据采样并动态调整
  • 总会添加一个安全的空档空间

九、ZGC

着色指针+读屏障

十、JVM相关参数

含义	参数
堆初始大小	-Xms
堆最大大小	-Xmx 或 -XX:MaxHeapSize=size
新生代大小	-Xmn 或 (-XX:NewSize=size + -XX:MaxNewSize=size )
幸存区比例（动态）	-XX:InitialSurvivorRatio=ratio 和 -XX:+UseAdaptiveSizePolicy
幸存区比例	-XX:SurvivorRatio=ratio
晋升阈值	-XX:MaxTenuringThreshold=threshold
晋升详情	-XX:+PrintTenuringDistribution
GC详情	-XX:+PrintGCDetails -verbose:gc
FullGC 前 MinorGC	-XX:+ScavengeBeforeFullGC

/**
 *  演示内存的分配策略
 */
public class Demo1 {
    private static final int _512KB = 512 * 1024;
    private static final int _1MB = 1024 * 1024;
    private static final int _6MB = 6 * 1024 * 1024;
    private static final int _7MB = 7 * 1024 * 1024;
    private static final int _8MB = 8 * 1024 * 1024;

    // -Xms20M -Xmx20M -Xmn10M -XX:+UseSerialGC -XX:+PrintGCDetails -verbose:gc -XX:-ScavengeBeforeFullGC
    public static void main(String[] args) throws InterruptedException {
        new Thread(() -> {
            ArrayList<byte[]> list = new ArrayList<>();
            list.add(new byte[_8MB]);
            list.add(new byte[_8MB]);
        }).start();

        System.out.println("sleep....");
        Thread.sleep(1000L);
    }
}

线程内的oom不会导致整个进程结束。