4. JVM垃圾回收

最新推荐文章于 2024-07-06 16:39:36 发布

tobebetter9527

最新推荐文章于 2024-07-06 16:39:36 发布

阅读量118

点赞数

分类专栏： # JVM 文章标签： jvm 垃圾回收

本文链接：https://blog.csdn.net/qq_39530821/article/details/100850097

版权

JVM 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

1. 垃圾回收常见算法

包括引用计数法、标记清除法、标记压缩法、复制算法、分代算法等。

1.1 引用计数法

1.1.1 原理

假设对象A，任何其他对象对A的引用，A的计数器加1，如果引用失败则减1，当A的计数器为0时，即没有引用，可以回收。

1.1.2 优缺点

优点：

实时性较高，无需等内存不够才开始回收，直接根据计数器是否为0回收；
垃圾回收时，应用无需挂起；
区域性，更新计数器时，只影响到该对象，不会扫描全部对象。
缺点：
更新计数器，有时间开销；
即使内存够用，仍然进行计数器统计，浪费cpu资源；
无法解决循环引用的问题（最大缺点）。

什么是循环引用：

public class Demo {

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

class TestA {
	public TestB b;
}

class TestB {
	public TestA a;
}

虽然a和b都为null，但存在循环引用，不会被回收。

1.2 标记清除法

分为两个阶段：标记、清除。

标记：从根节点开始标记引用对象。
清除：未被标记对象就是垃圾对象，可以清理。
优点：解决引用计数法的循环引用的问题。
缺点：效率较低，标记和清除都需要遍历所有对象，并且GC时，需要停止应用；内存碎片化严重。

1.3 标记压缩算法

在标记清除算法基础上，做了改进。标记阶段一样，不同点在于清除阶段，是将存活的对象压缩到一端，另外一端清理掉。
在这里插入图片描述
优缺点：同标记清除法，解决内存碎片化问题，另外对象的移动，对效率有一定影响。

1.4 复制算法

将内存分成两个一样大的空间，每次只用一个。当垃圾回收时，将存活对象复制到闲置空间，然后清理使用空间的垃圾，交换两个空间的角色。

优点：垃圾对象较多，效率较高；清理后无内存碎片。
缺点：垃圾对象较少，不适用；内存有效使用空间仅一半。

1.4.1 jvm年轻代内存空间

在GC开始的时候，对象只会存在于Eden区和名为“From”的Survivor区，Survivor区“To”是空的。
紧接着进行GC，Eden区中所有存活的对象都会被复制到“To”，而在“From”区中，仍存活的对象会根据他们的年龄值来决定去向。年龄达到一定值(年龄阈值，可以通过-XX:MaxTenuringThreshold来设置)的对象会被移动到年老代中，没有达到阈值的对象会被复制到“To”区域。
经过这次GC后，Eden区和From区已经被清空。这个时候，“From”和“To”会交换他们的角色，也就是新的“To”就是上次GC前的“From”，新的“From”就是上次GC前的“To”。不管怎样，都会保证名为To的Survivor区域是空的。
GC会一直重复这样的过程，直到“To”区被填满，“To”区被填满之后，会将所有对象移动到年老代中。

1.5 分代算法

上面每种算法各有优缺点，根据对象的特点选用不同的算法效率更高，针对年轻代，垃圾对象对，选用复制算法比较好；针对老年代，由于对象存活较多，选用标记清除或标记压缩法比较好。

2. 垃圾收集器以及内存分配

以上算法的具体实现包括：串行垃圾收集器、并行垃圾收集器、CMS（并发）收集器、G1垃圾收集器。

2.1 串行垃圾收集器

使用单线程回收垃圾，并且应用的其他线程暂停，等待垃圾回收完成。这种现象称为STW（Stop-The-World）。
对于交互性强的javaweb应用，这种收集器是不能接受的。
在这里插入图片描述

2.1.1 测试代码

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 {
                // 向list中添加10000个对象
                for (int i = 0; i < 10000; i++) {
                    Properties properties = new Properties();

                    properties.put("key_" + i, "value_" + System.currentTimeMillis() + i);

                    list.add(properties);
                }
            }
            Thread.sleep(sleep);
        }
    }
}

