JVM自动内存管理机制——Java内存区域（下）

一、虚拟机参数配置

　　在上一篇《java自动内存管理机制——java内存区域（上）》中介绍了有关的基础知识，这一篇主要是通过一些示例来了解有关虚拟机参数的配置。

　　1、java堆参数设置

　　a）下面是一些简单的使用参数

　　其中最后一个是一个运行时参数设置的简单实例。一般-xx是系统级别的配置（日志信息，或者是配置使用什么样的垃圾回收器等等），后面跟上+表示启用。不是-xx基本上是对于应用层面的配置信息

　　

　　下面是一个简单的实例：表示设置初始堆大小为5m，最大堆大小为20m，并将虚拟机的参数设置打印出来，后面会用示例程序来说明

　　

　　b）如下所示程序：

 1 package cn.jvm.test;
 2 
 3 public class test01 {
 4     //-xx:+printgc -xms5m -xmx20m -xx:+useserialgc  -xx:+printgcdetails -xx:+printcommandlineflags
 5 
 6     public static void main(string[] args) {
 7 
 8         //查看gc信息
 9         system.out.println("没有分配时候");
10         system.out.println("最大堆内存===" + runtime.getruntime().maxmemory());
11         system.out.println("空闲内存===" + runtime.getruntime().freememory());
12         system.out.println("总内存===" + runtime.getruntime().totalmemory());
13 
14         byte[] testbyte1 = new byte[1024 * 1024];
15         system.out.println("分配了1m");
16         system.out.println("最大堆内存===" + runtime.getruntime().maxmemory());
17         system.out.println("空闲内存===" + runtime.getruntime().freememory());
18         system.out.println("总内存===" + runtime.getruntime().totalmemory());
19 
20         byte[] testbyte2 = new byte[4 * 1024 * 1024];
21         system.out.println("分配了4m");
22         system.out.println("最大堆内存===" + runtime.getruntime().maxmemory());
23         system.out.println("空闲内存===" + runtime.getruntime().freememory());
24         system.out.println("总内存===" + runtime.getruntime().totalmemory());
25 
26     }
27 }

　　然后配置上  -xms5m -xmx20m -xx:+useserialgc  -xx:+printgcdetails -xx:+printcommandlineflags参数来运行查看结果信息，在idea中进入，然后在vm options中设置上面配置的参数

　　c）分析结果

"e:\program files\java\jdk1.8.0_141\bin\java.exe" -xms5m -xmx20m -xx:+useserialgc -xx:+printgcdetails -xx:+printcommandlineflags "-javaagent:e:\program files\intellij idea 2018.3.3\lib\idea_rt.jar=49362:e:\program files\intellij idea 2018.3.3\bin" -dfile.encoding=utf-8 -classpath "e:\program files\java\jdk1.8.0_141\jre\lib\charsets.jar;e:\program files\java\jdk1.8.0_141\jre\lib\deploy.jar;e:\program files\java\jdk1.8.0_141\jre\lib\ext\access-bridge-64.jar;e:\program files\java\jdk1.8.0_141\jre\lib\ext\cldrdata.jar;e:\program files\java\jdk1.8.0_141\jre\lib\ext\dnsns.jar;e:\program files\java\jdk1.8.0_141\jre\lib\ext\jaccess.jar;e:\program files\java\jdk1.8.0_141\jre\lib\ext\jfxrt.jar;e:\program files\java\jdk1.8.0_141\jre\lib\ext\localedata.jar;e:\program files\java\jdk1.8.0_141\jre\lib\ext\nashorn.jar;e:\program files\java\jdk1.8.0_141\jre\lib\ext\sunec.jar;e:\program files\java\jdk1.8.0_141\jre\lib\ext\sunjce_provider.jar;e:\program files\java\jdk1.8.0_141\jre\lib\ext\sunmscapi.jar;e:\program files\java\jdk1.8.0_141\jre\lib\ext\sunpkcs11.jar;e:\program files\java\jdk1.8.0_141\jre\lib\ext\zipfs.jar;e:\program files\java\jdk1.8.0_141\jre\lib\javaws.jar;e:\program files\java\jdk1.8.0_141\jre\lib\jce.jar;e:\program files\java\jdk1.8.0_141\jre\lib\jfr.jar;e:\program files\java\jdk1.8.0_141\jre\lib\jfxswt.jar;e:\program files\java\jdk1.8.0_141\jre\lib\jsse.jar;e:\program files\java\jdk1.8.0_141\jre\lib\management-agent.jar;e:\program files\java\jdk1.8.0_141\jre\lib\plugin.jar;e:\program files\java\jdk1.8.0_141\jre\lib\resources.jar;e:\program files\java\jdk1.8.0_141\jre\lib\rt.jar;e:\ideaproject\jvm\out\production\jvm" cn.jvm.test.test01
-xx:initialheapsize=5242880 -xx:maxheapsize=20971520 -xx:+printcommandlineflags -xx:+printgcdetails -xx:+usecompressedclasspointers -xx:+usecompressedoops -xx:-uselargepagesindividualallocation -xx:+useserialgc 
[gc (allocation failure) [defnew: 1664k->192k(1856k), 0.0018176 secs] 1664k->605k(5952k), 0.0028416 secs] [times: user=0.00 sys=0.00, real=0.00 secs] 
没有分配时候
最大堆内存===20316160
空闲内存===5202432
总内存===6094848
分配了1m
最大堆内存===20316160
空闲内存===4149872
总内存===6094848
[gc (allocation failure) [defnew: 1485k->31k(1856k), 0.0025246 secs][tenured: 1626k->1658k(4096k), 0.0031723 secs] 1899k->1658k(5952k), [metaspace: 3432k->3432k(1056768k)], 0.0061214 secs] [times: user=0.00 sys=0.00, real=0.01 secs] 
分配了4m
最大堆内存===20316160
空闲内存===4406496
总内存===10358784
2112
heap
 def new generation   total 1920k, used 76k [0x00000000fec00000, 0x00000000fee10000, 0x00000000ff2a0000)
  eden space 1728k,   4% used [0x00000000fec00000, 0x00000000fec13018, 0x00000000fedb0000)
  from space 192k,   0% used [0x00000000fedb0000, 0x00000000fedb0000, 0x00000000fede0000)
  to   space 192k,   0% used [0x00000000fede0000, 0x00000000fede0000, 0x00000000fee10000)
 tenured generation   total 8196k, used 5754k [0x00000000ff2a0000, 0x00000000ffaa1000, 0x0000000100000000)
   the space 8196k,  70% used [0x00000000ff2a0000, 0x00000000ff83e998, 0x00000000ff83ea00, 0x00000000ffaa1000)
 metaspace       used 3469k, capacity 4496k, committed 4864k, reserved 1056768k
  class space    used 380k, capacity 388k, committed 512k, reserved 1048576k

