JVM性能优化(二)垃圾回收算法详解

一、什么是垃圾回收

程序的运行必然需要申请内存资源,无效的对象资源如果不及时处理就会一直占用内存资源,最终将导致内存溢出,所以对内存资源的管理是非常重要了。

1.1 C/C++语言的垃圾回收

在C/C++语言中,没有自动垃圾回收机制,是通过new关键字申请内存资源,通过delete 关键字释放内存资源,如果程序员在某些位置没有写delete进行释放,那么申请的对象将一直占用内存资源,最终可能会导致内存溢出。

1.2 Java语言的垃圾回收

为了让程序员更专注于代码的实现,而不用过多的考虑内存释放的问题,所以在Java语言中,有了自动的垃圾回收机制,也就是我们熟悉的GC。
有了垃圾回收机制后,程序员只需要关心内存的申请即可,内存的释放由系统自动识别完成。
换句话说,自动的垃圾回收的算法会变得非常重要了,如果因为算法的不合理,导致内存一直没有释放,同样也可能会导致内存溢出的。
除了Java语言,C#、Python等语言也都有自动的垃圾回收机制。

二、垃圾回收的常见算法

自动化的管理内存资源,垃圾回收机制必须要有一套算法来进行计算,哪些是有效的对象,哪些是无效的对象,对于无效的对象就要进行回收处理。
常见的垃圾回收算法有:引用计数法、标记清除法、标记压缩法、复制算法、分代算法等。

2.1 引用计数法

引用计数是历史最悠久的一种算法,最早George E.Collins在1960的时候首次提出,50年后的今天,该算法依然被很多编程语言使用。

2.1.1 原理

假设有一个对象A,任何一个对象对A的引用,那么对象A的引用计数器+1,当引用失败时,对象A的引用计数器就-1,如果对象A的计数器的值为0,就说明对象A没有引用了,可以被回收。

如图所示:
在这里插入图片描述

2.1.2 优缺点
  • 优点:

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

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

什么是循环引用:

class TestA{
	public TestB b;
}

class TestB{
	public TestA a;
}
public class TestCycle {

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

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

如图所示:
在这里插入图片描述

2.2 标记清除法

标记清除算法,是将垃圾回收分为2个阶段,分别是 标记和清除

  • 标记:从根节点开始标记引用的对象
  • 清除:未被标记引用的对象就是垃圾对象,可以被清理
2.2.1 原理:

在这里插入图片描述
这张图代表的是程序运行期间所有对象的状态,他们的标志位全部是0(也就是未标记,以下默认0就是未标记,1为已标记),假设现在有效内存空间耗尽了,JVM将会停止应用程序的运行并开启GC线程,然后开始进行标记工作,按照根据搜索算法,标记完成以后,对象的状态如下图所示:
在这里插入图片描述

2.2.2 优缺点:

可以看到,标记清楚算法解决了引用计数算法中的循环引用的问题,没有从root节点引用的对象都会被回收。
同样标记清楚算法也是有缺点的:

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

2.3 标记压缩算法

标记压缩算法是在标记清除算法的基础之上,做了优化改进的算法,和标记清除算法一样,也是从根节点开始,对对象的引用进行标记,在清理阶段,并不是简单的清理未标记的对象,而是将存活的对象压缩到内存的一端,然后清理边界以外的垃圾,从而解决了碎片化的问题。

2.3.1 原理:

在这里插入图片描述

2.3.2 优缺点:

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

2.4 复制算法

复制算法的核心就是,将原有的内存空间一分为二,每次只用其中的一块,在垃圾回收时,将正在使用的对象复制到另一个内存空间中,然后将该内存空间清空,交换两个内存的角色,完成垃圾的回收。
如果内存的垃圾对象较多,需要复制的对象就较少,这种情况下适合使用该方式并且效率比较高,反之,则不适合。

在这里插入图片描述

在这里插入图片描述

2.4.1 JVM中年轻代内存空间:

在这里插入图片描述

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

优点:

