JVM-基本概念

最新推荐文章于 2021-07-11 19:40:09 发布
最新推荐文章于 2021-07-11 19:40:09 发布
阅读量505 收藏
点赞数
分类专栏： JVM 文章标签： JVM 垃圾收集算法 垃圾收集器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shuduti/article/details/84634219
版权

基本概念

  1. 类加载子系统：负责从文件系统或者网络中加载Class信息，加载的信息存放在一块称之为方法区的内存空间。
  2. 方法区：就是存放类信息、常量信息、常量池信息、包括字符串字面量和数字常量等。
  3. java堆：在java虚拟机启动的时候建立java堆，它就是java程序最主要的内存工作区域，几乎所有的对象实例都存放在java堆中，堆空间是所有线程共享的。
  4. 直接内存：java的NIO库允许java程序直接使用内存，从而提高性能，通常直接内存速度会优于java堆。读写频繁的场合可能考虑使用。
  5. java栈：每个虚拟机线程都有一个私有栈，一个线程的java栈在线程创建的时候被创建，java栈中保存着局部变量、方法参数、java的方法调用、返回值等。
  6. 本地方法栈：本地方法栈和java栈非常类似，最大不同为本地方法栈用于本地方法调用，java虚拟机允许java直接调用本地方法（通常使用c编写）。
  7. 垃圾收集系统：垃圾收集系统是java的核心，也是比不可少的，java有一套自己进行垃圾收集的机制，开发人员无需手工清理。
  8. PC寄存器：PC寄存器也是每个线程私有的空间，java虚拟机会为每个线程创建PC寄存器，在任意时刻，一个java线程总是在执行一个方法，这个方法被称为当前方法，如果当前方法不是本地方法，PC寄存器就会执行当前正在被执行的指令，如果是本地方法，则PC寄存器值为undefined，PC寄存器中存放如当前环境指针、程序计数器、操作栈指针、计算变量指针等信息。
  9. 执行引擎：虚拟机最核心的组件就是执行引擎，它负责执行虚拟机的字节码，一般是先进行编译成机器码之后执行。

堆、栈、方法区概念和联系

堆解决的是数据存储的问题，即数据怎么放、放在哪儿。栈解决程序运行问题，即程序如何运行，或者说如何处理数据。方法区则是辅助堆栈的快永久区（Perm）,解决堆栈信息的产生，是先决条件。我们创建一个新的对象，User：那么User类的一些信息（类信息、静态信息都取决于方法区中），User类被实例化出来之后，被存储到java堆中，一块内存空间。当我们去使用的时候，都是使用的是User对象的引用，形如User user = new User();这里的user就是存放在java栈中的，即User真实对象的一个引用。

java堆

java堆是和java应用程序关系最密切的内存空间，几乎所有的对象都存放在其中，并且java堆完全是自动化管理的，通过垃圾回收机制，垃圾对象会自动清理，不需要显示地释放。根据垃圾收集机制不同，java堆有可能拥有不同的结构。最为常见的就是将整个java堆分为新生代和老年代。其中新生代存放新生的对象或者年龄不大的对象，老年代则存放老年对象。新生代分为eden区、S0区、S1区，S0和S1也被称为From和To区域，他们是两块大小相等并且可以互换角色的空间。绝大多数情况下，对象首先分配在eden区，在一次新生代回收后，如果对象还存活，则会计入s0或者s1区，之后每经过一次新生代回收，如果对象存活则年龄就加1，当对象达到一定的年龄后，则进入老年代。

java栈

java栈是一块线程私有的内存空间，一个栈，一般由三部分组成：局部变量表、操作数栈和帧数据区。

  • 局部变量表：用于报错函数的参数及局部变量。
  • 操作数栈：主要保存计算过程的中间结果，同时作为计算过程中变量临时的存储空间。
  • 帧数据区：处理局部变量表和操作数栈以外，栈还需要一些数据来支持常量池的解析，这里帧数据区保存着访问常量池的指针，方便程序访问常量池，另外，当函数返回或者出现异常时，虚拟机必须有一个异常处理表，方便发送异常的时候找到异常的代码，因此异常处理表也是帧数据的一部分。

java方法区

java方法区和堆一样，方法区是一块所有线程共享的内存区域，它保存系统的类信息，比如类的字段、方法、常量池等。方法区的大小决定了系统可以保存多少个类，如果系统定义太多的类，容易导致方法区溢出。虚拟机同样会抛出内存溢出错误，方法区可以理解为永久代区（Perm）

虚拟机参数

在虚拟机运行过程中，如果可以跟踪系统的运行状态，那么对于问题的故障排查会有一定的帮助，为此，虚拟机提供了一些跟踪系统状态的参数，使用给定的参数执行java虚拟机，就可以在系统运行时打印相关的日志，用于分析实际问题。我们进行虚拟机参数的配置，其实主要就是围绕着堆、栈、方法区进行配置。

堆分配参数（一）

  • -XX:+PrintGC：使用这个参数，虚拟机启动之后，只要遇到GC就会打印日志。
  • -XX:+UseSerialGC：配置串行回收器。
  • -XX:+PrintGCDetails：可以查看详细信息，包括各个区的情况。
  • -Xms：设置java程序启动时初始化堆大小。
  • -Xmx：设置java程序能获得的最大堆大小。
  • -Xmx20m -xms5m -XX:+PrintCommandLineFlags：可以隐式或者显示传给虚拟机的参数输出。
public class Test01 {

