1.JVM基础概念及优化
1.java虚拟机原理
所谓虚拟机，就是一台虚拟的机器。它是一款软件，用来执行一系列虚拟计算机指令，大体上虚拟机可以分为系统虚拟机和程序虚拟机，大名鼎鼎的Visual Box、VMare就属于系统虚拟机，他们完全是对物理计算机的仿真，提供了一个可运行完整操作系统的软件平台。程序虚拟机典型代表就是Java虚拟机，它专门为执行单个计算机程序而设计，在java虚拟机中执行的指令我们成为java字节码指令。无论是系统虚拟机还是程序虚拟机，在上面运行的软件都被限制于虚拟机提供的资源中。Java发展至今，出现过很多虚拟机，最初Sun使用的一款叫Classic的Java虚拟机，到现在引用最广泛的是HotSpot虚拟机，除了Sun意外，还有BEA的JRockit，目前JRockit和HotSpot都被Oracle收入旗下，大有整合的趋势。
2.java虚拟机基本结构
3.基本概念说明
1类加载子系统：负责从文件系统或者网络中加载Class信息，加载的信息存放在一块称之为方法区的内存空间。
2方法区：就是存放类信息、常量信息、常量池信息、包括字符串字面量和数字常量等。
3 java堆：在java虚拟机启动的时候建立java堆，它是java程序最主要的内存工作区域，几乎所有的对象实例都存放到到ava堆中，堆空间是所有线程共享的。
4直接内存：Java的NIO库允许java程序使用直接内存，从而提高性能，通常直接内存速度会优于java堆。读写频繁的场合可能会考虑使用。
5每个虚拟机线程都有一个私有的栈，一个线程的java栈在线程创建的时候被创建，java栈中保存着局部变量、方法参数、同时java的方法调用、返回值等。
6本地方法栈和java栈非常类似，最大不同为本地方法栈用于本地方法调用。java虚拟机允许java直接调用本地方法（通常使用C编写）。
7垃圾收集系统是java的核心，也是必不可少的，java有一套自己进行垃圾清理的机制，开发人员无需手工清理，我们稍后详细说明。
8PC（Program Counter）寄存器也是每个线程私有的空间，java虚拟机会为每个线程创建PC寄存器，在任意时刻，一个java线程总是在执行一个方法，这个方法被称为当前方法，如果当前方法不是本地方法，PC寄存器就会执行当前正在被执行的指令，如果是本地方法，则PC寄存器值为undefined，寄存器存放如当前执行环境指针、程序计数器、操作栈指针、计算的变量指针等信息。
9虚拟机最核心的组件就是执行引擎了，它负责执行虚拟机的字节码。一般户先进行编译成机器码后执行
3.堆,栈,方法区概念和联系
堆解决的是数据存储的问题，即数据怎么放、放在哪儿。
栈解决程序的运行问题，即程序如何执行，或者说如何处理数据。
方法区则是辅助堆栈的一块永久区（Perm），解决堆栈信息的产生，是先决条件。
我们创建一个新的对象，User：那么User类的一些信息（类信息、静态信息都存在于而User类被实例化出来之后，被存储到java堆中，一块内存空间当我们去使用的时候，都是使用User对象的引用，形如User user=new User（）；这里的user就是存放在java栈中的，即User真实对象的一个引用。
4.java堆
java堆是和java应用程序关系最密切的内存空间，几乎所有的对象都存放在其中，并且java堆完全是自动化管理的，通过垃圾回收机制，垃圾对象会自动清理，不需要显示地释放。
根据垃圾回收机制不同，Java堆有可能拥有不同的结构。最为常见的就是将整个java堆分为新生代和老年代。其中新生代存放新生的对象或者年龄不大的对象，老年代则存放老年对象。
新生代分为eden区、s0区、s1区，s0和s1也被称为from和to区域，他们是两块大小相等并且可以互换角色的空间。
绝大多数情况下，对象首先分配在eden区，在一次新生代回收后，如果对象还存活，则会进入s0或者s1区，之后每经过一次新生代回收，如果对象存活则它的年龄就加1，当对象达到一定的年龄(15)后，则进入老年代。
5.java栈
java栈是一块线程私有的内存空间，一个栈，一般由三部分组成：局部变量表、操作数栈和帧数据区。
局部变量表：用于报错函数的参数及局部变量。
操作数栈：主要保存计算过程的中间结果，同时作为计算过程中变量临时的存储空间。
帧数据区：除了局部变量表和操作数栈以外，栈还需要一些数据来支持常量池的解析，这里帧数据区保存着访问常量池的指针，方便程序访问常量池，另外，当函数返回或者出现异常时，虚拟机必须有一个异常处理表，方便发送异常的时候找到异常的代码，因此异常处理表也是帧数据区的一部分。
6.方法区
java方法区和堆一样，方法区是一块所有线程共享的内存区域，它保存系统的类信息，比如类的字段、方法、常量池等。方法区的大小决定了系统可以保存多少个类，如果系统定义太多的类，导致方法区溢出。虚拟机同样会抛出内存溢出错误。方法区可以理解为永久区（Perm）。
7.虚拟机参数
在虚拟机运行的过程中，如果可以跟踪系统的运行状态，那么对于问题的故障排查会有一定的帮助，为此，虚拟机提供了一些跟踪系统状态的参数，使用给定的参数执行java虚拟机，就可以在系统运行时打印相关日志，用于分析实际问题。我们进行虚拟机参数配置，其实主要就是围绕着堆、栈、方法区进行配置。
堆分配参数(1)
（1）-XX对于系统级别的（jvm）配置配置日志信息或者说配置jvm使用什么样的垃圾回收器 （2）非-XX的基本上都是对应用层面上的配置 +:表示启用 -:表示禁用
-XX：+PrintGC使用这个参数，虚拟机启动后，只要遇到GC就会打印日志。
-XX：+UseSerialGC 配置串行回收器
-XX：+PrintGCDetails 可以查看详细信息，包括各个区的情况
-Xms：设置java程序启动时初始堆大小
-Xmx：设置java程序能获得的最大堆大小
-XX：+PrintCommandLineFlags：可以将隐式((就是上面我们配置的参数))或者显示(例如我们使用java -jar ***.jar -xx:***传递的参数)传给虚拟机的参数输出
示例【Test01】
public class Test0 { public static void main(String[] args) { //java程序启动时初始堆大小:5M;ava程序能获得的最大堆大小:20M;打印详细垃圾回收信息;使用串行化垃圾回收器;打印虚拟机配置参数信息 //-Xms5m -Xmx20m -XX:+PrintGCDetails -XX:+UseSerialGC -XX:+PrintCommandLineFlags //查看GC信息 System.out.println("max memory:" + Runtime.getRuntime().maxMemory());//max memory:20316160 System.out.println("free memory:" + Runtime.getRuntime().freeMemory());//free memory:4918840 System.out.println("total memory:" + Runtime.getRuntime().totalMemory());//total memory:6094848 byte[] b1 = new byte[1 * 1024 * 1024]; System.out.println("分配了1M");//数组b1占用了1M内存 System.out.println("max memory:" + Runtime.getRuntime().maxMemory());//max memory:20316160 System.out.println("free memory:" + Runtime.getRuntime().freeMemory());//free memory:3870248 System.out.println("total memory:" + Runtime.getRuntime().totalMemory());//total memory:6094848 byte[] b2 = new byte[4 * 1024 * 1024]; System.out.println("分配了4M");//数组b2占用了4M内存 System.out.println("max memory:" + Runtime.getRuntime().maxMemory());//max memory:20316160 System.out.println("free memory:" + Runtime.getRuntime().freeMemory());//free memory:4321864 System.out.println("total memory:" + Runtime.getRuntime().totalMemory());//total memory:10358784(当我们这次申请4M内存时,虚拟机发现初始内存5M不够用了,于是又分配了5M,所以现在总共是10M) int a = 0x00000000fec00000; int b = 0x00000000fee10000; System.out.println("结果为：" + (b - a) / 1024);//结果为：2112 } }
-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.0025525 secs] 1664K->676K(5952K), 0.0026297 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] max memory:20316160 free memory:4975728 total memory:6094848 分配了1M max memory:20316160 free memory:3918192 total memory:6094848 [GC (Allocation Failure) [DefNew: 1641K->40K(1856K), 0.0027011 secs][Tenured: 1700K->1741K(4096K), 0.0033455 secs] 2125K->1741K(5952K), [Metaspace: 3414K->3414K(1056768K)], 0.0061413 secs] [Times: user=0.02 sys=0.00, real=0.01 secs] 分配了4M max memory:20316160 free memory:4321768 total memory:10358784 结果为：2112 Heap(详细信息) 新生代: def new generation total 1920K, used 76K [0x00000000fec00000, 0x00000000fee10000, 0x00000000ff2a0000) eden space 1728K, 4% used [0x00000000fec00000, 0x00000000fec13000, 0x00000000fedb0000) from space 192K, 0% used [0x00000000fedb0000, 0x00000000fedb0000, 0x00000000fede0000) to space 192K, 0% used [0x00000000fede0000, 0x00000000fede0000, 0x00000000fee10000) 老年区:tenured generation total 8196K, used 5837K [0x00000000ff2a0000, 0x00000000ffaa1000, 0x0000000100000000) the space 8196K, 71% used [0x00000000ff2a0000, 0x00000000ff8534a8, 0x00000000ff853600, 0x00000000ffaa1000) 永久区: Metaspace used 3453K, capacity 4500K, committed 4864K, reserved 1056768K class space used 376K, capacity 388K, committed 512K, reserved 1048576K
IDEA配置:
总结：
在实际工作中，我们可以直接将初始的堆大小与最大堆大小设置相等，这样的好处是可以减少程序运行时的垃圾回收次数，从而提高性能。
堆分配参数(2)
新生代的配置
-Xmn：可以设置新生代的大小，设置一个比较大的新生代会减少老年代的大小，这个参数对系统性能以及GC行为有很大的影响，新生代大小一般会设置整个堆空间的1/3到1/4左右。
-XX:SurvivorRatio：用来设置新生代中eden空间和from/to空间的比例。含义：-XX:SurvivorRatio=eden/from=eden/to
示例【Test02】
public static void main(String[] args) { //第一次品置 eden2=from1+to 1 //-Xms20m -Xmx20m -Xmn1m -XX:SurvivorRatio=2 -XX:+PrintGCDetails -XX:+UseSerialGC //第二次配型 //-Xms20m -Xmx20m -Xmn7m -XX:SurvivorRatio=2 -XX:+PrintGCDetails -XX:+UseSerialGC //第三次配型 //-XX:NewRatio=老年代/新生代 //-Xms20m -Xmx20m -XX:NewRatio=2 -XX:+PrintGCDetails -XX:+UseSerialGC byte[] b = null; //连续向系统单第10MB空间 for (int i = 0; i < 10; i++) { b = new byte[1 * 1024 * 1024]; } /** * 三次配置打印内容: * 第一次: * [GC (Allocation Failure) [DefNew: 512K->256K(768K), 0.0012522 secs] 512K->435K(20224K), 0.0013026 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] * [GC (Allocation Failure) [DefNew: 768K->159K(768K), 0.0017292 secs] 947K->593K(20224K), 0.0017756 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] * [GC (Allocation Failure) [DefNew: 664K->97K(768K), 0.0009469 secs] 1099K->665K(20224K), 0.0009853 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] * [GC (Allocation Failure) [DefNew: 600K->140K(768K), 0.0009336 secs] 1168K->708K(20224K), 0.0009875 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] * Heap * def new generation total 768K, used 233K [0x00000000fec00000, 0x00000000fed00000, 0x00000000fed00000) * eden space 512K, 18% used [0x00000000fec00000, 0x00000000fec17430, 0x00000000fec80000) * from space 256K, 54% used [0x00000000fec80000, 0x00000000feca30a0, 0x00000000fecc0000) * to space 256K, 0% used [0x00000000fecc0000, 0x00000000fecc0000, 0x00000000fed00000) * tenured generation total 19456K, used 10808K [0x00000000fed00000, 0x0000000100000000, 0x0000000100000000) * the space 19456K, 55% used [0x00000000fed00000, 0x00000000ff78e310, 0x00000000ff78e400, 0x0000000100000000) * Metaspace used 3451K, capacity 4496K, committed 4864K, reserved 1056768K * class space used 376K, capacity 388K, committed 512K, reserved 1048576K * * 第二次 *[GC (Allocation Failure) [DefNew: 3118K->1728K(5376K), 0.0035463 secs] 3118K->1728K(18688K), 0.0036137 secs] [Times: user=0.00 sys=0.03, real=0.00 secs] * [GC (Allocation Failure) [DefNew: 4905K->1024K(5376K), 0.0029167 secs] 4905K->1722K(18688K), 0.0029635 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] * [GC (Allocation Failure) [DefNew: 4181K->1024K(5376K), 0.0006386 secs] 4879K->1723K(18688K), 0.0006752 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] * Heap * def new generation total 5376K, used 4218K [0x00000000fec00000, 0x00000000ff300000, 0x00000000ff300000) * eden space 3584K, 89% used [0x00000000fec00000, 0x00000000fef1ea08, 0x00000000fef80000) * from space 1792K, 57% used [0x00000000ff140000, 0x00000000ff240128, 0x00000000ff300000) * to space 1792K, 0% used [0x00000000fef80000, 0x00000000fef80000, 0x00000000ff140000) * tenured generation total 13312K, used 698K [0x00000000ff300000, 0x0000000100000000, 0x0000000100000000) * the space 13312K, 5% used [0x00000000ff300000, 0x00000000ff3aeb30, 0x00000000ff3aec00, 0x0000000100000000) * Metaspace used 3313K, capacity 4496K, committed 4864K, reserved 1056768K * class space used 361K, capacity 388K, committed 512K, reserved 1048576K * 第三次 * [GC (Allocation Failure) [DefNew: 5342K->639K(6144K), 0.0036972 secs] 5342K->1740K(19840K), 0.0037632 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] * [GC (Allocation Failure) [DefNew: 5921K->0K(6144K), 0.0021103 secs] 7021K->2764K(19840K), 0.0021500 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] * Heap * def new generation total 6144K, used 2239K [0x00000000fec00000, 0x00000000ff2a0000, 0x00000000ff2a0000) * eden space 5504K, 40% used [0x00000000fec00000, 0x00000000fee2fc58, 0x00000000ff160000) * from space 640K, 0% used [0x00000000ff160000, 0x00000000ff160290, 0x00000000ff200000) * to space 640K, 0% used [0x00000000ff200000, 0x00000000ff200000, 0x00000000ff2a0000) * tenured generation total 13696K, used 2764K [0x00000000ff2a0000, 0x0000000100000000, 0x0000000100000000) * the space 13696K, 20% used [0x00000000ff2a0000, 0x00000000ff553048, 0x00000000ff553200, 0x0000000100000000) * Metaspace used 3437K, capacity 4496K, committed 4864K, reserved 1056768K * class space used 374K, capacity 388K, committed 512K, reserved 1048576K */ }
总结：不同的堆分布情况，对系统执行会产生一定的影响，在实际工作中，应该根据系统的特点做出合理的配置，基本策略：尽可能将对象预留在新生代，减少老年代的GC次数。
除了可以设置新生代的绝对大小（-Xmn），还可以使用（-XX:NewRatio）
设置新生代和老年代的比例：-XX:NewRatio=老年代/新生代
堆溢出处理
在java程序的运行过程中，如果堆空间不足，则会抛出内存溢出的错误（Out Of Menory）OOM，一旦这类问题发生在生产环境，可能引起严重的业务中断，java虚拟机提供了:
-XX：+HeapDumpOnOutOfMemoryError，使用该参数可以在内存溢出时导出整个堆信息，与之配合使用的还有参数，
-XX:HeapDumpPath，可以设置导出堆的存放路径。
内存分析工具(ecliplse)：Memory Analyzer 1.5.0地址：http://download.eclipse.org/mat/1.5/update-site/
示例【Test03】
public static void main(String[] args) { //-Xms2m -Xmx2m -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=d:/Testo3.dump //堆内存益出 Vector v = new Vector(); for (int i = 0; i < 5; i++) { v.add(new Byte[1 * 1024 * 1024]); } }
控制台打印: java.lang.OutOfMemoryError: Java heap space Dumping heap to d:/Testo3.dump ... Heap dump file created [1625061 bytes in 0.014 secs] Exception in thread "main" java.lang.OutOfMemoryError: Java heap space at java_practice.jvm.Test03.main(Test03.java:11)
然后我们就可以使用dump查看工具查看内存溢出原因了
栈配置
Java虚拟机提供了参数-Xss来指定线程的最大栈空间，整个参数也直接决定了函数可调用的最大深度。
示例【Test004】
//-Xss1m //-Xss5m //使调用深度 private static int count; public static void recursion() { count++; recursion(); } public static void main(String[] args) { try { recursion(); } catch (Throwable t) { System.out.println("调用最大深度;" + count);//-Xss1m:调用最大深度;23090;-Xss5m:调用最大深度;127760 t.printStackTrace(); } }
方法区配置:
和java堆一样，方法区是一块所有线程共享的内存区域，它用于保存系统的类信息，方法区（永久区）可以保存多少信息可以对其进行配置，在默认情况下，-XX:MaxPermSize为64MB，如果系统运行时生产大量的类，就需要设置一个相对合适的方法区，以免出现永久区内存溢出的问题。
XX:PermSize=64M -XX:MaxPermSize=64M
直接内存
直接内存也是java程序中非常重要的组成部分，特别是广泛用在NIO中，直接内存跳过了java堆，使java程序可以直接访问原生堆空间，因此在一定程度上加快了内存空间的访问速度。但是说直接内存一定就可以提高内存访问速度也不见得，具体情况具体分析。
相关配置参数：-XX:MaxDirectMemorySize，如果不设置默认值为最大堆空间，即-Xmx。直接内存使用达到上限时，就会触发垃圾回收，如果不能有效的释放空间，也会引起系统的OOM.
虚拟机两种启动模式
1.7以前java虚拟机支持Client和Server两种运行模式，使用参数-client可以指定使用Client模式，使用-server即使用Server模式。可以直接在命令行查看当前计算机系统自动选择的运行模式。java-version即可。1.8之后只有Server模式
二者区别：Client模式相对Server启动较快，如果不追求系统的长时间使用性能仅仅是测试，可以使用Client模式。而Server模式则启动比较慢，原因是会对其进行复杂的系统性能信息收集和使用更复杂的算法对程序进行优化，一般我们的生产环境都会使用Server模式，长期运行其性能要远远快于Client模式。
JVM不错的博客：
http://www.cnblogs.com/redcreen/archive/2011/05/04/2037057.html
垃圾回收概念和其算法
谈到垃圾回收（Garbage Collection，简称GC），需要先澄清什么是垃圾，类比日常生活中的垃圾，我们会把他们丢入垃圾桶，然后倒掉。GC中的垃圾，特指存于内存中、不会再被使用的对象，而回收就是相当于把垃圾“倒掉”。垃圾回收有很多种算法：如引用计数法、标记压缩法、复制算法、分代、分区的思想。
垃圾回收算法1
引用计数法：这是个比较古老而经典的垃圾收集算法，其核心就是在对象被其他所引用时计数器加1，而当引用失效时则减1，但是这种方式有非常严重的问题：无法处理循环引用的情况、还有就是每次进行加减操作比较浪费系统性能。
标记清除法：就是分为标记和清除俩个阶段进行处理内存中的对象，当然这种方式也有非常大的弊端，就是空间碎片问题，垃圾回收后的空间不是连续的，不连续的内存空间的工作效率要低于连续的内存空间。
复制算法：其核心思想就是将内存空间分为两块，，每次只使用其中一块，在垃圾回收时，将正在使用的内存中的存留对象复制到未被使用的内存块中去，之后去清除之前正在使用的内存块中所有的对象，反复去交换俩个内存的角色，完成垃圾收集。
（java中新生代的from和to空间就是使用这个算法）标记压缩法：标记压缩法在标记清除法基础之上做了优化，把存活的对象压缩到内存一端，而后进行垃圾清理。（java中老年代使用的就是标记压缩法）
考虑一个问题：为什么新生代和老年代使用不同的算法？
因为新生代数据更新频率很快,老年代数据更新频率较慢,对更新频率较慢的数据来回复制大量数据太耗费性能;
分代算法：就是根据对象的特点把内存分成N块，而后根据每个内存的特点使用不同的算法。
对于新生代和老年代来说，新生代回收频率很高，但是每次回收耗时都很短,而老年代回收频率较低，但是耗时会相对较长，所以应该尽量减少老年代的GC.
分区算法：其主要就是将整个内存分为N多个小的独立空间，每个小空间都可以独立使用，这样细粒度的控制一次回收都少个小空间和那些个小空间，而不是对整个空间进行GC，从而提升性能，并减少GC的停顿时间。
垃圾回收时的停顿现象
垃圾回收器的任务是识别和回收垃圾对象进行内存清理，为了让垃圾回收器可以高效的执行，大部分情况下，会要求系统进入一个停顿的状态。停顿的目的是终止所有应用线程，只有这样系统才不会有新的垃圾产生，同事停顿保证了系统状态在某一个瞬间的一致性，也有益于更好低标记垃圾对象。因此在垃圾回收时，都会产生应用程序的停顿。
对象如何进入老年代
一般而言对象首次创建会被放置在新生代的eden区，如果没有GC介入，则对象不会离开eden区，那么eden区的对象如何进入老年代呢？一般来讲，只要对象的年龄达到一定的大小，就会自动离开年轻代进入老年代，对象年龄是由对象经历数次GC决定的，在新生代每次GC之后如果对象没有被回收则年龄加1.虚拟机提供了一个参数来控制新生代对象的最大年龄，当超过这个年龄范围就会晋升老年代。
-XX:Max Tenuring Threshold，默认情况下为15。
示例【Test05】
public static void main(String[] args) { //初始的对象在edeng //参载：-Xmx64M -Xms64M -XX:+PrintGCDetails // for (int i = 0; i < 5; i++) { // byte[] b = new byte[1024 * 1024]; // } /** * 打印内容: * Heap * PSYoungGen total 18944K, used 8107K [0x00000000feb00000, 0x0000000100000000, 0x0000000100000000) * eden space 16384K, 49% used [0x00000000feb00000,0x00000000ff2eaeb0,0x00000000ffb00000) * from space 2560K, 0% used [0x00000000ffd80000,0x00000000ffd80000,0x0000000100000000) * to space 2560K, 0% used [0x00000000ffb00000,0x00000000ffb00000,0x00000000ffd80000) * ParOldGen total 44032K, used 0K [0x00000000fc000000, 0x00000000feb00000, 0x00000000feb00000) * object space 44032K, 0% used [0x00000000fc000000,0x00000000fc000000,0x00000000feb00000) * Metaspace used 3450K, capacity 4496K, committed 4864K, reserved 1056768K * class space used 376K, capacity 388K, committed 512K, reserved 1048576K */ //测试进入老年代的对象 //参数：-Xmx1024M -Xms1024M -XX:+UseSerialGC -XX:MaxTenuringThreshold=5 -XX:+PrintGCDetails //没五次GC就会将对象从新生代移到老年代 //-XX：+PrintReapatec Map<Integer, byte[]> m = new HashMap<>(); for (int i = 0; i < 5; i++) { byte[] b = new byte[1024 * 1024]; m.put(i, b); } for (int k = 0; k < 20; k++) { for (int j = 0; j < 300; j++) { byte[] b = new byte[1024 * 1024]; } } /** * [GC (Allocation Failure) [DefNew: 278925K->5862K(314560K), 0.0076612 secs] 278925K->5862K(1013632K), 0.0077312 secs] [Times: user=0.00 sys=0.02, real=0.01 secs] * [GC (Allocation Failure) [DefNew: 284698K->5856K(314560K), 0.0060841 secs] 284698K->5856K(1013632K), 0.0061297 secs] [Times: user=0.02 sys=0.00, real=0.01 secs] * [GC (Allocation Failure) [DefNew: 285212K->5856K(314560K), 0.0030135 secs] 285212K->5856K(1013632K), 0.0030671 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] * [GC (Allocation Failure) [DefNew: 284740K->5856K(314560K), 0.0029796 secs] 284740K->5856K(1013632K), 0.0030372 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] * [GC (Allocation Failure) [DefNew: 284780K->5856K(314560K), 0.0031983 secs] 284780K->5856K(1013632K), 0.0032491 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] * [GC (Allocation Failure) [DefNew: 284805K->0K(314560K), 0.0065911 secs] 284805K->5856K(1013632K), 0.0066393 secs] [Times: user=0.00 sys=0.00, real=0.01 secs] * [GC (Allocation Failure) [DefNew: 278965K->0K(314560K), 0.0003601 secs] 284822K->5856K(1013632K), 0.0004043 secs] [Times: user=0.00 sys=0.02, real=0.00 secs] * [GC (Allocation Failure) [DefNew: 278976K->0K(314560K), 0.0004520 secs] 284832K->5856K(1013632K), 0.0005007 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] * [GC (Allocation Failure) [DefNew: 278983K->0K(314560K), 0.0003931 secs] 284839K->5856K(1013632K), 0.0004404 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] * [GC (Allocation Failure) [DefNew: 278987K->0K(314560K), 0.0005841 secs] 284843K->5856K(1013632K), 0.0006283 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] * [GC (Allocation Failure) [DefNew: 279186K->239K(314560K), 0.0013825 secs] 285042K->6096K(1013632K), 0.0014284 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] * [GC (Allocation Failure) [DefNew: 278897K->332K(314560K), 0.0017948 secs] 284753K->6189K(1013632K), 0.0019166 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] * [GC (Allocation Failure) [DefNew: 279268K->332K(314560K), 0.0011553 secs] 285124K->6188K(1013632K), 0.0012040 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] * [GC (Allocation Failure) [DefNew: 279289K->332K(314560K), 0.0009304 secs] 285145K->6188K(1013632K), 0.0009746 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] * [GC (Allocation Failure) [DefNew: 279303K->332K(314560K), 0.0010433 secs] 285159K->6188K(1013632K), 0.0010853 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] * [GC (Allocation Failure) [DefNew: 279311K->148K(314560K), 0.0010032 secs] 285168K->6188K(1013632K), 0.0010465 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] * [GC (Allocation Failure) [DefNew: 279133K->0K(314560K), 0.0011281 secs] 285173K->6188K(1013632K), 0.0011736 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] * [GC (Allocation Failure) [DefNew: 278988K->0K(314560K), 0.0005270 secs] 285177K->6188K(1013632K), 0.0005725 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] * [GC (Allocation Failure) [DefNew: 278991K->0K(314560K), 0.0005020 secs] 285179K->6188K(1013632K), 0.0005507 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] * [GC (Allocation Failure) [DefNew: 278992K->0K(314560K), 0.0004637 secs] 285181K->6188K(1013632K), 0.0005172 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] * [GC (Allocation Failure) [DefNew: 278993K->0K(314560K), 0.0005060 secs] 285182K->6188K(1013632K), 0.0005556 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] * [GC (Allocation Failure) [DefNew: 278994K->0K(314560K), 0.0003548 secs] 285182K->6188K(1013632K), 0.0003963 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] * Heap * def new generation total 314560K, used 57255K [0x00000000c0000000, 0x00000000d5550000, 0x00000000d5550000) * eden space 279616K, 20% used [0x00000000c0000000, 0x00000000c37e9ed0, 0x00000000d1110000) * from space 34944K, 0% used [0x00000000d1110000, 0x00000000d1110000, 0x00000000d3330000) * to space 34944K, 0% used [0x00000000d3330000, 0x00000000d3330000, 0x00000000d5550000) * tenured generation total 699072K, used 6188K [0x00000000d5550000, 0x0000000100000000, 0x0000000100000000) * the space 699072K, 0% used [0x00000000d5550000, 0x00000000d5b5b328, 0x00000000d5b5b400, 0x0000000100000000) * Metaspace used 3948K, capacity 4568K, committed 4864K, reserved 1056768K * class space used 434K, capacity 460K, committed 512K, reserved 1048576K */ }
总结：根据设置MaxTenuringThreshold参数，可以指定新生代对象经过多少次回收后进入老年代。
另外，大对象（新生代eden区无法装入时，也会直接进入老年代）。JVM里有个参数可以设置对象的大小超过在指定的大小之后，直接晋升老年代。
-XX:PretenureSize Threshold示例
【Test06】和Test07合并
总结：使用PretenureSizeThreshold可以进行指定进入老年代的对象大小，但是要注意TLAB区域优先分配空间。
TLAB全称是Thread Local Allocation Buffer 即线程本地分配缓存，从名字上看是一个线程专用的内存分配区域，是为了加速对象分配而生的。每一个线程都会产生一个TLAB，该线程独享的工作区域，java虚拟机使用这种TLAB区来避免多线程冲突问题，提高了对象分配的效率。TLAB空间一般不会太大，当大对象无法在TLAB分配时，则会直接分配到堆上。
-XX：+UseTLAB 使用TLAB
-XX：+TLABSize 设置TLAB大小
-XX:TLABRefillWasteFraction 设置维护进入TLAB空间的单个对象大小，他是一个比例值，默认为64，即如果对象大于整个空间的1/64，则在堆创建对象。
-XX：+PrintTLAB 查看TLAB信息
-XX:ResizeTLAB 自调整TLABRefillWasteFraction阀值。
示例【Testo7】|
public class Test06 { public static void main(String[] args) { //参数：-Xmx30M-Xms30M -XX:+UseSerialGC-XX:+PrintGCDetails -XX:PretenureSizeThreshold=1000 (1k) //这种现象原因为：虚拟机对于体积不大的对象会优先把趣帮分配到TLAB区城中,因此就失去了在者年代分配的机会 //参数：-Xmx30M -Xms30M -XX:+UseSerialGC -XX:+PrintGCDetails -XX:PretenureSizeThreshold=1000 -XX:-UseTLAB Map<Integer, byte[]> m = new HashMap<Integer, byte[]>(); for (int i = 0; i < 5 * 1024; i++) { byte[] b = new byte[1024]; m.put(i, b); } /** * Heap * def new generation total 9216K, used 1294K [0x00000000fe200000, 0x00000000fec00000, 0x00000000fec00000) * eden space 8192K, 15% used [0x00000000fe200000, 0x00000000fe343a68, 0x00000000fea00000) * from space 1024K, 0% used [0x00000000fea00000, 0x00000000fea00000, 0x00000000feb00000) * to space 1024K, 0% used [0x00000000feb00000, 0x00000000feb00000, 0x00000000fec00000) * tenured generation total 20480K, used 6284K [0x00000000fec00000, 0x0000000100000000, 0x0000000100000000) * the space 20480K, 30% used [0x00000000fec00000, 0x00000000ff2231a8, 0x00000000ff223200, 0x0000000100000000) * Metaspace used 3455K, capacity 4496K, committed 4864K, reserved 1056768K * class space used 376K, capacity 388K, committed 512K, reserved 1048576K */ } }
对象创建流程图
一个对象创建在什么位置，我们的jvm会有有一个比较细节的流程，根据数据的大小，参数的设置，决定如何创建分配，以及其位置。
