JVM Survivor行为一探究竟

傷城~ 2021-06-22 15:37 325阅读 0赞

# MaxTenuringThreshold: #

说到Survivor就不得不提及这个参数，笨神（**微信公众号："你假笨"**, 想学习JVM调优的话，强烈推荐关注这个公众号）昨天在JVM分享群里分享了这个参数, 总结如下:  
这个参数主要作用是设置在YGC的时候，新生代的对象正常情况下**最多经过多少次YGC**的过程会晋升到老生代，注意是表示最多而不是一定，也就是说某个对象的age其实并不是一定要达到这个值才会晋升到Old的，当你设置这个值的时候，第一次会以它为准，后面的就不一定以它为准了，而是JVM会自动计算在0～15之间决定，但不会超过这个值。如果配置了CMS GC，这个值默认是6；PS的话这个值默认是15。这个值最大你可以设置到15，因为jvm里就4个bit来存这个值，所以最大就是1111，即15；

# 引申问题 #

那么JVM是怎么计算接下来S区的对象晋升到Old区的age的呢?介绍两个重要的JVM参数:

### \-XX:TargetSurvivorRatio ###

一个计算期望S区存活大小(Desired survivor size)的参数. 默认参数为50，即50%。可参考JVMPocket。

### PrintTenuringDistribution ###

输出S区各个age的对象信息, 用法:-XX:+PrintTenuringDistribution, -XX:-PrintTenuringDistribution  
例如, gc日志如下:  
new threshold 1 (max 6)  
\- age 1: 1048608 bytes, 1048608 total  
\- age 2: 524304 bytes, 1572912 total

当一个S区中各个age的对象的总size大于或等于Desired survivor size ( TargetSurvivorRatio \* S0 / 100 )，则重新计算age，以age和MaxTenuringThreshold两者的最小值为准；验证这个结论的Java代码如下：

public class GcSurvivorTest {
    
        public static void main(String[] args) throws InterruptedException {
    
            // 这两个对象不会被回收, 用于在s0和s1不断来回拷贝增加age直到达到PretenureSizeThreshold晋升到old
            byte[] byte1m_1 = new byte[1 * 512 * 1024];
            byte[] byte1m_2 = new byte[1 * 512 * 1024];
    
            // YoungGC后, byte1m_1 和 byte1m_2的age为1
            youngGc(1);
            Thread.sleep(3000);
    
            // 再次YoungGC后, byte1m_1 和 byte1m_2的age为2
            youngGc(1);
            Thread.sleep(3000);
    
            // 第三次YoungGC后, byte1m_1 和 byte1m_2的age为3
            youngGc(1);
            Thread.sleep(3000);
    
            // 这次再ygc时, 由于byte1m_1和byte1m_2的年龄已经是3，且MaxTenuringThreshold=3, 所以这两个对象会晋升到Old区域,且ygc后, s0(from)和s1(to)空间中的对象被清空
            youngGc(1);
            Thread.sleep(3000);
    
            // main方法中分配的对象不会被回收, 不断分配是为了达到TargetSurvivorRatio这个比例指定的值, 即5M*60%=3M(Desired survivor size)，说明: 5M为S区的大小，60%为TargetSurvivorRatio参数指定，如下三个对象分配后就能够达到Desired survivor size
            byte[] byte1m_4 = new byte[1 * 1024 * 1024];
            byte[] byte1m_5 = new byte[1 * 1024 * 1024];
            byte[] byte1m_6 = new byte[1 * 1024 * 1024];
    
            // 这次ygc时, 由于s区已经占用达到了60%(-XX:TargetSurvivorRatio=60), 所以会重新计算对象晋升的age，计算公式为：min(age, MaxTenuringThreshold) = 1
            youngGc(1);
            Thread.sleep(3000);
    
            // 由于前一次ygc时算出age=1, 所以这一次再ygc时, byte1m_4, byte1m_5, byte1m_6就会晋升到Old区, 而不需要等MaxTenuringThreshold这么多次, 此次ygc后, s0(from)和s1(to)空间中对象再次被清空, 对象全部晋升到old
            youngGc(1);
            Thread.sleep(3000);
    
            System.out.println("hello world");
        }
    
        private static void youngGc(int ygcTimes){
            for(int i=0; i<ygcTimes*40; i++) {
                byte[] byte1m = new byte[1 * 1024 * 1024];
            }
        }
    
    }

> 代码配套的JVM参数(Eden: 40M, S0/S1: 5M, Old: 150M):  
> \-verbose:gc -Xmx200M -Xmn50M -XX:TargetSurvivorRatio=60 -XX:+PrintTenuringDistribution -XX:+PrintGCDetails -XX:+PrintGCDateStamps -XX:+UseConcMarkSweepGC -XX:+UseParNewGC -XX:MaxTenuringThreshold=3

由于JVM参数申明了-verbose:gc, 所以直接可以通过控制台输出gc日志信息验证上面的结论，gc日志如下：