	public static void main(String[] args) {
		//1.-XX:+PrintGC -Xms5m -Xmx20m -XX:+UseSerialGC -XX:+PrintGCDetails -XX:+PrintCommandLineFlags
		//查看GC信息
		System.out.println("max memory: " + Runtime.getRuntime().maxMemory());
		System.out.println("free memory: " + Runtime.getRuntime().freeMemory());
		System.out.println("total memory: " + Runtime.getRuntime().totalMemory());
		
		byte[] b1 = new byte[1*1024*1024]; //1M
		
		System.out.println("分配了1M");
		System.out.println("max memory: " + Runtime.getRuntime().maxMemory());
		System.out.println("free memory: " + Runtime.getRuntime().freeMemory());
		System.out.println("total memory: " + Runtime.getRuntime().totalMemory());
		
		byte[] b2 = new byte[4*1024*1024]; //4M
		
		System.out.println("分配了4M");
		System.out.println("max memory: " + Runtime.getRuntime().maxMemory());
		System.out.println("free memory: " + Runtime.getRuntime().freeMemory());
		System.out.println("total memory: " + Runtime.getRuntime().totalMemory());
	}

}
/*
打印结果：
-XX:InitialHeapSize=5242880 -XX:MaxHeapSize=20971520 -XX:+PrintCommandLineFlags -XX:+PrintGC -XX:+PrintGCDetails -XX:+UseCompressedClassPointers -XX:+UseCompressedOops -XX:-UseLargePagesIndividualAllocation -XX:+UseSerialGC 
max memory: 20316160
free memory: 5285968
total memory: 6094848
[GC (Allocation Failure) [DefNew: 789K->191K(1856K), 0.0014625 secs] 789K->527K(5952K), 0.0015014 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
分配了1M
max memory: 20316160
free memory: 4471800
total memory: 6094848
[GC (Allocation Failure) [DefNew: 1249K->0K(1856K), 0.0012294 secs][Tenured: 1551K->1551K(4096K), 0.0039679 secs] 1585K->1551K(5952K), [Metaspace: 2599K->2599K(1056768K)], 0.0052516 secs] [Times: user=0.02 sys=0.00, real=0.01 secs] 
分配了4M
max memory: 20316160
free memory: 4540624
total memory: 10358784
Heap
 def new generation   total 1920K, used 68K [0x00000000fec00000, 0x00000000fee10000, 0x00000000ff2a0000)
  eden space 1728K,   3% used [0x00000000fec00000, 0x00000000fec113e8, 0x00000000fedb0000)
  from space 192K,   0% used [0x00000000fedb0000, 0x00000000fedb0000, 0x00000000fede0000)
  to   space 192K,   0% used [0x00000000fede0000, 0x00000000fede0000, 0x00000000fee10000)
 tenured generation   total 8196K, used 5647K [0x00000000ff2a0000, 0x00000000ffaa1000, 0x0000000100000000)
   the space 8196K,  68% used [0x00000000ff2a0000, 0x00000000ff823ef8, 0x00000000ff824000, 0x00000000ffaa1000)
 Metaspace       used 2605K, capacity 4486K, committed 4864K, reserved 1056768K
  class space    used 288K, capacity 386K, committed 512K, reserved 1048576K
 */

总结：在实际工作中，我们可以直接将初始的堆大小与最大堆设置相等，这样的好处是可以减少程序运行时的垃圾回收次数，从而提高性能。

堆分配参数（二）

新生代的配置：

  • Xmn：可以设置新生代的大小，设置一个比较大的新生代会减少老年代的大小，这个参数对系统性能以及GC行为有很大的影响，新生代大小一般会设置为整个堆空间的1/3到1/4左右。
  • XX:SurvivoRatio：用来设置新生代中eden空间和from/to空间的比例。含义：-XXSurvivoRatio=eden/from=eden/to
public class Test02 {

	public static void main(String[] args) {
		//1.-Xms20m -Xmx20m -Xmn1m -XX:SurvivorRatio=2 -XX:+PrintGCDetails -XX:+UseSerialGC(eden 2 = from 1 + to 1)
		
		byte[] b = null;
		//连续申请内存
		for(int i = 0; i < 10; i++){
			b = new byte[1*1024*1024];
		}
	}

}
/*
 [GC (Allocation Failure) [DefNew: 509K->256K(768K), 0.0011554 secs] 509K->436K(20224K), 0.0011969 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
Heap
 def new generation   total 768K, used 497K [0x00000000fec00000, 0x00000000fed00000, 0x00000000fed00000)
  eden space 512K,  47% used [0x00000000fec00000, 0x00000000fec3c7b0, 0x00000000fec80000)
  from space 256K, 100% used [0x00000000fecc0000, 0x00000000fed00000, 0x00000000fed00000)
  to   space 256K,   0% used [0x00000000fec80000, 0x00000000fec80000, 0x00000000fecc0000)
 tenured generation   total 19456K, used 10420K [0x00000000fed00000, 0x0000000100000000, 0x0000000100000000)
   the space 19456K,  53% used [0x00000000fed00000, 0x00000000ff72d138, 0x00000000ff72d200, 0x0000000100000000)
 Metaspace       used 2603K, capacity 4486K, committed 4864K, reserved 1056768K
  class space    used 288K, capacity 386K, committed 512K, reserved 1048576K
 * */

总结：不同的堆分布情况，对系统执行会产生一定的影响，在实际工作中，应该根据系统的特点做合理的配置，基本策略：尽可能将对象预留在新生代，减少老年代的GC次数。除了可以设置新生代的绝对大小（-Xmn），还可以使用（-XX:NewRatio）设置新生代和老年代的比例：-XX:NewRatio=老年代/新生代。

