GC(年轻代垃圾回收)速度相比较慢,老年代的回收算法因篇幅有限在此略过

Java程序员进阶三条必经之路:数据库、虚拟机、异步通讯。

堆内存使用分析,GC 日志解读

前言

数据库是大家会常见器重的一个天地,异步通讯一般用不到,虚拟机在多数时候不会出难题,常被人忽略,所以自己打算先读书虚拟机,从零单排Java高质量难题。

重大的东东

  • 在Java中,对象实例都是在堆上创制。一些类新闻,常量,静态变量等储存在方法区。堆和方法区都是线程共享的。
  • GC机制是由JVM提供,用来清理需要排除的靶子,回收堆内存。
  • GC机制将Java程序员从内存管理中解放了出来,能够更关爱于工作逻辑。
  • 在Java中,GC是由一个被称作垃圾回收器的医护线程执行的。
  • 在从内存回收一个目的此前会调用对象的finalize()方法。
  • 用作一个Java开发者无法强制JVM执行GC;GC的触发由JVM按照堆内存的轻重来支配。
  • System.gc()和Runtime.gc()会向JVM发送执行GC的呼吁,但是JVM不有限支撑一定会举行GC。
  • 只要堆没有内存创立新的靶子了,会抛出OutOfMemoryError。

堆内存存储结构

Paste_Image.png

Java6是以年代来设计内存的,而Java7的G1收集器则相反,这里以Java6为准。
Sur小米r1和Sur中兴r2是一模一样大的,必有一个一向为空,容量小于艾登。

什么样的靶子会被GC回收?

  • 在垃圾堆收集器举行回收前,第一件事就是确定这么些目的如何还存世,哪些已经死去。

点击 查看 我的另一篇小说《深刻了然Java虚拟机》(三)垃圾收集器与内存分配政策

污染源回收机制

年轻代选取复制算法,当回收时,将艾登和Sur华为r中还存世的靶子一遍性地复制到其它一块Sur中兴r上,然后清理掉艾登和刚刚用过的Sur金立r空间。每举行三次Minor
GC(年轻代回收),对象的年龄就扩展1岁(开始为0),当年龄扩大到一定水准(默许15岁),就会被移到老年代。老年代的回收算法因篇幅有限在此略过。

从《深刻了然Java虚拟机》第二版93页上抄一个事例来做个示范:

package com.jiuyan.mountain.jvm;

public class Test {

  private static final int MB = 1024 * 1024;

  public static void main(String[] args) {
    byte[] bytes1, bytes2, bytes3, bytes4;
    bytes1 = new byte[2 * MB];
    bytes2 = new byte[2 * MB];
    bytes3 = new byte[2 * MB];
    bytes4 = new byte[4 * MB];
  }
}

命令行执行:

java -verbose:gc -Xms20M -Xmx20M -Xmn10M -XX:+PrintGCDetails -XX:SurvivorRatio=8 com/jiuyan/mountain/jvm/Test

参数解释:

  1. Xms20M:初始堆20M
  2. Xmx20M:最大堆20M
  3. Xmn10M:年轻代10M
  4. -XX:+PrintGCDetails:打印GC详细新闻
  5. -XX:Sur小米rRatio=8:艾登和一个SurMotorolar的长空比例是8:1。

输出:

Heap
 PSYoungGen      total 9216K, used 6799K [0x00000000ff600000, 0x0000000100000000, 0x0000000100000000)
  eden space 8192K, 83% used [0x00000000ff600000,0x00000000ffca3f28,0x00000000ffe00000)
  from space 1024K, 0% used [0x00000000fff00000,0x00000000fff00000,0x0000000100000000)
  to   space 1024K, 0% used [0x00000000ffe00000,0x00000000ffe00000,0x00000000fff00000)
 ParOldGen       total 10240K, used 4096K [0x00000000fec00000, 0x00000000ff600000, 0x00000000ff600000)
  object space 10240K, 40% used [0x00000000fec00000,0x00000000ff000010,0x00000000ff600000)
 PSPermGen       total 21504K, used 2751K [0x00000000f4600000, 0x00000000f5b00000, 0x00000000fec00000)
  object space 21504K, 12% used [0x00000000f4600000,0x00000000f48afc08,0x00000000f5b00000)

