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：颜色指针+读屏障
垃圾回收器
- 串行单线程
堆内存较小，适合个人电脑 - 吞吐量优先
多线程
堆内存较大，多核 cpu
让单位时间内，STW 的时间最短 0.2 0.2 = 0.4，垃圾回收时间占比最低，这样就吞吐量高 - 响应时间优先
多线程
堆内存较大，多核 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
- 整体上是 标记+整理 算法，两个区域之间是 复制 算法
逻辑分区，三色标记+写屏障 会 STW 在 Young GC 时会进行 GC Root 的初始标记 会对 E、S、O 进行全面垃圾回收 1.标记gcroot和gc root 所在的region G1相关的参数配置： pre-write barrier + satb_mark_queue 当引用发生改变时，加入写屏障，把发生了引用的对象加入到队列中，将对象的颜色改为灰色，重新标记阶段会把队列中的对象再标记一次。 所有对象都经过并发标记后，就能知道哪些类不再被使用，当一个类加载器的所有类都不再使用，则卸载它所加载的所有类 -XX:+ClassUnloadingWithConcurrentMark 默认启用 着色指针+读屏障 线程内的oom不会导致整个进程结束。
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
借助SATB算法，snapshot at the begins第一阶段：YoungGC的过程:
第二阶段：YoungGC+concurrent mark
老年代占用堆空间比例达到阈值时，进行并发标记（不会 STW），由下面的 JVM 参数决定-XX:InitiatingHeapOccupancyPercent=percent （默认45%）
第三阶段：MixGC过程
最终标记（Remark）会 STW
拷贝存活（Evacuation）会 STW
-XX:MaxGCPauseMillis=ms
根据最大暂停时间有选择的回收
2.扫描gc root region和rset中的root
3.对rset进行标记
4.针对漏标，错标，使用SATB算法重新标记
5.回收，重置rset
-XX:G1HeapRegionSize=size（设置每个region大小）YoungGC跨代引用问题
Remark
优化点1:JDK 8u20 字符串去重
-XX:+UseStringDeduplicationString s1 = new String("hello"); // char[]{'h','e','l','l','o'}
String s2 = new String("hello"); // char[]{'h','e','l','l','o'}
优化点2:DK 8u40 并发标记类卸载
优化点3:JDK 8u60 回收巨型对象
优化点4: JDK 9 并发标记起始时间的调整
九、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);
}
}