堆溢出处理

在java程序运行的过程中，如果堆空间不足，则会抛出内存溢出的错误（Out of Memory）OOM，一旦这类问题发生在生产环境，可能引起严重的业务中断，java虚拟机提供了-XX:+HeapDumpOnOutOfMemoryError，使用该参数可以在内存溢出时导出整个堆信息，与之配合使用的参数是-XX:HeapDumpPath，可以设置导出堆溢出时快照信息。内存分析工具：Eclipse Memory Analyzer

public class Test03 {

	public static void main(String[] args) {
		//-Xms2m -Xmx2m -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=d:/Test03.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:/Test03.dump ...
Heap dump file created [1218914 bytes in 0.009 secs]
Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
	at com.jt.jvm.Test03.main(Test03.java:11)
 * */

栈配置

java虚拟机提供了参数-Xss来指定线程的最大栈空间，整个参数业务直接决定了函数可调用的最大深度。

public class Test04 {

	//-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);
			t.printStackTrace();
		}
	}
}
/*
打印结果：

调用最大深度： 22327
java.lang.StackOverflowError
	at com.jt.jvm.Test04.recursion(Test04.java:13)
	at com.jt.jvm.Test04.recursion(Test04.java:13)
	at com.jt.jvm.Test04.recursion(Test04.java:13)
	at com.jt.jvm.Test04.recursion(Test04.java:13)
	at com.jt.jvm.Test04.recursion(Test04.java:13)
	at com.jt.jvm.Test04.recursion(Test04.java:13)
	at com.jt.jvm.Test04.recursion(Test04.java:13)
	at com.jt.jvm.Test04.recursion(Test04.java:13)
	at com.jt.jvm.Test04.recursion(Test04.java:13)
	at com.jt.jvm.Test04.recursion(Test04.java:13)
	at com.jt.jvm.Test04.recursion(Test04.java:13)
	at com.jt.jvm.Test04.recursion(Test04.java:13)
	at com.jt.jvm.Test04.recursion(Test04.java:13)
	at com.jt.jvm.Test04.recursion(Test04.java:13)
	at com.jt.jvm.Test04.recursion(Test04.java:13)
	at com.jt.jvm.Test04.recursion(Test04.java:13)
	at com.jt.jvm.Test04.recursion(Test04.java:13)
	at com.jt.jvm.Test04.recursion(Test04.java:13)
	at com.jt.jvm.Test04.recursion(Test04.java:13)
	at com.jt.jvm.Test04.recursion(Test04.java:13)
	at com.jt.jvm.Test04.recursion(Test04.java:13)
	at com.jt.jvm.Test04.recursion(Test04.java:13)
	at com.jt.jvm.Test04.recursion(Test04.java:13)
	at com.jt.jvm.Test04.recursion(Test04.java:13)
	at com.jt.jvm.Test04.recursion(Test04.java:13)
	at com.jt.jvm.Test04.recursion(Test04.java:13)
	at com.jt.jvm.Test04.recursion(Test04.java:13)
	at com.jt.jvm.Test04.recursion(Test04.java:13)
	at com.jt.jvm.Test04.recursion(Test04.java:13)
	at com.jt.jvm.Test04.recursion(Test04.java:13)
	at com.jt.jvm.Test04.recursion(Test04.java:13)
	at com.jt.jvm.Test04.recursion(Test04.java:13)
	at com.jt.jvm.Test04.recursion(Test04.java:13)
	at com.jt.jvm.Test04.recursion(Test04.java:13)
	at com.jt.jvm.Test04.recursion(Test04.java:13)
	at com.jt.jvm.Test04.recursion(Test04.java:13)
	at com.jt.jvm.Test04.recursion(Test04.java:13)
	at com.jt.jvm.Test04.recursion(Test04.java:13)
	at com.jt.jvm.Test04.recursion(Test04.java:13)
	at com.jt.jvm.Test04.recursion(Test04.java:13)
	at com.jt.jvm.Test04.recursion(Test04.java:13)
	at com.jt.jvm.Test04.recursion(Test04.java:13)
	at com.jt.jvm.Test04.recursion(Test04.java:13)
	at com.jt.jvm.Test04.recursion(Test04.java:13)
	at com.jt.jvm.Test04.recursion(Test04.java:13)
	at com.jt.jvm.Test04.recursion(Test04.java:13)
	at com.jt.jvm.Test04.recursion(Test04.java:13)
	at com.jt.jvm.Test04.recursion(Test04.java:13)
	at com.jt.jvm.Test04.recursion(Test04.java:13)
	at com.jt.jvm.Test04.recursion(Test04.java:13)
	at com.jt.jvm.Test04.recursion(Test04.java:13)
	at com.jt.jvm.Test04.recursion(Test04.java:13)
 * */

方法区

和java堆一样，方法去是一块所有线程共享的内存区域，它用于保存系统的类信息，方法区（永久带）可以保存多少信息可以对其进行配置，在默认情况下，-XX:MaxPerSize为64MB，如果系统运行时产生大量的类，就需要设置一个相对合适的方法区，以避免出现永久区内存溢出问题。-XX:PermSize=64M -XX:MaxPermSize=64M。

直接内存配置