JVM没有进展垃圾回收,byte1、byte2、byte3、byte4总共10M内存,而青春代唯有9M内存,不该啊。结果Eden有6M内存(bytes1,bytes2,bytes3),老年代有4M内存(bytes4),表明bytes4平素被分配到了老年代,因为在SurBlackBerryr空间中当相同年龄有所目标大小的总和大于SurSamsungr空间的一半,年龄超越或等于该年龄的靶子就可以直接进入老年代。

那么我就调用System.gc()来积极触发一回GC。
输出:

[GC-- [PSYoungGen: 6635K->6635K(9216K)] 10731K->14827K(19456K), 0.0035280 secs] [Times: user=0.00 sys=0.01, real=0.00 secs] 
[Full GC [PSYoungGen: 6635K->2275K(9216K)] [ParOldGen: 8192K->8192K(10240K)] 14827K->10467K(19456K) [PSPermGen: 2743K->2742K(21504K)], 0.0079080 secs] [Times: user=0.02 sys=0.00, real=0.01 secs] 
Heap
 PSYoungGen      total 9216K, used 2441K [0x00000000ff600000, 0x0000000100000000, 0x0000000100000000)
  eden space 8192K, 29% used [0x00000000ff600000,0x00000000ff8624d8,0x00000000ffe00000)
  from space 1024K, 0% used [0x00000000fff00000,0x00000000fff00000,0x0000000100000000)
  to   space 1024K, 0% used [0x00000000ffe00000,0x00000000ffe00000,0x00000000fff00000)
 ParOldGen       total 10240K, used 8192K [0x00000000fec00000, 0x00000000ff600000, 0x00000000ff600000)
  object space 10240K, 80% used [0x00000000fec00000,0x00000000ff400030,0x00000000ff600000)
 PSPermGen       total 21504K, used 2750K [0x00000000f4600000, 0x00000000f5b00000, 0x00000000fec00000)
  object space 21504K, 12% used [0x00000000f4600000,0x00000000f48af8d0,0x00000000f5b00000)

日记分析:

  1. GC和Full
    GC说明了这一次垃圾收集的间歇类型,而不是用来分别年轻代仍旧老年代的。假使有“Full”,表达这一次GC爆发了STW(Stop-The-World)。
  2. PSYoungGen是使用Parallel
    Scavenge收集器的后生代,ParOldGen是应用Parallel
    Old收集器的老年代,Tenured是选拔Serial Old收集器的老年代。
  3. [PSYoungGen:
    6635K->6635K(9216K)]代表GC前年轻代占用内存6M,GC后占用内存6M,内存区域总容量9M。10731K->14827K(19456K)表示GC前堆占用内存10M,GC后占用内存14M,堆总容量20M。
  4. GC进度是把青春代中的4M内存复制到了老年代,所以才会出现10731K->14827K(19456K),Full
    GC进程是把青春代中的4M内存回收掉,所以才会冒出PSYoungGen:
    6635K->2275K(9216K)。

测试环境

  • 系统

    Microsoft Windows [版本 10.0.14393]
    
  • JDK

    java version "1.8.0_112"
    Java(TM) SE Runtime Environment (build 1.8.0_112-b15)
    Java HotSpot(TM) 64-Bit Server VM (build 25.112-b15, mixed mode)
    
  • 测试工具

    IntelliJ IDEA 2017.2
    

以身作则代码

那边大家来通过一个小程序开展一下堆内存分析,代码如下:

package net.penglei.test;

public class HeapTest {
    private static final int _1M = 1024 * 1024;

    public static void main(String[] args) throws InterruptedException {
        byte[] byte1 = new byte[2 * _1M];
        byte[] byte2 = new byte[2 * _1M];
        byte[] byte3 = new byte[2 * _1M];
        byte[] byte4 = new byte[2 * _1M];
        byte[] byte5 = new byte[2 * _1M];

        byte[] byte6 = new byte[5 * _1M];

        byte[] byte7 = new byte[2 * _1M];


    }
}

安装JVM 参数配置

-Xms20m
-Xmx20m
-Xmn10m
-verbose:gc
-XX:+PrintGCDetails #输出详细GC日志模式
-XX:+PrintTenuringDistribution #输出每次minor GC后新的存活周期的阈值
-XX:+PrintGCTimeStamps #输出gc的触发时间

我的 IntelliJ IDEA 配置

图片 1

图片 2

翻看程序进程,堆详情

  • 查看 jps -l 看进程,通过 jmap -heap pid 查看堆的大约音信

    $ jps -l
    5636 net.penglei.test.HeapTest

堆配置

$ jmap -heap 5636

Attaching to process ID 5636, please wait...
Debugger attached successfully.
Server compiler detected.
JVM version is 25.112-b15