process finished with exit code 0

输出的整个结果

　　我们通过查看输出结果和打印的日志信息，结合刚刚设置的参数来简单分析一下java堆参数和程序运行的关系

　　1）我们在参数设置中配置了–xx:+printcommandlineflags就会在结果中打印下面的信息

-xx:initialheapsize=5242880 -xx:maxheapsize=20971520 -xx:+printcommandlineflags -xx:+printgcdetails -xx:+usecompressedclasspointers -xx:+usecompressedoops -xx:-uselargepagesindividualallocation -xx:+useserialgc 

　　然后将这些信息做一简单的解释：

1 -xx:initialheapsize=5242880  //设置初始堆大小（我们在参数设置中设置为5m）
2 -xx:maxheapsize=20971520  //设置最大堆大小（参数设置中设置为10m）
3 -xx:+printcommandlineflags  //打印自己设置的jvm参数
4 -xx:+printgcdetails //打印包括新生代（eden、from、to）和老年代以及元空间的信息
5 -xx:+usecompressedclasspointers //使用-xx:+usecompressedclasspointers选项来压缩类指针,对象中指向类元数据的指针会被压缩成32位,类指针压缩空间会有一个基地址
6 -xx:+usecompressedoops//使用-xx:+usecompressedoops压缩对象指针,"oops"指的是普通对象指针("ordinary" object pointers)。
　　　　　　　　　　　　　　　 java堆中对象指针会被压缩成32位。使用堆基地址（如果堆在低26g内存中的话，基地址为0）
7 -xx:-uselargepagesindividualallocation 
8 -xx:+useserialgc  //使用串行收集器

　　2）下面是输出结果信息，我们来具体的看一下每行代表的含义

 1 [gc (allocation failure) [defnew: 1647k->192k(1856k), 0.0026381 secs] 1647k->604k(5952k), 0.0035661 secs] [times: user=0.00 sys=0.00, real=0.00 secs] 
 2 没有分配时候
 3 最大堆内存===20316160
 4 空闲内存===5177136
 5 总内存===6094848
 6 分配了1m
 7 最大堆内存===20316160
 8 空闲内存===4128544
 9 总内存===6094848
10 [gc (allocation failure) [defnew: 1508k->30k(1856k), 0.0031475 secs][tenured: 1626k->1656k(4096k), 0.0031027 secs] 1920k->1656k(5952k), [metaspace: 3411k->3411k(1056768k)], 0.0067187 secs] [times: user=0.00 sys=0.00, real=0.01 secs] 
11 分配了4m
12 最大堆内存===20316160
13 空闲内存===4401904
14 总内存===10358784

 　　①[gc (allocation failure) [defnew: 1647k->192k(1856k), 0.0026381 secs] 1647k->604k(5952k), 0.0035661 secs] [times: user=0.00 sys=0.00, real=0.00 secs] 结果分析