直接内存也是java程序中非常重要的组成部分，特别是广泛的NIO中，直接内存跳过java堆，使java程序可以直接访问原生堆空间，因此在一定程度上加快了内存空间的访问速度。但是说直接内存一定就可以提高内存访问速度也不见得，具体情况具体分析。相关配置参数：

  • -XX:MaxDirectMemorySize：如果不设置默认值为最大堆空间，即-Xmx。直接内存使用达到上限是，就会触发垃圾收集，如果不能有效的释放空间，也会引起系统的OOM。

垃圾回收概念和算法、及对象的分代转换

垃圾回收概念和其算法

垃圾回收（Garbage Collection，简称GC），GC中的垃圾，特指存于内存中、不会再被使用的对象，而回收就是相当于把垃圾“倒掉”。垃圾回收有很多种算法：如引用计数法、标记压缩法、复制算法、分代、分区思想。

垃圾收集算法

  • 引用计数法：比较古老而经典的垃圾收集算法，其核心就是在对象被其他所引用时计数器加1，而当引用时效时则减1，但是这种方式有非常严重的问题：无法处理循环引用的情况、还有就是每次进行加减操作比较浪费系统性能。
  • 标记清除法：就是分为标记和清除两个阶段进行处理内存中的对象，当然这种方式也有非常大的弊端，就是空间碎片问题，垃圾回收后的空间不是连续的，不连续的内存空间的工作效率要低于连续的内存空间。
  • 复制算法：其核心思想就是将内存空间分为两块，每次只使用其中一块，在垃圾回收时，将正在使用的内存中的存留对象复制到未被使用的内存块中，之后去清除之前正在使用的内存块中所有的对象，反复去交换两个内存的角色，完成垃圾收集（JVM中新生代的from和to空间就是使用这个算法）。
  • 标记压缩法：标记压缩法在标记清除法基础之上做了优化，把存活的对象压缩到内存一端，而后进行垃圾清理（JVM中老年代使用的就是标记压缩法）。
  • 分代算法：就是根据对象的特点把内存分成N块，而后根据每个内存的特点用不同的算法。对于新生代和老年代来说，新生代回收频率很高，但是每次回收耗时很短，而老年代回收频率低，但是耗时相对较长，所以应该尽量减少老年代的GC。
  • 分区算法：其主要就是将内存分为N个小的独立空间，每个小空间都可以独立使用，这样细粒度的控制一次回收多少个和回收哪些小空间，而不是对整个空间进行GC，从而提升性能，并减少GC的停顿时间。

垃圾回收时的停顿现象

垃圾回收器的任务是识别和回收垃圾对象进行内存清理，为了让垃圾回收器可高效的执行，大部分情况下，会要求系统进入一个停顿的状态。停顿的目的是终止所有应用线程，只有这样系统才不会有新的垃圾产生，同时停顿保证了系统状态在某一个瞬间的一致性，也有益于更好地标记垃圾对象。因此在垃圾回收时，都会产生应用程序的停顿。

对象如何进入老年代

一般而言对象首次创建都会被放置在新生代的eden区，如果没有GC介入，则对象不会离开eden区，那么eden区的对象如何进入老年代？一般而言，只要对象的年龄达到一定的大小，就会自动离开新生代进入老年代，对象年龄是由对象经历的GC次数决定的，在新生代每次GC之后，如果对象没有被回收则年龄加1，虚拟机提供了一个参数来控制新生代对象的最大年龄，当超过这个年龄范围就会晋升到老年代（-XX:MaxTenuringThreshold，默认情况下为15）。

public class Test05 {