2.1.2 设置串行垃圾收集器

-XX:+UseSerialGC，制定新生代和老年代都使用串行垃圾收集器。
-XX:+PrintGCDetails，打印垃圾回收详细信息

# 为了测试GC，将堆的初始和最大内存都设置为16M
-XX:+UseSerialGC -XX:+PrintGCDetails -Xms16m -Xmx16m

在这里插入图片描述
运行程序的结果

[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]

GC日志信息解读：
年轻代的内存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。

2.2 并行垃圾收集器

与串行垃圾收集器不同在于多线程进行垃圾回收。
在这里插入图片描述

2.2.1 ParNew垃圾收集器

运行在新生代上，通过-XX:+UseParNewGC设置，老年代依然使用串行垃圾收集器。

-XX:+UseParNewGC -XX:+PrintGCDetails -Xms16m -Xmx16m

运行代码

#打印出的信息
[GC (Allocation Failure) [ParNew: 4416K‐>512K(4928K), 0.0032106 secs]
4416K‐>1988K(15872K), 0.0032697 secs] [Times: user=0.00 sys=0.00,
real=0.00 secs]

ParNew使用并行垃圾回收器。

2.2.2 ParallelGC垃圾收集器

ParallelGC收集器工作机制和ParNewGC收集器一样，只是在此基础之上，新增了两个和系统吞吐量相关的参数，使得其使用起来更加的灵活和高效。
相关参数：

-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

