Java6是以年代来设计内存的,Parallel Scavenge 是年轻代 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为准。
SurNokiar1和Sur三星(三星)r2是同等大的,必有一个从来为空,容量小于艾登(Eden)。

何以的对象会被GC回收?

  • 在废品收集器进行回收前,第一件事就是确定那么些目标怎样还存世,哪些已经死去。

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

废品回收机制

常青代接纳复制算法,当回收时,将艾登和Sur华为r中还存世的靶子四次性地复制到其它一块Sur一加r上,然后清理掉艾登和刚刚用过的Sur三星(Samsung)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:SurSamsungrRatio=8:艾登和一个Survivor的空间比例是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直接被分配到了老年代,因为在Sur三星r空间中当相同年龄有所目标大小的总和大于Sur三星(Samsung)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(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内存),会触发EdenSpace 空间(年轻代) Minor GC (年轻代垃圾收集)。

  • PS Old Generation 老年代空间,使用量达到
    0.00%,内存剩余10.MB,当下次举行 byte4(占用年轻代2M内存),上边艾登(Eden) 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之后艾登(Eden)空间GC后青春代已占据空间
    或者Sur华为r中已被并吞的空中。
  • 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 Sur黑莓r空间。
  • b 为 Minor GC之后艾登(Eden)空间GC前几年轻代已占用空间
    或者SurOPPOr中已被占用的半空中。
  • 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内存)
    不会触发年轻代 艾登(Eden) 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%

简易总计

  • 少壮代 艾登(Eden) 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内存),导致年轻代空间不够用了,会先触发年轻代
    艾登(Eden) Space 空间 Minor GC(年轻代垃圾收集),把部分内存转移到 PS
    Old Generation 老年代,GC回收后 艾登(Eden) 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 年轻代 Eden 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

相关文章

网站地图xml地图