//第一次YGC
    2017-07-22T17:43:50.615-0800: [GC (Allocation Failure) 2017-07-22T17:43:50.615-0800: [ParNew: 39936K->2812K(46080K), 0.0126581 secs] 39936K->2812K(125952K), 0.0127387 secs] [Times: user=0.00 sys=0.00, real=0.01 secs]  
    //第二次YGC
    2017-07-22T17:43:53.653-0800: [GC (Allocation Failure) 2017-07-22T17:43:53.653-0800: [ParNew: 43542K->2805K(46080K), 0.0144079 secs] 43542K->2805K(125952K), 0.0144607 secs] [Times: user=0.01 sys=0.00, real=0.01 secs] 
    //第三次YGC
    2017-07-22T17:43:56.679-0800: [GC (Allocation Failure) 2017-07-22T17:43:56.679-0800: [ParNew: 43329K->2877K(46080K), 0.0010447 secs] 43329K->2877K(125952K), 0.0010784 secs] [Times: user=0.01 sys=0.00, real=0.01 secs] 
    //三次YGC后，此时age达到MaxTenuringThreshold阈值3，再次YGC时，会晋升到Old区，可以看到此时新生代空间为0
    2017-07-22T17:43:59.691-0800: [GC (Allocation Failure) 2017-07-22T17:43:59.691-0800: [ParNew: 43604K->0K(46080K), 0.0065182 secs] 43604K->2675K(125952K), 0.0065664 secs] [Times: user=0.01 sys=0.01, real=0.00 secs] 
    //分配3M不回收的对象，经历一次YGC，此时age=1
    2017-07-22T17:44:02.708-0800: [GC (Allocation Failure) 2017-07-22T17:44:02.708-0800: [ParNew: 40731K->3072K(46080K), 0.0050035 secs] 43406K->5747K(125952K), 0.0050444 secs] [Times: user=0.00 sys=0.00, real=0.01 secs] 
    //此时可以看到，3M的对象也被晋升到了Old区，这可以证明，如果只靠MaxTenuringThreshold来决定多少次YGC才晋升到Old区的话，此时age=1，并没有达到阈值。
    //因为此时3m达到TargetSurvivorRatio=60（5M*60=3m）的要求，那么前一次YGC，会重新计算对象晋升的threshold=min(age, MaxTenuringThreshold) = min(1,3) = 1次，所以此时晋升到了Old区
    2017-07-22T17:44:05.722-0800: [GC (Allocation Failure) 2017-07-22T17:44:05.722-0800: [ParNew: 43806K->0K(46080K), 0.0060735 secs] 46481K->5747K(125952K), 0.0061215 secs] [Times: user=0.01 sys=0.00, real=0.00 secs] 
    GC end!
    Heap
     par new generation   total 46080K, used 18003K [0x00000007b3800000, 0x00000007b6a00000, 0x00000007b6a00000)
      eden space 40960K,  43% used [0x00000007b3800000, 0x00000007b4994d88, 0x00000007b6000000)
      from space 5120K,   0% used [0x00000007b6000000, 0x00000007b6000000, 0x00000007b6500000)
      to   space 5120K,   0% used [0x00000007b6500000, 0x00000007b6500000, 0x00000007b6a00000)
     concurrent mark-sweep generation total 79872K, used 5747K [0x00000007b6a00000, 0x00000007bb800000, 0x00000007c0000000)
     Metaspace       used 3267K, capacity 4494K, committed 4864K, reserved 1056768K
      class space    used 354K, capacity 386K, committed 512K, reserved 1048576K