	public static void main(String[] args) {
		//测试进入老年代
		//参数：-Xmx1024M -Xms1024M -XX:+UseSerialGC -XX:MaxTenuringThreshold=15 -XX:+PrintGCDetails
		//-XX:+PrintHeapAtGC
		for(int i= 0; i < 20; i++){
			for(int j = 0; j < 300; j++){
				byte[] b = new byte[1024*1024];
			}
		}
	}

}
/*
打印结果:

[GC (Allocation Failure) [DefNew: 279004K->526K(314560K), 0.0015339 secs] 279004K->526K(1013632K), 0.0015796 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[GC (Allocation Failure) [DefNew: 279475K->525K(314560K), 0.0012435 secs] 279475K->525K(1013632K), 0.0012833 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[GC (Allocation Failure) [DefNew: 279481K->525K(314560K), 0.0009651 secs] 279481K->525K(1013632K), 0.0010096 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[GC (Allocation Failure) [DefNew: 279495K->525K(314560K), 0.0008946 secs] 279495K->525K(1013632K), 0.0009284 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[GC (Allocation Failure) [DefNew: 279504K->525K(314560K), 0.0009202 secs] 279504K->525K(1013632K), 0.0009519 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[GC (Allocation Failure) [DefNew: 279510K->525K(314560K), 0.0008993 secs] 279510K->525K(1013632K), 0.0009322 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[GC (Allocation Failure) [DefNew: 279514K->525K(314560K), 0.0008899 secs] 279514K->525K(1013632K), 0.0009224 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[GC (Allocation Failure) [DefNew: 279516K->525K(314560K), 0.0008523 secs] 279516K->525K(1013632K), 0.0008822 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[GC (Allocation Failure) [DefNew: 279518K->525K(314560K), 0.0008304 secs] 279518K->525K(1013632K), 0.0008574 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[GC (Allocation Failure) [DefNew: 279519K->525K(314560K), 0.0009348 secs] 279519K->525K(1013632K), 0.0009664 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[GC (Allocation Failure) [DefNew: 279519K->525K(314560K), 0.0008783 secs] 279519K->525K(1013632K), 0.0009078 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[GC (Allocation Failure) [DefNew: 279520K->525K(314560K), 0.0009014 secs] 279520K->525K(1013632K), 0.0009318 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[GC (Allocation Failure) [DefNew: 279520K->525K(314560K), 0.0008655 secs] 279520K->525K(1013632K), 0.0008963 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[GC (Allocation Failure) [DefNew: 279520K->525K(314560K), 0.0009985 secs] 279520K->525K(1013632K), 0.0010280 secs] [Times: user=0.01 sys=0.00, real=0.00 secs] 
[GC (Allocation Failure) [DefNew: 279520K->525K(314560K), 0.0009160 secs] 279520K->525K(1013632K), 0.0009519 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[GC (Allocation Failure) [DefNew: 279520K->0K(314560K), 0.0010939 secs] 279520K->525K(1013632K), 0.0011251 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[GC (Allocation Failure) [DefNew: 278995K->0K(314560K), 0.0056553 secs] 279520K->525K(1013632K), 0.0056895 secs] [Times: user=0.00 sys=0.00, real=0.01 secs] 
[GC (Allocation Failure) [DefNew: 278995K->0K(314560K), 0.0002506 secs] 279520K->525K(1013632K), 0.0002831 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[GC (Allocation Failure) [DefNew: 278995K->0K(314560K), 0.0002425 secs] 279520K->525K(1013632K), 0.0002750 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[GC (Allocation Failure) [DefNew: 278995K->0K(314560K), 0.0002339 secs] 279520K->525K(1013632K), 0.0002651 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[GC (Allocation Failure) [DefNew: 278995K->0K(314560K), 0.0002292 secs] 279520K->525K(1013632K), 0.0002600 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[GC (Allocation Failure) [DefNew: 278995K->0K(314560K), 0.0002638 secs] 279520K->525K(1013632K), 0.0002942 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
Heap
 def new generation   total 314560K, used 23463K [0x00000000c0000000, 0x00000000d5550000, 0x00000000d5550000)
  eden space 279616K,   8% used [0x00000000c0000000, 0x00000000c16e9f98, 0x00000000d1110000)
  from space 34944K,   0% used [0x00000000d1110000, 0x00000000d1110000, 0x00000000d3330000)
  to   space 34944K,   0% used [0x00000000d3330000, 0x00000000d3330000, 0x00000000d5550000)
 tenured generation   total 699072K, used 525K [0x00000000d5550000, 0x0000000100000000, 0x0000000100000000)
   the space 699072K,   0% used [0x00000000d5550000, 0x00000000d55d3720, 0x00000000d55d3800, 0x0000000100000000)
 Metaspace       used 2596K, capacity 4486K, committed 4864K, reserved 1056768K
  class space    used 288K, capacity 386K, committed 512K, reserved 1048576K
 * */

总结：根据设置MaxTenuringThreshold参数，可以指定新生代对象经过多少次回收后进入老年代。另外，大对象（新生代eden区无法装入时，也会直接进入老年代）。JVM里有个参数可以设置对象的大小超过指定的大小之后，直接晋升老年代（-XX:PretenureSizeThreshold）。

public class Test06 {

	public static void main(String[] args) {
		//-XX:PretenureSizeThreshold = 1024*1000 < 1024*1024
		//参数：-Xmx30M -Xms30M -XX:+UseSerialGC -XX:+PrintGCDetails -XX:PretenureSizeThreshold=1024000
		/*Map<Integer,byte[]> map = new HashMap<>();
		for(int i=0; i < 5; i++){
			byte[] b = new byte[1024*1024];//1M
			map.put(i, b);
		}*/
				
	}

}
/*
打印结果：

Heap
 def new generation   total 9216K, used 983K [0x00000000fe200000, 0x00000000fec00000, 0x00000000fec00000)
  eden space 8192K,  12% used [0x00000000fe200000, 0x00000000fe2f5fb8, 0x00000000fea00000)
  from space 1024K,   0% used [0x00000000fea00000, 0x00000000fea00000, 0x00000000feb00000)
  to   space 1024K,   0% used [0x00000000feb00000, 0x00000000feb00000, 0x00000000fec00000)
 tenured generation   total 20480K, used 5120K [0x00000000fec00000, 0x0000000100000000, 0x0000000100000000)
   the space 20480K,  25% used [0x00000000fec00000, 0x00000000ff100050, 0x00000000ff100200, 0x0000000100000000)
 Metaspace       used 2597K, capacity 4486K, committed 4864K, reserved 1056768K
  class space    used 288K, capacity 386K, committed 512K, reserved 1048576K
  */

public class Test06 {