using thread-local object allocation.
Parallel GC with 8 thread(s)

Heap Configuration: 
   MinHeapFreeRatio         = 0                
   MaxHeapFreeRatio         = 100   #GC后如果发现空闲堆内存占到整个预估堆内存的N%(百分比)  
   MaxHeapSize              = 20971520 (20.0MB) # 堆最大空闲    jvm参数 -Xms20m
   NewSize                  = 10485760 (10.0MB) # 年轻代空间    jvm参数 -Xmn10m
   MaxNewSize               = 10485760 (10.0MB) # 年轻代最大空间
   OldSize                  = 10485760 (10.0MB) # 老年代空间 =(等于)堆内存大小 -(减去)年轻代大小
   NewRatio                 = 2   
   SurvivorRatio            = 8   # 年轻代内存又被分成三部分 Eden 空间 80% 而From Survivor 空间 和 To Survivor空间 分别占用10%
   MetaspaceSize            = 21807104 (20.796875MB) # 设置元空间的最大值 jvm参数 -XX:MaxMetaspaceSize
   CompressedClassSpaceSize = 1073741824 (1024.0MB)  # 类指针压缩空间大小, 默认为1G
   MaxMetaspaceSize         = 17592186044415 MB    # 是分配给类元数据空间的最大值
   G1HeapRegionSize         = 0 (0.0MB) # G1区块的大小, 取值为1M至32M. 其取值是要根据最小Heap大小划分出2048个区块

...

执行完 byte3

byte[] byte3 = new byte[2 * _1M];

$ jmap -heap 5636
...
Heap Usage:
PS Young Generation
Eden Space:
   capacity = 8388608 (8.0MB)
   used     = 7635080 (7.281379699707031MB)
   free     = 753528 (0.7186203002929688MB)
   91.01724624633789% used
From Space:
   capacity = 1048576 (1.0MB)
   used     = 0 (0.0MB)
   free     = 1048576 (1.0MB)
   0.0% used
To Space:
   capacity = 1048576 (1.0MB)
   used     = 0 (0.0MB)
   free     = 1048576 (1.0MB)
   0.0% used
PS Old Generation
   capacity = 10485760 (10.0MB)
   used     = 0 (0.0MB)
   free     = 10485760 (10.0MB)
   0.0% used

1628 interned Strings occupying 148560 bytes.
数据区块 堆总容量 使用容量 剩余容量 使用占比
年轻代 8.0MB 7.28MB 0.71MB 91.0%
幸存者0 1.0MB 0.00MB 1.0MB 0.0%
幸存者1 1.0MB 0.00MB 1.0MB 0.0%
老年代 10.0MB 0.00MB 10.MB 0.0%

简言之总计

  • PS Young Generation 年轻代空间,使用量达到
    91.0%,内存剩余0.71MB,当下次举办byte4(占用年轻代2M内存),会触发艾登Space 空间(年轻代) Minor GC (年轻代垃圾收集)。

  • PS Old Generation 老年代空间,使用量达到
    0.00%,内存剩余10.MB,当下次举行 byte4(占用年轻代2M内存),上边艾登 Space 空间(年轻代) Minor GC
    (年轻代垃圾收集),会老年代占用部分内存。

执行完 byte4

byte[] byte4 = new byte[2 * _1M]

控制台打印的GC日志

641.638: [GC (Allocation Failure) 
Desired survivor size 1048576 bytes, new threshold 7 (max 15)
[PSYoungGen: 7456K->728K(9216K)] 7456K->6880K(19456K), 0.0036244 secs] 
[Times: user=0.00 sys=0.00, real=0.00 secs] 


641.642: [Full GC (Ergonomics) 
[PSYoungGen: 728K->0K(9216K)] [ParOldGen: 6152K->6700K(10240K)] 6880K->6700K(19456K), 
[Metaspace: 2848K->2848K(1056768K)], 0.0068164 secs] 
[Times: user=0.00 sys=0.00, real=0.01 secs] 

GC日志分块图解 ps(画的不佳)

图片 3

$ jmap -heap 5636
...
Heap Usage:
PS Young Generation
Eden Space:
   capacity = 8388608 (8.0MB)
   used     = 2097168 (2.0000152587890625MB)
   free     = 6291440 (5.9999847412109375MB)
   25.00019073486328% used
From Space:
   capacity = 1048576 (1.0MB)
   used     = 0 (0.0MB)
   free     = 1048576 (1.0MB)
   0.0% used