2017-07-22T18:07:51.401-0800: [GC (Allocation Failure) 2017-07-22T18:07:51.401-0800: [ParNew
    Desired survivor size 3145728 bytes, new threshold 3 (max 3)
    - age   1:    2854440 bytes,    2854440 total
    : 39936K->2819K(46080K), 0.0136187 secs] 39936K->2819K(125952K), 0.0138705 secs] [Times: user=0.01 sys=0.01, real=0.01 secs] 
    2017-07-22T18:07:54.452-0800: [GC (Allocation Failure) 2017-07-22T18:07:54.452-0800: [ParNew
    Desired survivor size 3145728 bytes, new threshold 3 (max 3)
    - age   2:    2682504 bytes,    2682504 total
    : 43549K->2918K(46080K), 0.0172463 secs] 43549K->2918K(125952K), 0.0173506 secs] [Times: user=0.00 sys=0.00, real=0.02 secs] 
    2017-07-22T18:07:57.484-0800: [GC (Allocation Failure) 2017-07-22T18:07:57.484-0800: [ParNew
    Desired survivor size 3145728 bytes, new threshold 3 (max 3)
    - age   3:    2680152 bytes,    2680152 total
    : 43442K->2723K(46080K), 0.0115410 secs] 43442K->2723K(125952K), 0.0116179 secs] [Times: user=0.00 sys=0.00, real=0.01 secs] 
    2017-07-22T18:08:00.511-0800: [GC (Allocation Failure) 2017-07-22T18:08:00.511-0800: [ParNew
    Desired survivor size 3145728 bytes, new threshold 3 (max 3)
    : 43449K->0K(46080K), 0.0226608 secs] 43449K->2673K(125952K), 0.0228187 secs] [Times: user=0.03 sys=0.00, real=0.02 secs] 
    2017-07-22T18:08:03.547-0800: [GC (Allocation Failure) 2017-07-22T18:08:03.547-0800: [ParNew
    Desired survivor size 3145728 bytes, new threshold 1 (max 3)
    - age   1:    3145776 bytes,    3145776 total
    : 40731K->3072K(46080K), 0.0055686 secs] 43404K->5745K(125952K), 0.0056352 secs] [Times: user=0.01 sys=0.00, real=0.01 secs] 
    2017-07-22T18:08:06.572-0800: [GC (Allocation Failure) 2017-07-22T18:08:06.572-0800: [ParNew
    Desired survivor size 3145728 bytes, new threshold 3 (max 3)
    : 43806K->0K(46080K), 0.0068945 secs] 46479K->5745K(125952K), 0.0070480 secs] [Times: user=0.00 sys=0.01, real=0.00 secs] 
    GC end!
    Heap
     par new generation   total 46080K, used 18003K [0x00000007b3800000, 0x00000007b6a00000, 0x00000007b6a00000)
      eden space 40960K,  43% used [0x00000007b3800000, 0x00000007b4994d88, 0x00000007b6000000)
      from space 5120K,   0% used [0x00000007b6000000, 0x00000007b6000000, 0x00000007b6500000)
      to   space 5120K,   0% used [0x00000007b6500000, 0x00000007b6500000, 0x00000007b6a00000)
     concurrent mark-sweep generation total 79872K, used 5745K [0x00000007b6a00000, 0x00000007bb800000, 0x00000007c0000000)
     Metaspace       used 3273K, capacity 4494K, committed 4864K, reserved 1056768K
      class space    used 354K, capacity 386K, committed 512K, reserved 1048576K

MaxTenuringThreshold该参数用于控制对象经过GC多少次仍然存活后晋升到老年代的最大阈值，参数最大可配置为15，即对象最多经过15次GC后仍然存活就会晋升到老年代

记住！是最大！也就是说实际上不一定会经过15次才能晋升！这个值的JVM内部会进行动态计算然后动态改变的。

最近在线上有个应用GC非常频繁，MaxTenuringThreshold参数配置的是15，而以前对这个参数的理解是一定要经过15次后才会晋升，所以导致整个排查过程根本就不对，线上日志如下：

Desired survivor size 184549376 bytes, new threshold 1 (max 15)
    - age   1:        369096960 bytes,        369096960 total
    ....下面进行GC，年轻代有很多对象全跑到了老年代

当时思考方向是：age为1，离15有很大的距离，不应该会晋升，老年代空间增加是因为大对象

这个思考方向真是大错特错了，因为对MaxTenuringThreshold理解错了。注意日志中有几个关键字

new threshold 1 (max 15)

意思是说阈值现在变成了1，而不是15！所以直接就晋升了！那么为什么会变成1呢，这个动态计算的算法是怎么样的，参考了一下一些大神的文章再看了下源码，终于发现原因所在，直接看源码会比较清晰，源码如下：

int ageTable::compute_tenuring_threshold(size_t survivor_capacity) {
      //TargetSurvivorRatio默认为50
      //desired_survivor_size = survivor的空间*50%
      size_t desired_survivor_size = (size_t)((((double) survivor_capacity)*TargetSurvivorRatio)/100);
      size_t total = 0;
      int age = 1;
      assert(sizes[0] == 0, "no objects with age zero should be recorded");
      while (age < table_size) {
        // 循环遍历所有年龄代的对象累加得到一个大小
        total += sizes[age];
        // 如果该大小大于desired_survivor_size，即survivor的空间*50%，那么退出循环
        if (total > desired_survivor_size) break;
        age++;
      }
      // 如果算出来的age大于MaxTenuringThreshold则使用MaxTenuringThreshold，否则使用计算出来的age
      int result = age < MaxTenuringThreshold ? age : MaxTenuringThreshold;
    
      if (PrintTenuringDistribution || UsePerfData) {
        if (PrintTenuringDistribution) {
          gclog_or_tty->cr();
          // 这里就是线上出现的那个日志所在的地方
          gclog_or_tty->print_cr("Desired survivor size %ld bytes, new threshold %d (max %d)",
            desired_survivor_size*oopSize, result, MaxTenuringThreshold);
        }
      //....
      }
      // 返回计算的年龄
      return result;
    }

经过多次GC，存活的对象会在From和To两个地方来回的存放，而前提是两个空间能有足够的大小去存放这些数据，上述算法中，会计算每个年龄的大小，如果达到某个年龄后发现总大小以及大于Survivor的大小的50%，那么这时候就需要调整阈值，不能继续等到15次GC后才晋升，这样会导致Survivor的空间不足，所以调整阈值，让其尽快晋升

回到线上的那个例子，线上我记得是没配置TargetSurvivorRatio属性，那么按照50%算，survivor \* 50%=184549376，在while循环中计算第一个年龄代=369096960>184549376，那么退出循环，此时计算得到的年龄为1，所以这个年龄的对象会提前晋升