  • 在垃圾对象多的情况下,效率较高
  • 清理后,内存无碎片

缺点:

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

2.4 分代算法

前面介绍了多种回收算法,没有算法都有自己的优点也有缺点,谁都不能替代谁,所以根据垃圾回收对象的特点进行选择,才是明智的选择。
分代算法其实就是这样,根据回收算法的特点进行选择,在JVM中,年轻代适合使用复制算法,老年代适合使用标记清楚或标记压缩算法。

三、垃圾收集器以及内存分配

上面我们介绍了垃圾回收的算法,还需要有具体的体现,在jvm中,实现了多种垃圾收集器,包括:串行垃圾收集器、并行垃圾收集器、CMS(并发)垃圾收集器,G1垃圾收集器,接下来,我们一个个的了解学习。

3.1、串行垃圾收集器

串行垃圾收集器,是指使用单线程进行垃圾回收,垃圾回收时,只有一个线程在工作,并且java应用中的所有线程都要暂停,等待垃圾回收的完成,这种现象称之为 STW(Stop-The-World)。
对于交互性较强的应用而言,这种垃圾收集器是不能够接收的。
一般在javaweb应用中是不会采用该收集器的。

3.1.1 编写测试代码
   // 实现:不断的产生新的数据(对象),随机的去废弃对象(垃圾)
    public static void main(String[] args) throws Exception {
        List<Object> list = new ArrayList<>();
        while (true){
            int sleep = new Random().nextInt(100);
            if(System.currentTimeMillis() % 2 ==0){
                //当前的时间戳,是偶数
                list.clear();
            }else{
                //向List中添加1000个对象
                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);
        }
    }
3.1.2 设置垃圾回收为串行收集器

在这里插入图片描述

在程序运行参数添加2个参数,如下:

  • -XX:UseSerialGC:指定年轻代和老年代都是用串行垃圾收集器
  • -XX:PrintGCDetails:打印垃圾回收的详细信息
# 为了测试GC,将堆的初始值和最大内存都谁知为16M
-XX:+UseSerialGC -XX:+PrintGCDetails -Xms16m -Xmx16m

启动程序后,可以看到下面信息:

[GC (Allocation Failure) [DefNew: 4416K->511K(4928K), 0.0052836 secs] 4416K->1768K(15872K), 0.0053321 secs] [Times: user=0.00 sys=0.00, real=0.01 secs] 

[Full GC (Allocation Failure) [Tenured: 10943K->10943K(10944K), 0.0186019 secs] 15871K->14611K(15872K), [Metaspace: 3828K->3828K(1056768K)], 0.0186344 secs] [Times: user=0.02 sys=0.00, real=0.02 secs] 

GC日志信息解读:
年轻代的内存GC前后的大小:

  • DefNew:表示使用的是串行垃圾收集器
  • 4416K->511K(4928K): 表示,年轻代GC前,占有4416K内存,GC后,占有512K内存,总大小4928K
  • 0.0052836 secs: 表示,GC所用的时间,单位为毫秒
  • **4416K->1768K(15872K):**表示,GC前,堆内存占有4416K,GC后,占有1973K,总大小为 15872K
  • Full GC: 表示,内存空间全部进行GC

3.2、并行垃圾收集器

并行垃圾收集器在串行垃圾收集器的基础之上做了改进,将单线程改为多线程进行垃圾回收,这样可以缩短垃圾回收的时间(这里是指,并行能力较强的机器)
不过,并行垃圾收集器在收集的过程中也会暂停应用程序,这个和串行垃圾回收器是一样的,只是并行执行,速度更快些,暂停的时间更短一些。

3.2.1 parNew垃圾收集器

ParNew垃圾收集器是工作在年轻代上的,只是将串行的垃圾收集器改为了并行。
通过 -XX:UseParNewGC 参数设置年轻代使用ParNew回收器,老年代使用的依然是串行收集器。

测试:
在这里插入图片描述

# 参数
-XX:+UseParNewGC -XX:+PrintGCDetails -Xms16m -Xmx16m

# 打印的日志信息
[GC (Allocation Failure) [ParNew: 4416K->512K(4928K), 0.0015707 secs] 4416K->1818K(15872K), 0.0016110 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 

[Full GC (Allocation Failure) [Tenured: 10944K->1185K(10944K), 0.0086455 secs] 15872K->1185K(15872K), [Metaspace: 3835K->3835K(1056768K)], 0.0086862 secs] [Times: user=0.00 sys=0.00, real=0.01 secs] 

由以上信息可以看出,ParNew: 使用的是ParNew收集器,其他信息和串行收集器一致。

3.2.2 ParallelGC垃圾收集器

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

  • -XX:+UserParallelGC: 年轻代使用ParallelGC垃圾回收器,老年代使用串行回收器

  • -XX:+UseParallelOldGC: 年轻代使用ParallelGC垃圾回收器,来年代使用ParallelOldGC垃圾回收器

  • -XX:MaxGCPauseMillis:

    1. 设置最大的垃圾收集时的停顿时间,单位为毫秒
    2. 需要注意的是,ParallelGC为了达到设置的停顿时间,可能会调整堆大小或其他的参数,如果堆的大小设置的较小,就会导致GC工作变的频繁,反而可能影响到性能。
    3. 使用这个参数需谨慎
  • -XX:GCTimeRatio

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

    1. 自适应GC模式,垃圾回收器将自动调整新生代,老年代等参数,达到吞吐量,堆大小、停顿时间之间的平衡
    2. 一般用于,手动调整参数比较困难的场景,让收集器自动进行调整
#参数
-XX:+UseParallelGC -XX:+UseParallelOldGC -XX:MaxGCPauseMillis=100 -XX:+PrintGCDetails -Xms16m -Xmx16m

#打印的信息
[GC (Allocation Failure) [PSYoungGen: 4096K->512K(4608K)] 4096K->1683K(15872K), 0.0021804 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 

[Full GC (Ergonomics) [PSYoungGen: 1472K->0K(3584K)] [ParOldGen: 9577K->3990K(11264K)] 11049K->3990K(14848K), [Metaspace: 3828K->3828K(1056768K)], 0.0191664 secs] [Times: user=0.01 sys=0.00, real=0.02 secs] 

3.3、CMS垃圾收集器

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

CMS垃圾回收器的执行过程中如下:
在这里插入图片描述

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

测试:
在这里插入图片描述

#设置启动参数
-XX:+UseConcMarkSweepGC -XX:+PrintGCDetails -Xms16m -Xmx16m

#运行日志
[GC (Allocation Failure) [ParNew: 4416K->511K(4928K), 0.0050460 secs] 4416K->1954K(15872K), 0.0050891 secs] [Times: user=0.00 sys=0.00, real=0.01 secs] 

#第一步:初始3标记
[GC (CMS Initial Mark) [1 CMS-initial-mark: 6075K(10944K)] 6938K(15872K), 0.0003563 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: 862 K (4928 K)][Rescan (parallel) , 0.0001950 secs][weak refs processing, 0.0000292 secs][class unloading, 0.0003607 secs][scrub symbol table, 0.0005794 secs][scrub string table, 0.0002047 secs][1 CMS-remark: 6075K(10944K)] 6938K(15872K), 0.0015122 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 

#第五步:并发清理
[CMS-concurrent-sweep-start]
[CMS-concurrent-sweep: 0.002/0.002 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] 

四、结束语

今天的内容就到这里了,文中详细描述了 垃圾回收算法和垃圾收集器的类型和作用,也通过案例给大家展示出来了,大家有什么疑问或者问题可以在下方留言,我会在第一时间回复大家,下一篇会讲最重要的垃圾收集器——G1垃圾收集器,感兴趣的小伙伴记得关注,大家加油,我是牧小农,我为自己代言。

牧小农 CSDN认证博客专家 Java后端 大数据 数据库
专注Java领域开发,从使用技巧到底层源码,从数据库到大数据,从多线程到高并发,你想要的这里都有,一个人可能走得更快,但是一群人会走得更远,快快订阅关注牧小农,让我们一起走的更远,关注小农,将知识打包带走,大家加油
相关推荐
©️2020 CSDN 皮肤主题: Age of Ai 设计师:meimeiellie 返回首页