[
gc   //用来区分是 minor gc 还是 full gc 的标志(flag). 这里的 gc 表明本次发生的是 minor gc.
 (allocation failure) //引起垃圾回收的原因. 本次gc是因为年轻代中没有任何合适的区域能够存放需要分配的数据结构而触发的.    
[defnew: //使用的垃圾收集器的名字. defnew 这个名字代表的是: 单线程采用标记复制(mark-copy)算法的, 使整个jvm暂停运行的年轻代(young generation) 垃圾收集器.
1647k->192k(1856k), 0.0026381 secs] //在本次垃圾收集之前和之后的年轻代内存使用情况，从1647k回收到了192k（使用情况），括号中的1856k表示年轻代的总的大小.
1647k->604k(5952k), 0.0035661 secs] //在本次垃圾收集之前和之后整个堆内存的使用情况(total used heap).括号中的5952k代表总的堆大小（基本上和初始时候设置的堆大小相同）
[times: 
user=0.00 //此次垃圾回收, 垃圾收集线程消耗的所有cpu时间.
sys=0.00, //系统调用以及等待系统事件的时间(waiting for system event)
real=0.00 // 应用程序暂停的时间(clock time). 由于串行垃圾收集器(serial garbage collector)只会使用单个线程, 所以 real time 等于 user 以及 system time 的总和.
secs] 

　　②这是开始没有分配内存的时候打印的结果信息

没有分配时候
最大堆内存===20316160 //设置的-xx:maxheapsize=20971520
空闲内存===5177136 //初始的时候设置的-xx:initialheapsize=5242880
总内存===6094848 //堆内存加上其他的数据区域所占

　　③第一次分配1m内存时

分配了1m
最大堆内存===20316160 //这个值没有变化，和第一次没有分配的时候打印的结果一样
空闲内存===4128544 //分配1m后从5177136变化为现在的数值（5177136-4128544 =1048576 = 1024 * 1024）
总内存===6094848//总内存没有变化，和初始没有分配的时候是一样的

　　④第二次分配4m的时候，上面第一次分配之后还剩下4128544 = 3 * 1024 * 1024 = 3m，所以不够分配4m，这时候就需要扩展内存，（刚刚设置的-xx:maxheapsize=20971520 = 20 * 1024 * 1024 =  20m）

分配了4m
最大堆内存===20316160 //最大内存不变，和上面的两次输出相同
空闲内存===4401904 //总内存现在是9m，然后分配了5m，还剩下4m（4 * 1024 * 1024 = 4401904 ）
总内存===10358784 //由于最开始的5m不够分配，所以直接从最大内存处申请4m，这时候总内存就是9m = 9 * 1024 * 1024 = 10358784 

 　　⑤下面是第二次对整个堆进行gc

1 [gc 
2 (allocation failure) 
3 [defnew: 
4 1508k->30k(1856k), 0.0031475 secs] //新生代空间gc信息
5 [tenured: 1626k->1656k(4096k), 0.0031027 secs] 1920k->1656k(5952k),  //老年代空间回收信息
6 
7 [metaspace: 3411k->3411k(1056768k)], 0.0067187 secs] //元空间gc信息
8 [times: user=0.00 sys=0.00, real=0.01 secs] 

　　⑥开始的是时候我们设置了-xx:+printgcdetails ，所以最后会打印出整个gc的详细信息

heap //gc主要在堆上面进行
 def new generation   total 1920k, used 82k [0x00000000fec00000, 0x00000000fee10000, 0x00000000ff2a0000) //新生代
  eden space 1728k,   4% used [0x00000000fec00000, 0x00000000fec148c8, 0x00000000fedb0000) //eden区
  from space 192k,   0% used [0x00000000fedb0000, 0x00000000fedb0000, 0x00000000fede0000) //from区
  to   space 192k,   0% used [0x00000000fede0000, 0x00000000fede0000, 0x00000000fee10000) //to区
//eden区+from区+to区总共使用2112k，在newgeneration中：(0x00000000fee10000-0x00000000fec00000) / 1024 = 2112
 tenured generation   total 8196k, used 5752k [0x00000000ff2a0000, 0x00000000ffaa1000, 0x0000000100000000)  
    //5752/8196  = 70%
   the space 8196k,  70% used [0x00000000ff2a0000, 0x00000000ff83e2d8, 0x00000000ff83e400, 0x00000000ffaa1000) //老年代
 metaspace       used 3461k, capacity 4496k, committed 4864k, reserved 1056768k //元空间区空间信息 
  class space    used 379k, capacity 388k, committed 512k, reserved 1048576k

　2、新生代中参数设置