To Space:
   capacity = 1048576 (1.0MB)
   used     = 0 (0.0MB)
   free     = 1048576 (1.0MB)
   0.0% used
PS Old Generation
   capacity = 10485760 (10.0MB)
   used     = 6861768 (6.543891906738281MB)
   free     = 3623992 (3.4561080932617188MB)
   65.43891906738281% used

1556 interned Strings occupying 143760 bytes.

GC日志详细分析

641.638: [GC (Allocation Failure) 
Desired survivor size 1048576 bytes, new threshold 7 (max 15)
[PSYoungGen: 7456K->728K(9216K)] 7456K->6880K(19456K), 0.0036244 secs] 
[Times: user=0.00 sys=0.00, real=0.00 secs] 

Parallel Scavenge 是青春代 GC 收集器

641.638: [GC (Allocation Failure)
  • 1641.638:是本次GC发生的小时,从jvm启动起开头计时,单位为秒。那是两次Minor GC(年轻代垃圾收集),Minor
    GC 卓殊频仍,回收速度快。

    Desired survivor size 1048576 bytes, new threshold 7 (max 15)

  • 可望的幸存者大小1048576字节,新的幸存周期的阈值为7(max 15)。

    [PSYoungGen: 7456K->728K(9216K)]

格式为:[PSYoungGen: a->b(c)]

青春代选取的是三八线程垃圾收集器 Parallel Scavenge(新生代收集器,一般选择复制算法,并行的十六线程收集器)

  • PSYoungGen,表示 GC发生在年轻代。
  • a 为GC二〇一七年轻代已占用空间,年轻代又细分为一个艾登 空间和From Sur酷派r
    空间 和 To Sur三星r空间。
  • b 为 Minor GC之后艾登空间GC后青春代已占据空间
    或者SurOPPOr中已被挤占的上空。
  • c 括号里的c表示所有年轻代的尺寸。

    7456K->6880K(19456K)

格式为:x->y(z)

  • x 代表GC前堆的已占有空间,
  • y 表示GC后堆已占用空间,
  • z 代表堆的总大小。

    , 0.0036244 secs]

  • 表示此次GC所成本的时刻。

    [Times: user=0.00 sys=0.00, real=0.00 secs]

  • 提供cpu使用及时间消耗,user是用户态消耗的cpu时间,sys是系统态消耗的cpu时间,real是实际上的损耗时间。

老年代占用内存空间 总括方式

  • 老年代的内存大小 = (等于) 堆内存总大小 – (减去)年轻代内存大小。
  • 此例中就是19456K – 9216K = 10240K

Parallel Old 是Parallel Scavenge 收集器的老年代版本

641.642: [Full GC (Ergonomics) 
[PSYoungGen: 728K->0K(9216K)] [ParOldGen: 6152K->6700K(10240K)] 6880K->6700K(19456K), 
[Metaspace: 2848K->2848K(1056768K)], 0.0068164 secs] 
[Times: user=0.00 sys=0.00, real=0.01 secs] 

641.642: [Full GC (Ergonomics)

老年代GC 又叫做Major GC,平日会陪伴几遍Minor
GC(年轻代垃圾回收)速度比较慢

  • 641.642:是本次GC发生的时刻,从jvm启动起早先计时,单位为秒。[Full GC
    (Ergonomics) ,表示执行全局垃圾回收

    [PSYoungGen: 728K->0K(9216K)]

格式为:[PSYoungGen: a->b(c)]

少壮代接纳的是八线程垃圾收集器 Parallel Scavenge(新生代收集器,一般拔取复制算法,并行的多线程收集器)

  • PSYoungGen,表示 GC暴发在年轻代。
  • a 为GC二零一七年轻代已占据空间,年轻代又细分为一个艾登 空间和From Sur索尼爱立信r
    空间 和 To SurOPPOr空间。
  • b 为 Minor GC之后艾登空间GC后青春代已占有空间
    或者SurBlackBerryr中已被占据的空中。
  • c 括号里的c表示一切年轻代的轻重缓急。

    [ParOldGen: 6152K->6700K(10240K)]

格式为:[ParOldGen: x->y(z)]

老年代GC,使用 Parallel Old收集器,是Parallel
Scavenge收集器的老年代版本,一搬采取三多线程和“标记-整理”算法

  • ParOldGen 表示 GC 发生在老年代。
  • x 为GC前老年代已占用空间
  • y 为GC后老年代已占据空间
  • 括号里的 z 为总体老年代的轻重缓急

    6880K->6700K(19456K)

格式为:e->f(g)]

  • e 为GC前堆堆内存占用,
  • f 为GC后堆堆内存占用,
  • 括号里的 g 为JVM整个堆的总大小。

    [Metaspace: 2848K->2848K(1056768K)]

java8 特性是 把永久代 (Permanent Generation (PermGen))
移植到元空间(Metaspace)

格式为:t->y(u)]