	public static void main(String[] args) {
		//这种现象原因：虚拟机对于体积不大的对象会优先把数据分配到TLAB区域中，因此就失去了老年代的分配机会
		//参数：-Xmx30M -Xms30M -XX:+UseSerialGC -XX:+PrintGCDetails -XX:PretenureSizeThreshold=1000 -XX:-UseTLAB(增加此参数后优先达到指定大小优先老年代分配)
		Map<Integer,byte[]> map = new HashMap<>();
		for(int i=0; i < 5*1024; i++){
			byte[] b = new byte[1024];//1k
			map.put(i, b);
		}
	}

}
/*
 打印结果2（未增加-XX:-UseTLAB）：
 
 Heap
 def new generation   total 9216K, used 6587K [0x00000000fe200000, 0x00000000fec00000, 0x00000000fec00000)
  eden space 8192K,  80% used [0x00000000fe200000, 0x00000000fe86ef90, 0x00000000fea00000)
  from space 1024K,   0% used [0x00000000fea00000, 0x00000000fea00000, 0x00000000feb00000)
  to   space 1024K,   0% used [0x00000000feb00000, 0x00000000feb00000, 0x00000000fec00000)
 tenured generation   total 20480K, used 0K [0x00000000fec00000, 0x0000000100000000, 0x0000000100000000)
   the space 20480K,   0% used [0x00000000fec00000, 0x00000000fec00000, 0x00000000fec00200, 0x0000000100000000)
 Metaspace       used 2610K, capacity 4486K, committed 4864K, reserved 1056768K
  class space    used 288K, capacity 386K, committed 512K, reserved 1048576K
  
 打印结果3（增加-XX:-UseTLAB）:

Heap
 def new generation   total 9216K, used 801K [0x00000000fe200000, 0x00000000fec00000, 0x00000000fec00000)
  eden space 8192K,   9% used [0x00000000fe200000, 0x00000000fe2c86a0, 0x00000000fea00000)
  from space 1024K,   0% used [0x00000000fea00000, 0x00000000fea00000, 0x00000000feb00000)
  to   space 1024K,   0% used [0x00000000feb00000, 0x00000000feb00000, 0x00000000fec00000)
 tenured generation   total 20480K, used 5421K [0x00000000fec00000, 0x0000000100000000, 0x0000000100000000)
   the space 20480K,  26% used [0x00000000fec00000, 0x00000000ff14b668, 0x00000000ff14b800, 0x0000000100000000)
 Metaspace       used 2609K, capacity 4486K, committed 4864K, reserved 1056768K
  class space    used 288K, capacity 386K, committed 512K, reserved 1048576K
 * */

总结：使用PretenureSizeThreshold可以进行指定进入老年代的对象的大小，但是要注意TLAB区域优先分配空间。

TLAB

TLAB全称是Thread Local Allocation Buffer即线程本地分配缓存，从名字上看是一个线程专用的内存分配区域，是为了加速对象分配而产生的。每一个线程都会产生一个TLAB，该线程独享的工作区域，java虚拟机使用这种TLAB区来避免多线程冲突问题，提高了对象分配的效率。TLAB空间一般不会太大，当大对象无法在TLAB分配时，则会直接分配到堆上。

  • -XX:+UseTLAB：使用TLAB。
  • -XX:+TLABSize：设置TLAB大小。
  • -XX:TLABRefillWasterFraction：设置维护进入TLAB空间的单个对象大小，他是一个比值，默认为64，即如果对象大于整个空间的1/64，则会在堆上创建对象。
  • -XX:+PrintTLAB：查看TLAB信息。
  • -xx:ResizeTLAB：自调整TLABRefillWasterFraction阀值。

对象创建流图

一个对象创建在什么位置，我们的JVM会有一个比较细节的流程，根据数据的大小，参数的设置，决定如何创建分配，以及其位置。

垃圾收集器

在java中，垃圾收集器不仅仅只有一种，什么情况下该使用哪种，对性能又有什么影响，这都是我们需要了解的。

  • 串行垃圾回收器
  • 并行垃圾回收器
  • CMS回收器
  • G1回收器

串行回收器

串行回收器是指使用单线程进行垃圾回收的回收器。每次回收时，串行回收器只有一个工作线程，对于并行能力较弱的计算机来说，串行回收器的专注性和独占性往往有更好的性能表现。串行回收器可以在新生代和老年代使用，根据作用于不同的堆空间，分为新生代串行回收器和老年代串行回收器。使用-XX:+UseSerialGC参数可以设置使用新生代串行回收器和老年代串行回收器。

并行回收器（ParNew回收器）

并行垃圾回收器在串行回收器基础上做了改进，它可以使用多个线程同时进行垃圾回收，对于计算能力强的计算机而言，可以有效的缩短垃圾回收所需的实际时间。ParNew回收器是一个工作在新生代的垃圾收集器，它只是简单的将串行回收器多线程话，它的回收策略和算法和串行回收器一样。使用-XX:+UseParNewGC，新生代ParNew回收器，老年代则使用串行回收器ParNew回收器工作是的线程数量可以使用-XX:ParallelGCThreads参数指定，一般最好和计算机的CPU相当避免过多的线程影响性能。

并行回收器（ParallelGC回收器）

新生代ParallelGC回收器，使用了复制算法的手机器，也是多线程独占形式的收集器，但ParallelGC回收器有个非常重要的特点，就是它非常关注系统的吞吐量。提供了两个非常关键的参数来控制系统的吞吐量。

  • -XX:MaxGCPauseMills：设置最大垃圾收集停顿时间，可用把虚拟机在GC停顿的时间控制在MaxGCPauseMills范围内，如果希望减少GC停顿时间可以将MaxGCPauseMills设置得很小，但是会导致频繁GC，从而增加GC的总时间，降低了吞吐量。所以根据实际情况设置该值。
  • -XX:GCTimeRatio：设置吞吐量大小，它是一个0到100之间的整数，默认情况下他的取值是99，那么系统将花费不超过1/(1+n)的时间用于垃圾回收，也就是1/(1+99)=1%的时间。
    另外还可以指定-XX:UseAdaptiveSizePollicy打开自适应模式，在这种模式下，新生代的大小、eden、from/to的比例，以及晋升老年代的对象年龄参数会被自动调整，以达到在堆大小、吞吐量和停顿时间之间的平衡点。

并行回收器（ParallelOldGC回收器）

