GC(年轻代垃圾回收)速度相比慢,Java6是以时期来统筹内存的

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

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

前言

数据库是豪门会大规模敬爱的二个天地,异步通讯一般用不到,虚拟机在大多数时候不会出难点,常被人忽视,所以自个儿打算先读书虚拟机,从零单排Java高质量难题。

要害的东东

  • 在Java中,对象实例都以在堆上创造。一些类新闻,常量,静态变量等储存在方法区。堆和方法区都以线程共享的。
  • GC机制是由JVM提供,用来清理要求免去的目标,回收堆内存。
  • GC机制将Java程序员从内存管理中解放了出去,可以更关爱于事情逻辑。
  • 在Java中,GC是由三个被称为垃圾回收器的医护线程执行的。
  • 在从内存回收1个对象从前会调用对象的finalize()方法。
  • 用作一个Java开发者无法强制JVM执行GC;GC的触及由JVM根据堆内存的大大小小来控制。
  • System.gc()和Runtime.gc()会向JVM发送执行GC的央浼,可是JVM不保险一定会实行GC。
  • 借使堆没有内存创建新的指标了,会抛出OutOfMemoryError。

堆内存存储结构

Paste_Image.png

Java6是以时代来设计内存的,而Java7的G1收集器则相反,那里以Java6为准。
Sur中兴r1和SuriPhoner2是一样大的,必有三个一味为空,容积小于艾登。

怎么着的对象会被GC回收?

  • 在废品收集器举办回收前,第③件事就是规定那些目的怎样还存世,哪些已经死去。

点击 查看 小编的另一篇文章《深切通晓Java虚拟机》(三)垃圾收集器与内存分配政策

垃圾回收机制

少壮代采用复制算法,当回收时,将艾登和SurNokiar中还存世的对象一次性地复制到别的一块SurMotorolar上,然后清理掉艾登和刚刚用过的Sur索爱r空间。每进行一回Minor
GC(年轻代回收),对象的年华就扩展二岁(初阶为0),当年龄增加到早晚程度(暗中认可1肆岁),就会被移到老时代。老时代的回收算法因篇幅有限在此略过。

从《深远驾驭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:艾登和多个Sur索爱r的空中比例是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没有开展垃圾回收,byte① 、byte② 、byte三 、byte4总共10M内存,而年轻代唯有9M内存,不应有啊。结果Eden有6M内存(bytes1,bytes2,bytes3),老时代有4M内存(bytes4),表明bytes4一向被分配到了老年代,因为在SurHTCr空间中当相同年龄有所目标大小的总数大于Sur魅族r空间的二分之一,年龄当先或等于该年龄的靶子就足以向来进去老时代。

那么自身就调用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(壹玖肆伍6K)表示GC前堆占用内存10M,GC后占用内存14M,堆总体积20M。
  4. GC进度是把年轻代中的4M内存复制到了老时期,所以才会冒出10731K->14827K(19446K),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二〇一七年轻代已占有空间,年轻代又细分为1个Eden 空间和From SurOPPOr
    空间 和 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是实际上的消耗时间。

老时代占用内存空间 总结办法

  • 老时代的内存大小 = (等于) 堆内存总大小 – (减去)年轻代内存大小。
  • 此例中就是壹玖肆伍6K – 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 SurHTCr
    空间 和 To SurOne plusr空间。
  • b 为 Minor GC之后艾登空间GC后青春代已占用空间
    大概Sur摩托罗拉r中已被挤占的空中。
  • 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
J罗克it 和IBM
JVM’很一般。那将是二个好新闻:意味着不会再有java.lang.OutOfMemoryError: PermGen问题

默许意况下,类元数据只受可用的地点内存限制(体积取决于是叁十几位大概6几位操作系统的可用虚拟内存大小)

  • 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内存)
    不会触发年轻代 Eden Space 空间 Minor GC(年轻代垃圾收集)。

  • 老时期空间,使用量达到
    6.二分之一,内存剩余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.百分之三十三,内存剩余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回收后 艾登Space 空间 剩余 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内存),导致年轻代空间不够用了,会触发EdenSpace 空间(年轻代) 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

相关文章