[GC (Allocation Failure) [PSYoungGen: 3456K->1376K(3584K)] 12178K->11434K(14848K), 0.0031972 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[Full GC (Ergonomics) [PSYoungGen: 1376K->0K(3584K)] [ParOldGen: 10058K->3993K(11264K)] 11434K->3993K(14848K), [Metaspace: 3243K->3243K(1056768K)], 0.0109964 secs] [Times: user=0.06 sys=0.00, real=0.01 secs]

2.3 CMS垃圾收集器

CMS全称 Concurrent Mark Sweep，是一款并发的、使用标记-清除算法的垃圾回收器，该回收器是针对老年代垃圾回收的，通过参数-XX:+UseConcMarkSweepGC进行设置。
参数控制：

-XX:+UseConcMarkSweepGC 使用CMS收集器
-XX:+ UseCMSCompactAtFullCollection Full GC后，进行一次碎片整理；整理过程是独占的，会引起停顿时间变长
-XX:+CMSFullGCsBeforeCompaction 设置进行几次Full GC后，进行一次碎片整理
-XX:ParallelCMSThreads 设定CMS的线程数量（一般情况约等于可用CPU数量）

CMS 处理过程有七个步骤：

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

测试：

#设置启动参数
‐XX:+UseConcMarkSweepGC ‐XX:+PrintGCDetails ‐Xms16m ‐Xmx16m
#运行日志
[GC (Allocation Failure) [ParNew: 4926K‐>512K(4928K), 0.0041843 secs]
9424K‐>6736K(15872K), 0.0042168 secs] [Times: user=0.00 sys=0.00,
real=0.00 secs]
#第一步，初始标记
[GC (CMS Initial Mark) [1 CMS‐initial‐mark: 6224K(10944K)] 6824K(15872K),
0.0004209 secs] [Times: user=0.00 sys=0.00, real=0.00 secs]
#第二步，并发标记
[CMS‐concurrent‐mark‐start]
[CMS‐concurrent‐mark: 0.002/0.002 secs] [Times: user=0.00 sys=0.00,
real=0.00 secs]
#第三步，预处理
[CMS‐concurrent‐preclean‐start]
[CMS‐concurrent‐preclean: 0.000/0.000 secs] [Times: user=0.00 sys=0.00,
real=0.00 secs]
#第四步，重新标记
[GC (CMS Final Remark) [YG occupancy: 1657 K (4928 K)][Rescan (parallel)
, 0.0005811 secs][weak refs processing, 0.0000136 secs][class unloading,
0.0003671 secs][scrub symbol table, 0.0006813 secs][scrub string table,
0.0001216 secs][1 CMS‐remark: 6224K(10944K)] 7881K(15872K), 0.0018324
secs] [Times: user=0.00 sys=0.00, real=0.00 secs]
#第五步，并发清理
[CMS‐concurrent‐sweep‐start]
[CMS‐concurrent‐sweep: 0.004/0.004 secs] [Times: user=0.00 sys=0.00,
real=0.00 secs]
#第六步，重置
[CMS‐concurrent‐reset‐start]
[CMS‐concurrent‐reset: 0.000/0.000 secs] [Times: user=0.00 sys=0.00,
real=0.00 secs]

2.4 G1垃圾收集器（重点）

G1的设计原则就是简化JVM性能调优，只需要简单的三步即可完成调优：

第一步，开启G1垃圾收集器
第二步，设置堆的最大内存
第三步，设置最大的停顿时间

G1中提供了三种模式垃圾回收模式，Young GC、Mixed GC 和 Full GC，在不同的条件
下被触发。

2.4.1原理

G1垃圾收集器相对比其他收集器而言，最大的区别在于它取消了年轻代、老年代的物理划分，取而代之的是将堆划分为若干个区域（Region），这些区域中包含了有逻辑上的年轻代、老年代区域。
这样做的好处就是，我们再也不用单独的空间对每个代进行设置了，不用担心每个代内存是否足够。
在这里插入图片描述
在G1划分的区域中，年轻代的垃圾收集依然采用暂停所有应用线程的方式，将存活对象拷贝到老年代或者Survivor空间，G1收集器通过将对象从一个区域复制到另外一个区域，完成了清理工作。
这就意味着，在正常的处理过程中，G1完成了堆的压缩（至少是部分堆的压缩），这样也就不会有cms内存碎片问题的存在了。

在G1中，有一种特殊的区域，叫Humongous区域。

如果一个对象占用的空间超过了分区容量50%以上，G1收集器就认为这是一个巨型对象。
这些巨型对象，默认直接会被分配在老年代，但是如果它是一个短期存在的巨型对象，就会对垃圾收集器造成负面影响。
为了解决这个问题，G1划分了一个Humongous区，它用来专门存放巨型对象。如果一个H区装不下一个巨型对象，那么G1会寻找连续的H分区来存储。为了能找到连续的H区，有时候不得不启动Full GC.

2.4.2 Young GC

Young GC主要是对Eden区进行GC，它在Eden空间耗尽时会被触发。

Eden空间的数据移动到Survivor空间中，如果Survivor空间不够，Eden空间的部分
数据会直接晋升到年老代空间。
Survivor区的数据移动到新的Survivor区中，也有部分数据晋升到老年代空间中。
最终Eden空间的数据为空，GC停止工作，应用线程继续执行。

2.4.2.1Remembered Set（已记忆集合）

在GC年轻代的对象时，我们如何找到年轻代中对象的根对象呢？
根对象可能是在年轻代中，也可以在老年代中，那么老年代中的所有对象都是根么？
如果全量扫描老年代，那么这样扫描下来会耗费大量的时间。
于是，G1引进了RSet的概念。它的全称是Remembered Set，其作用是跟踪指向某个堆内的对象引用。

每个Region初始化时，会初始化一个RSet，该集合用来记录并跟踪其它Region指向该Region中对象的引用，每个Region默认按照512Kb划分成多个Card，所以RSet需要记录的东西应该是 xx Region的 xx Card。

2.4.3 Mixed GC

当越来越多的对象晋升到老年代old region时，为了避免堆内存被耗尽，虚拟机会触发一个混合的垃圾收集器，即Mixed GC，该算法并不是一个Old GC，除了回收整个YoungRegion，还会回收一部分的Old Region，这里需要注意：是一部分老年代，而不是全部老年代，可以选择哪些old region进行收集，从而可以对垃圾回收的耗时时间进行控制。
也要注意的是Mixed GC 并不是 Full GC。
MixedGC什么时候触发？由参数 -XX:InitiatingHeapOccupancyPercent=n 决定。默认：45%，该参数的意思是：当老年代大小占整个堆大小百分比达到该阀值时触发。
它的GC步骤分2步：

全局并发标记（global concurrent marking）
拷贝存活对象（evacuation）

2.4.3.1 全局并发标记

全局并发标记，执行过程分为五个步骤：

初始标记（initial mark，STW）
标记从根节点直接可达的对象，这个阶段会执行一次年轻代GC，会产生全局停顿。
根区域扫描（root region scan）
G1 GC 在初始标记的存活区扫描对老年代的引用，并标记被引用的对象。
该阶段与应用程序（非 STW）同时运行，并且只有完成该阶段后，才能开始下一次 STW 年轻代垃圾回收。
并发标记（Concurrent Marking）
G1 GC 在整个堆中查找可访问的（存活的）对象。该阶段与应用程序同时运行，可以被 STW 年轻代垃圾回收中断。
重新标记（Remark，STW）
该阶段是 STW 回收，因为程序在运行，针对上一次的标记进行修正。
清除垃圾（Cleanup，STW）
清点和重置标记状态，该阶段会STW，这个阶段并不会实际上去做垃圾的收集，等待evacuation阶段来回收。

2.4.3.2 拷贝存活对象

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

2.4.4 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%。

2.4.4.1 G1优化建议

年轻代大小
避免使用 -Xmn 选项或 -XX:NewRatio 等其他相关选项显式设置年轻代大小。
固定年轻代的大小会覆盖暂停时间目标。
暂停时间目标不要太过严苛
G1 GC 的吞吐量目标是 90% 的应用程序时间和 10%的垃圾回收时间。
评估 G1 GC 的吞吐量时，暂停时间目标不要太严苛。目标太过严苛表示您愿意承受更多的垃圾回收开销，而这会直接影响到吞吐量。

3. 可视化GC日志分析工具

3.1 GC日志输出参数

在日志打印输出涉及到的参数如下：

‐XX:+PrintGC 输出GC日志
‐XX:+PrintGCDetails 输出GC的详细日志
‐XX:+PrintGCTimeStamps 输出GC的时间戳（以基准时间的形式）
‐XX:+PrintGCDateStamps 输出GC的时间戳（以日期的形式，如 2013‐05‐
04T21:53:59.234+0800）
‐XX:+PrintHeapAtGC 在进行GC的前后打印出堆的信息
‐Xloggc:../logs/gc.log 日志文件的输出路径

测试：

-XX:+UseG1GC -XX:MaxGCPauseMillis=100 -Xmx256m -XX:+PrintGCDetails -XX:+PrintGCTimeStamps -XX:+PrintGCDateStamps -XX:+PrintHeapAtGC -Xloggc:F://test//gc.log

3.2 GC Easy 可视化工具

GC Easy是一款在线的可视化工具，易用、功能强大，网站：https://www.gceasy.io/

在这里插入图片描述

参考文章：
1.https://www.jianshu.com/p/86e358afdf17
2.http://www.ityouknow.com/jvm/2017/08/29/GC-garbage-collection.html

tobebetter9527

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
4. JVM垃圾回收

文章目录1. 垃圾回收常见算法1.1 引用计算法1.1.1 原理1.1.2 优缺点1. 垃圾回收常见算法包括引用计数法、标记清除法、标记压缩法、复制算法、分代算法等。1.1 引用计算法1.1.1 原理假设对象A，任何其他对象对A的引用，A的计数器加1，如果引用失败则减1，当A的计数器为0时，即没有引用，可以回收。1.1.2 优缺点优点：实时性较高，无需等内存不够才开始回收，直接根...
复制链接

扫一扫