JDK8 HotSpot JVM
使用当地内存来储存类元数据新闻并称之为:元空间(Metaspace);那与Oracle
JRockit 和IBM
JVM’很一般。那将是一个好音讯:意味着不会再有java.lang.OutOfMemoryError: PermGen问题

默许景况下,类元数据只受可用的地点内存限制(容量取决于是32位可能64位操作系统的可用虚拟内存大小)

  • t 为元空间的污染源回收前内存占用
  • y 为元空间的废料回收后内存占用
  • 括号里的 u 为JVM元空间内存总大小

    , 0.0068164 secs]

  • 意味着此次GC所消耗的日子。

    [Times: user=0.00 sys=0.00, real=0.01 secs]

提供cpu使用及时间消耗

  • user :用是用户态消耗的cpu时间
  • sys :是系统态消耗的cpu时间
  • real :本次GC是实际上的损耗时间
数据区块 堆总容量 使用容量 剩余容量 使用占比
年轻代 8.0MB 2.00MB 5.99MB 25.0%
幸存者0 1.0MB 0.00MB 1.00MB 0.0%
幸存者1 1.0MB 0.00MB 1.00MB 0.0%
老年代 10.0MB 6.54MB 3.45MB 65.4%

简单的讲总计

  • 常青代 艾登 Space 空间,使用量达到
    25.0%,内存剩余5.99MB,当下次推行byte5(占用年轻代2M内存)
    不会触发年轻代 艾登 Space 空间 Minor GC(年轻代垃圾收集)。

  • 老年代空间,使用量达到
    6.54%,内存剩余3.45MB,当下次推行byte5(占用年轻代2M内存),不会触发老年代空间
    Major GC(老年代垃圾收集),因为年轻代空间还够用。

执行完 byte5

byte[] byte5 = new byte[2 * _1M];

$ jmap -heap 5636
...
Heap Usage:
PS Young Generation
Eden Space:
   capacity = 8388608 (8.0MB)
   used     = 4356568 (4.154747009277344MB)
   free     = 4032040 (3.8452529907226562MB)
   51.9343376159668% used
From Space:
   capacity = 1048576 (1.0MB)
   used     = 0 (0.0MB)
   free     = 1048576 (1.0MB)
   0.0% used
To Space:
   capacity = 1048576 (1.0MB)
   used     = 0 (0.0MB)
   free     = 1048576 (1.0MB)
   0.0% used
PS Old Generation
   capacity = 10485760 (10.0MB)
   used     = 6861768 (6.543891906738281MB)
   free     = 3623992 (3.4561080932617188MB)
   65.43891906738281% used

1556 interned Strings occupying 143760 bytes.
数据区块 堆总容量 使用容量 剩余容量 使用占比
年轻代 8.0MB 4.15MB 3.84MB 51.9%
幸存者0 1.0MB 0.00MB 1.00MB 0.0%
幸存者1 1.0MB 0.00MB 1.00MB 0.0%
老年代 10.0MB 6.54MB 3.45MB 65.4%

粗略总括

  • 常青代 艾登 Space 空间,使用量达到
    51.9%,内存剩余3.84MB,当下次执行byte6(占用年轻代5M内存),导致年轻代空间不够用了,
    会触发年轻代 艾登 Space 空间 Minor
    GC(年轻代垃圾收集),把一些内存转移到 PS Old Generation
    老年代。

  • 老年代 PS Old Generation 空间,使用量达到
    6.54%,内存剩余3.45MB,当下次实践byte6(占用年轻代5M内存),由于年轻代的一片段内存,转移到了老年代,导致老年代空间不够用了,会触发老年代
    PS Old Generation 空间 Major GC(老年代垃圾收集)。

执行完 byte6

byte[] byte6 = new byte[5 * _1M];

控制台打印的GC日志

10342.704: [

Full GC (Ergonomics) 

   [PSYoungGen: 4254K->2048K(9216K)] 
   [ParOldGen: 6700K->8745K(10240K)]
   10955K->10793K(19456K), 
   [Metaspace: 2848K->2848K(1056768K)],

 0.0154383 secs
 ] 