　　1）通过设置-xmn来设置新生代的大小，设置一个比较大的新生代可以减小老年代的空间大小，这样的设置对于整个gc的行为有比较大影响，新生代的大小一般会设置为整个堆空间的1/3或者1/4大小左右。-xx:survivorratio用来设置新生代中eden和from/to的比例。-xx:survivorratio=eden/from=eden/to

　　2）通过示例程序来查看关于新生代参数设置的方式和jvm结果分析。代码中会对于同一程序段进行三次不同的配置，然后通过jvm日志来分析不同的结果信息

 1 package cn.jvm.test;
 2 
 3 public class test02 {
 4     //第一次配置
 5     //-xms20m -xmx20m -xmn1m -xx:survivorratio=2 -xx:+printgcdetails -xx:+useserialgc
 6 
 7     //第二次配置
 8     //-xms20m -xmx20m -xmn7m -xx:survivorratio=2 -xx:+printgcdetails -xx:+useserialgc
 9 
10     //第三次配置
11     //-xx:newratio = 老年代/新生代
12     //-xms20m -xmx20m -xx:newratio=2 -xx:+printgcdetails -xx:+useserialgc
13     
14     public static void main(string[] args) {
15         byte[] b = null;
16 
17         for (int i = 0; i < 10; i++) {
18             b = new byte[1 * 1024 * 1024];
19         }
20     }
21 }

　　①第一次配置-xms20m -xmx20m -xmn1m -xx:survivorratio=2 -xx:+printgcdetails -xx:+useserialgc

（初始堆大小=最大堆大小=20m，新生代大小为1m，新生代中eden:from:to = 2:1:1，然后使用使用串行收集器，并且打印gc详细信息）

　　这个时候的新生代就是1m，其中eden:from:to = 2:1:1，下面是在idea中配置信息

　　运行的结果如下所示，可以计算出得到新生代的大小和分配的大小相同，新生代中的eden和from/to的比例为2:1:1

　　②第二次配置同样是在run/debug configuration中的vm options里面配置上-xms20m -xmx20m -xmn7m -xx:survivorratio=2 -xx:+printgcdetails -xx:+useserialgc，与第一次不同的只是改变了新生代的大小为7m，下面是运行结果

 

　　③设置第三次的分配参数-xms20m -xmx20m -xx:newratio=2 -xx:+printgcdetails -xx:+useserialgc。使用-xx:newratio可以设置老年代和新生代比例（-xx:newratio = 老年代/新生代）。所以第三次使用的是老年代和新生代按照比例进行划分，同样是在run/debug configuration中的vm options里面配置上-xms20m -xmx20m -xx:newratio=2 -xx:+printgcdetails -xx:+useserialgc然后我们来查看运行结果：

　　3）不同的堆分布情况会对于系统的执行产生大的影响，可以考虑尽量的将对象预留在新生代中，减少老年代的gc次数。

　3、栈参数设置

　　a）在hotspot中，使用-xss来设置栈容量的大小，如果请求的栈深度大于所提供允许的最大深度，将抛出stack overflow异常，如果扩展栈的时候不能申请到足够的内存，将会抛出outofmemoryerror异常。

　　b）下面使用一个简单的测试程序演示oom异常，程序中反复的调用自身，会一直申请栈空间，导致栈空间不够继续申请，最终抛出oom异常

 1 package cn.jvm.test;
 2 
 3 public class test04 {
 4 
 5     //-xss1m
 6     private static int stacklength = 1;
 7 
 8     public static void stackleak() {
 9         stacklength ++;
10         stackleak();
11     }
12 
13     public static void main(string[] args) {
14         try {
15             stackleak();
16         } catch (throwable e) {
17             system.out.println("最大栈深度" + stacklength);
18             e.printstacktrace();
19         }
20     }
21 }

　　c）在下面的输出结果之中：在单个线程下面，无论是由于栈帧太大还是由于虚拟机栈容量太小，当无法分配足够的内存的时候，都会抛出stack overflowerror异常

　　d）在多线程模式下面：在多线程环境开发中，如果对于每个线程的栈分配的空间越大，越容易引起内存溢出的异常。原因如下：

　　操作系统为每个线程分配的进程的内存是有限度的，虚拟机可以使用参数来控制堆内存和方法区内存的max值，剩余的内存减去这两部分的所占空间，再除去永久区（1.7）、程序计数器的空间，余下的部分就会被每个线程各自分配的到自己的栈空间（包括虚拟机栈和本地方法栈），这样看来，如果每个线程所设置的栈空间大小越大那么再次建立线程的时候就会越容易引起耗尽剩余的内存（从而引起oom异常）。

　　所以在多线程 环境之中，如果是建立多线程导致的内存溢出异常，在没有减少线程数或者提供更大的内存的情况下，就需要通过减小最大堆内存和减小每个线程的栈容量的方式来创建更多的线程。