zoukankan      html  css  js  c++  java
  • 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. 无法解决循环引用问题。(最大缺点)

    什么是循环引用:

    1. class TestA{

    2. public TestB b;

    3. }

    4. class TestB{

    5. public TestA a;

    6. }

    7. public class TestCycle {

    8. public static void main(String[] args) {

    9. TestA a = new TestA();

    10. TestB b = new TestB();

    11. a.b = b;

    12. b.a = a;

    13. a = null;

    14. b = null;

    15. }

    16. }

    虽然 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 编写测试代码
    1. // 实现:不断的产生新的数据(对象),随机的去废弃对象(垃圾)

    2. public static void main(String[] args) throws Exception {

    3. List<Object> list = new ArrayList<>();

    4. while (true){

    5. int sleep = new Random().nextInt(100);

    6. if(System.currentTimeMillis() % 2 ==0){

    7. //当前的时间戳,是偶数

    8. list.clear();

    9. }else{

    10. //向List中添加1000个对象

    11. for (int i = 0; i < 10000; i++) {

    12. Properties properties = new Properties();

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

    14. list.add(properties);

    15. }

    16. }

    17. Thread.sleep(sleep);

    18. }

    19. }

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

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

    • -XX:UseSerialGC:指定年轻代和老年代都是用串行垃圾收集器

    • -XX:PrintGCDetails:打印垃圾回收的详细信息

    1. # 为了测试GC,将堆的初始值和最大内存都设置为16M

    2. -XX:+UseSerialGC -XX:+PrintGCDetails -Xms16m -Xmx16m

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

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

    2. [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回收器,老年代使用的依然是串行收集器。

    测试:

    1. # 参数

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

    3. #打印的日志信息

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

    5. [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. 一般用于,手动调整参数比较困难的场景,让收集器自动进行调整

    1. #参数

    2. -XX:+UseParallelGC -XX:+UseParallelOldGC -XX:MaxGCPauseMillis=100 -XX:+PrintGCDetails -Xms16m -Xmx16m

    3. #打印的信息

    4. [GC (Allocation Failure) [PSYoungGen: 4096K->512K(4608K)] 4096K->1683K(15872K), 0.0021804 secs] [Times: user=0.00 sys=0.00, real=0.00 secs]

    5. [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),与用户线程同时运行

    测试:

    1. #设置启动参数

    2. -XX:+UseConcMarkSweepGC -XX:+PrintGCDetails -Xms16m -Xmx16m

    3. #运行日志

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

    5. #第一步:初始3标记

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

    7. #第二步:并发标记

    8. [CMS-concurrent-mark-start]

    9. [CMS-concurrent-mark: 0.002/0.002 secs] [Times: user=0.00 sys=0.00, real=0.00 secs]

    10. #第三步:预处理

    11. [CMS-concurrent-preclean-start]

    12. [CMS-concurrent-preclean: 0.000/0.000 secs] [Times: user=0.00 sys=0.00, real=0.00 secs]

    13. #第四步:重新标记

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

    15. #第五步:并发清理

    16. [CMS-concurrent-sweep-start]

    17. [CMS-concurrent-sweep: 0.002/0.002 secs] [Times: user=0.00 sys=0.00, real=0.00 secs]

    18. #第六步:重置

    19. [CMS-concurrent-reset-start]

    20. [CMS-concurrent-reset: 0.000/0.000 secs] [Times: user=0.00 sys=0.00, real=0.00 secs]

  • 相关阅读:
    什么是IOC
    spring的作用
    什么是spring框架?
    72
    71
    70
    69
    68
    67
    66
  • 原文地址:https://www.cnblogs.com/caicz/p/12794333.html
Copyright © 2011-2022 走看看