老年代ParallelOldGC回收器也是一种多线程的回收器，和新生代的ParallelGC回收器一样，也是一种关注吞吐量的回收器，它使用了标记压缩算法进行实现。

  • -XX:+UseParallelOldGC进行设置。
  • -XX:+ParallelGCThreads也可以设置垃圾收集时的线程数量。

CMS回收器

CMS全称为：Concurrent Mark Sweep意为并发标记清除，它使用的是标记清除法，主要关注系统停顿时间。使用-XX:+UseConcMarkSweepGC进行设置。使用-XX:ConcGCThreads设置并发线程数量。CMS并不是独占的回收器也就是说CMS回收过程中，应用程序仍然在不停的工作，又会有新的垃圾不断产生，所有在使用CMS的过程中应该确保应用程序的内存足够可同。CMS不会等到应用程序饱和的时候才去回收垃圾，二十在某一个阀值的时候开始回收，默认为69，也就是说当老年代的空间使用率达到68%的时候，会执行CMS回收。如果内存使用率增长很快，在CMS执行的过程中，已经出现了内存不足的情况，此时CMS回收就会失败，虚拟机将启动老年代串行回收器进行垃圾回收，这会导致应用程序中断，直到垃圾回收完成之后才会正常工作，这个过程GC的停顿时间可能较长，所以-XX:CMSInitiatingOccupancyFraction的设置要根据实际的情况。之前我们在学习算法的时候说过，标记清除法有个缺点就是存在内存碎片的问题，那么CMS有个参数设置-XX:+UseCMSCompactAtFullCollection可以使CMS回收完成之后进行一次碎片整理，-XX:CMSFullGCsBeforeCompaction参数可以设置进行多少次CMS回收之后，对内存进行一次压缩。

G1回收器

G1回收器（Garbage-First）是在jdk1.7中提出的垃圾回收器，从长期目标来看是为了取代CMS回收器，G1回收器拥有独特的垃圾回收策略，G1属于分代垃圾回收器，区分新生代和老年代，依然有eden区和from/to区，它并不要求整个eden区或者整个新生代、老年代的空间都连续，它使用了分区算法。

  • 并行性：G1回收期间可多线程同时工作。
  • 并发性：G1拥有与程序交替执行的能力，部分工作可与应用程序同时执行，在整个GC期间不会完全阻塞应用程序。
  • 分代GC：G1依然是一个分代收集器，但是他是兼顾新生代和老年代一起工作，之前的垃圾收集器或者是在新生代工作，或者是在老年代工作，因此这是一个很大的不同。
  • 空间整理：G1在回收过程中，不会像CMS那样在若干次GC后需要进行碎片整理，G1采用了有效的复制对象的方式，减小空间碎片。
  • 可预见性：由于分区的原因，G1可以只选取部分分区进行回收，缩小回收的范围，提升性能。
  • 使用-XX:+UseG1GC应用G1收集器
  • 使用-XX:MaxGCPauseMillis指定最大停顿时间。
  • 使用-XX:ParallelGCThreads设置并回收的线程数量。