[Times: user=0.00 sys=0.03, real=0.02 secs] 

本条GC 日志详细解读请参考,上面解读,执行完 byte4 的日记
ps(那个解读更详细)

  • 以此是日记其实说的就是
    :年轻代G回收前后,老年代GC回收前后,整个堆的GC回收前后,原数据空间回收前后,的内存使用状态。多少个内存区块GC回收所消耗的岁月,提供cpu使用及时间消耗时间

概括解读GC日志

  • PS Young Generation 年轻代 艾登 Space 空间,使用量达到
    4254K,当执行byte6(占用年轻代5M内存),导致年轻代空间不够用了,会先触发年轻代
    艾登 Space 空间 Minor GC(年轻代垃圾收集),把有些内存转移到 PS
    Old Generation 老年代,GC回收后 艾登 Space 空间 剩余 2048K。

  • PS Old Generation 老年代空间,使用量达到
    6700K,当执行byte6(占用年轻代5M内存),由于年轻代的一局地内存,转移到了老年代,导致老年代空间不够用了,会先触发老年代
    PS Old Generation 空间 Major GC(老年代垃圾收集)。GC回收后 EdenSpace 空间 剩余 8745K。

    $ jmap -heap 5636

    Heap Usage:
    PS Young Generation
    Eden Space:
    capacity = 8388608 (8.0MB)
    used = 7507856 (7.1600494384765625MB)
    free = 880752 (0.8399505615234375MB)
    89.50061798095703% used
    From Space:
    capacity = 1048576 (1.0MB)
    used = 0 (0.0MB)
    free = 1048576 (1.0MB)
    0.0% used
    To Space:
    capacity = 1048576 (1.0MB)
    used = 0 (0.0MB)
    free = 1048576 (1.0MB)
    0.0% used
    PS Old Generation
    capacity = 10485760 (10.0MB)
    used = 8955872 (8.540985107421875MB)
    free = 1529888 (1.459014892578125MB)
    85.40985107421875% used

    1556 interned Strings occupying 143760 bytes.

数据区块 堆总容量 使用容量 剩余容量 使用占比
年轻代 8.0MB 7.16MB 0.83MB 89.5%
幸存者0 1.0MB 0.00MB 1.00MB 0.0%
幸存者1 1.0MB 0.00MB 1.00MB 0.0%
老年代 10.0MB 8.54MB 1.45MB 85.4%

执行完 byte7

byte[] byte7 = new byte[2 * _1M];

不难计算

  • 参考 byte6 执行后,PS Young Generation 年轻代 艾登 Space
    空间,使用量达到
    89.5%,内存剩余0.83MB,执行byte7(占用年轻代2M内存),导致年轻代空间不够用了,会触发艾登Space 空间(年轻代) Minor GC (年轻代垃圾收集)
  • 参考 byte6 执行后,PS Old Generation 老年代空间,使用量达到
    85.4%,内存剩余1.45MB,执行byte7(占用年轻代2M内存),会导致年轻代的GC回收放到老年代,而老年代也承担不了,会 OutOfMemoryError

控制台打印的GC日志

10427.298: [Full GC (Ergonomics) [PSYoungGen: 7331K->7168K(9216K)] [ParOldGen: 8745K->8745K(10240K)] 16077K->15913K(19456K), [Metaspace: 2849K->2849K(1056768K)], 0.0065366 secs] [Times: user=0.09 sys=0.02, real=0.01 secs] 

10427.305: [Full GC (Allocation Failure) [PSYoungGen: 7168K->7168K(9216K)] [ParOldGen: 8745K->8745K(10240K)] 15913K->15913K(19456K), [Metaspace: 2849K->2849K(1056768K)], 0.0027873 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
Heap
 at net.penglei.test.HeapTest.main(HeapTest.java:16)
 PSYoungGen      total 9216K, used 7462K [0x00000000ff600000, 0x0000000100000000, 0x0000000100000000)
  eden space 8192K, 91% used [0x00000000ff600000,0x00000000ffd49b60,0x00000000ffe00000)
  from space 1024K, 0% used [0x00000000ffe00000,0x00000000ffe00000,0x00000000fff00000)
  to   space 1024K, 0% used [0x00000000fff00000,0x00000000fff00000,0x0000000100000000)
 ParOldGen       total 10240K, used 8745K [0x00000000fec00000, 0x00000000ff600000, 0x00000000ff600000)
  object space 10240K, 85

相关文章