做最专注的自己
关注
专栏目录
JVM基础概念整理
STAR
07-20 336
JVM JVM简介 虚拟机：通过软件模拟的具有完整硬件功能的、运行在一个完全隔离环境中的完整的计算机系统。 JVM:通过软件模拟Java字节码的指令集，JVM中只保留了PC寄存器 内存区域与内存溢出异常 １.运行时数据区域 线程私有区域 程序计数器、Ｊａｖａ虚拟机栈、本地方法栈 线程私有：生命周期与具体线程相同，随着线程的创建而创建，随着线程销毁，对应空间回收 线程共享区域 ｊａｖａ堆、方法区、...
jvm-sanbox详解--汇总篇
xyznol的博客
05-16 1002
介绍 jvm-sanbox是阿里出的基于 java.lang.instrument包做的一款工具 使用手册 源码git地址：https://github.com/alibaba/jvm-sandbox 使用手册：源码中wiki很详细，不再赘述 jvmsandbox的前世今生：https://yq.aliyun.com/articles/707736 基本原理 ...
JVM基本概念
热门推荐
北漂码农的博客
07-09 2万+
JVM是可运行Java 代码的假想计算机 ，包括一套字节码指令集、一组寄存器、一个栈、一个垃圾回收，堆 和 一个存储方法域。JVM 是运行在操作系统之上的，它与硬件没有直接的交互。 下面是JVM的一张思维导图： JVM的运行过程： 我们都知道Java 源文件，通过编译器，能够生产相应的.Class 文件，也就是字节码文件， 而字节码文件又通过Java 虚拟机中的解释器，编译成特定机...
JVM之——基本概念、可见性与同步
冰河的专栏
04-24 986
转载请注明出处：https://blog.csdn.net/l1028386804/article/details/80069057开发高性能并发应用不是一件容易的事情。这类应用的例子包括高性能Web服务器、游戏服务器和搜索引擎爬虫等。这样的应用可能需要同时处理成千上万个请求。对于这样的应用，一般采用多线程或事件驱动的 架构 。对于Java来说，在语言内部提供了线程的支持。但是Java的多线程应用...
JVM--基本概念
yanbin
08-16 210
定义 JVM是JAVA虚拟机（JAVA Virtual Machine）的缩写，是一个虚构出来的计算机，是通过在实际的计算机上仿真模拟各种计算机功能来实现的。 JAVA虚拟机有自己完善的虚拟硬件架构，如处理器、堆栈、寄存器等，还具有相应的指令系统。 JVM屏蔽了与具体操作系统平台相关的信息,使得JAVA程序只需生成在JAVA虚拟机上运行的目标代码(字节码),就可以在多种平台上不加修改地运行 ...
mini-jvm in rust实现jvm，jvm-rs-main.zip
04-22
Mini-JVM是JVM的简化版本，它通常只包含JVM的基本功能，如类加载、字节码解释执行等。通过实现Mini-JVM，开发者可以更直观地理解JVM如何执行字节码，如何管理内存，以及如何实现垃圾回收等关键概念。 三、项目结构...
JVM--字节码和类的加载篇1
08-03
描述符是用来表示各种数据类型的，包括基本数据类型如byte、char和double等。这些数据类型在字节码中有着特定的表示方式。例如，无符号数（u1、u2、u4、u8）用于表示不同长度的数字，而表（table）则是一种由多个无...
rock-the-jvm-scala-beginners:Udemy Rock JVM的Scala入门课程
03-15
Scala是Java虚拟机（JVM）上的一个高级编程语言，它融合了面向对象和函数式编程的概念，使得开发者能够编写出高效、可维护的代码。通过本课程，学习者将逐步了解Scala的基础语法、核心特性以及如何在实际项目中应用...
理论与实践结合 解密JVM-day02.rar
06-21
在深入探讨JVM（Java虚拟机）的理论与实践结合时，...通过"理论与实践结合 解密JVM-day02"的学习，我们将不仅了解JVM的基本概念，还能掌握其在实际应用中的调优技巧，为开发高性能、低内存消耗的Java应用打下坚实基础。
Java 虚拟机(JVM)之基本概念详解
08-30
下面小编就为大家带来一篇Java 虚拟机(JVM)之基本概念详解。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
JVM的基本概念
wu13682463835的博客
09-27 218
.JVM简析： 说起Java，我们首先想到的是Java编程语言，然而事实上，Java是一种技术，它由四方面组成：Java编程语言、Java类文件格式、Java虚拟机和Java应用程序接口(Java API)。 JVM基本概念 (1) 基本概念： JVM是可运行Java代码的假想计算机 ，包括一套字节码指令集、一组寄存器、一个栈、一个垃圾回收，堆 和 一个存储方法域。JVM是运行在操作系统之上的，它...
jvm基础概念
hello_IT_的博客
09-11 356
一、jvm主要包括一下几方面： 1.类加载子系统：负责从文件系统或者网络中加载Class信息，加载的信息放在方法区中 2.执行引擎：负责执行虚拟机的字节码文件，一般先进行编译成机器码后执行 3.垃圾回收器：java有一套垃圾回收清理机制，开发人员无需手动清理。 垃圾回收机制算法：引用计数法，标记清除法，复制算法，标记压缩法。 4.堆：在java虚拟机启动时候创建java堆，他是java程
JVM(一)---基础概念
༺࿈无关痛痒࿈༻的博客
01-06 408
JVM概念   JVM是Java Virtual Machine（Java虚拟机）的缩写，JVM是一种用于计算设备的规范，它是一个虚构出来的计算机，是通过在实际的计算机上仿真模拟各种计算机功能来实现的。   引入Java语言虚拟机后，Java语言在不同平台上运行时不需要重新编译。Java语言使用Java虚拟机屏蔽了与具体平台相关的信息，使得Java语言编译程序只需生成在Java虚拟机上运行的目标代...
JVM-GC总结—基本概念篇
one-programmer
02-04 511
Java运行时,程序计数器,虚拟机栈和本地方法栈随线程而生,随线程而灭,栈中的栈帧随着方法的进入和退出有条不紊的进行着出栈和入栈.每一个栈帧中分配多少内存是在编译器决定了.这几个区域的内存分配和回收都具有确定性,所以这几个区域都不用过多考虑回收的问题.java的垃圾回收关注的是java堆和方法区的内存.   一些概念 数据类型 Java虚拟机中，数据类型可以分为两类：基本类型和引用类型。基
一篇帮你搞定JVM基本概念（超详细）
qq_44654974的博客
07-11 303
一、整体框架 二、核心知识学习 基本概念 （1）定义 JVM：Java virtual machine,即Java虚拟机；是可运行Java代码的假想计算机，包括一套 指令集、一组 寄存器、一个栈、一个垃圾回收、堆和一个存储方法域。JVM运行OS之上，它与硬件没有直接的交互。 （2）运行过程 Java源文件 通过编译器，产生相应的class文件（即字节码文件，也是由此 出现 一次编译到处运行的说法 跨平台的特性），再通过JVM中的解释器，编译成特定的机器码。 线程 线程：CPU资源分配的基
JVM 基本概念
尚未佩妥剑 转眼便江湖
10-30 219
JVM 是可运行 Java 代码的假想计算机 ，包括一套字节码指令集、一组寄存器、一个栈、 一个垃圾回收，堆 和 一个存储方法域。JVM是运行在操作系统之上的，它与硬件没有直接 的交互。 Java 源文件，通过编译器，能够生产相应的.Class 文件，也就是字节码文件， 而字节码文件又通过 Java 虚拟机中的解释器，编译成特定机器上的机器码 。 也就是如下： ① Java 源文件—->编译器—->字节码文件 ② 字节码文件—->JVM—->机器码.
"了解JVM的基本概念和运行过程
总之，《阿里大佬总结的Java面试资料.pdf》对JVM的介绍非常详细，并且内容丰富，包括了JVM的基本概念、运行过程以及与之相关的其他知识。对于想要深入了解JVM的Java程序员来说，这份资料是一份非常有价值的学习资料...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值