008-深入理解JVM
in 003-性能优化 with 0 comment

008-深入理解JVM

in 003-性能优化 with 0 comment

1. JVM官网

1.1 帮助文档

帮助文档首页 :https://docs.oracle.com/javase/8/
Java官网首页 :https://www.oracle.com/java/

JavaWorld.png

1.2 The relation of JDK/JRE/JVM

Reference -> Developer Guides -> 定位到:https://docs.oracle.com/javase/8/docs/index.html
jdk.png

2. 源码到类文件

2.1 源码

class Person{
	private String name;
	private int age;
	private static String address;
	private final static String hobby="Programming";
	public void say(){
		System.out.println("person say...");
	}
	public int calc(int op1,int op2){
		return op1+op2;
	}
}

编译: javac Person.java ---> Person.class

2.2 编译过程

Person.java -> 词法分析器 -> tokens流 -> 语法分析器 -> 语法树/抽象语法树 -> 语义分析器
-> 注解抽象语法树 -> 字节码生成器 -> Person.class文件

2.3 类文件(Class文件)

官网The class File Format :https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html

cafe babe 0000 0034 0027 0a00 0600 1809
0019 001a 0800 1b0a 001c 001d 0700 1e07
001f 0100 046e 616d 6501 0012 4c6a 6176
612f 6c61 6e67 2f53 7472 696e 673b 0100
0361 6765 0100 0149 0100 0761 6464 7265
......

magic(魔数):

The magic item supplies the magic number identifying the class file format; it has the
value 0xCAFEBABE(魔术项提供标识类文件格式的魔术数字;它有值0 xcafebabe开头)

cafe babe

minor_version, major_version

0000 0034 对应10进制的52,代表JDK 8中的一个版本

constant_pool_count

0027 对应十进制27,代表常量池中27个常量
ClassFile {
	u4 magic;
	u2 minor_version;
	u2 major_version;
	u2 constant_pool_count;
	cp_info constant_pool[constant_pool_count-1];
	u2 access_flags;
	u2 this_class;
	u2 super_class;
	u2 interfaces_count;
	u2 interfaces[interfaces_count];
	u2 fields_count;
	field_info fields[fields_count];
	u2 methods_count;
	method_info methods[methods_count];
	u2 attributes_count;
	attribute_info attributes[attributes_count];
}

.class字节码文件

魔数与class文件版本
常量池
访问标志
类索引、父类索引、接口索引
字段表集合
方法表集合
属性表集合

2.4 javap文件分解器

javap -c Person.class > Person.txt,后面再详聊

3. 类文件到虚拟机(类加载机制)

类加载机制:

  • 虚拟机把Class文件加载到内存
  • 并对数据进行校验,转换解析和初始化
  • 形成可以虚拟机直接使用的Java类型,即java.lang.Class

3.1 装载(Load)

查找和导入class文件:

  • 通过一个类的全限定名获取定义此类的二进制字节流
  • 将这个字节流所代表的静态存储结构转化为方法区的运行时数据结构
  • 在Java堆中生成一个代表这个类的java.lang.Class对象,作为对方法区中这些数据的访问入口
Class对象封装了类在方法区内的数据结构,并且向Java程序员提供了访问方法区内的数据结构的接
口。
在Java堆中生成一个代表这个类的java.lang.Class对象,作为对方法区中这些数据的访问入口

4234243.png

类的装载方式有哪些?

  • 本地系统加载
  • 网络下载.class文件
  • 从zip,jar等归档文件中加载.class文件
  • 从数据库中提取.class文件
  • 由java源文件动态编译成.class文件
  • Class.forName()加载
  • ClassLoader.loadClass()加载

3.2.1 验证(Verify)

保证被加载类的正确性

3.2.2 准备(Prepare)

为类的静态变量分配内存,并将其初始化为默认值
jvmstatic.png

3.2.3 解析(Resolve)

把类中的符号引用转换为直接引用

解析阶段是虚拟机将常量池内的符号引用替换为直接引用的过程。
解析动作主要针对类或接口、字段、类方法、接口方法、方法类型、方法句柄和调用限定符7类符号引用进
行。
符号引用就是一组符号来描述目标,可以是任何字面量。
直接引用就是直接指向目标的指针、相对偏移量或一个间接定位到目标的句柄。

3.3 初始化(Initialize)

对类的静态变量,静态代码块执行初始化操作
initialize.png

3.4 类加载机制图解

classLoad.png

4. 类装载器ClassLoader

在装载(Load)阶段,其中第(1)步:通过类的全限定名获取其定义的二进制字节流,需要借助类装载
器完成,顾名思义,就是用来装载Class文件的。
(1)通过一个类的全限定名获取定义此类的二进制字节流

4.1 分类

1. Bootstrap ClassLoader 负责加载$JAVA_HOME中 jre/lib/rt.jar 里所有的class或Xbootclassoath选项指定的jar包。由C++实现,不是ClassLoader子类.
2. Extension ClassLoader 负责加载java平台中扩展功能的一些jar包,包括$JAVA_HOME中jre/lib/*.jar 或 -Djava.ext.dirs指定目录下的jar包。
3. App ClassLoader 负责加载classpath中指定的jar包及 Djava.class.path 所指定目录下的类和jar包。
4. Custom ClassLoader 通过java.lang.ClassLoader的子类自定义加载class,属于应用程序根据自身需要自定义的ClassLoader,如tomcat、jboss都会根据j2ee规范自行实现ClassLoader。

4.2 图解

image.png![image.png]

4.3 加载原则

检查某个类是否已经加载:顺序是自底向上,从Custom ClassLoader到BootStrap ClassLoader逐层检查,只要某个Classloader已加载,就视为已加载此类,保证此类只所有ClassLoader加载一次。

加载的顺序:加载的顺序是自顶向下,也就是由上层来逐层尝试加载此类

双亲委派机制

定义:如果一个类加载器在接到加载类的请求时,它首先不会自己尝试去加载这个类,而是把这个请求任务委托给父类加载器去完成,依次递归,如果父类加载器可以完成类加载任务,就成功返回;只有父类加载器无法完成此加载任务时,才自己去加载。
优势:Java类随着加载它的类加载器一起具备了一种带有优先级的层次关系。比如,Java中的Object类,它存放在rt.jar之中,无论哪一个类加载器要加载这个类,最终都是委派给处于模型最顶端的启动类加载器进行加载,因此Object在各种类加载环境中都是同一个类。如果不采用双亲委派模型,那么由各个类加载器自己取加载的话,那么系统中会存在多种不同的Object类。

5. 运行时数据区(Run-Time Data Areas)

在装载阶段的第(2),(3)步可以发现有运行时数据,堆,方法区等名词
(2)将这个字节流所代表的静态存储结构转化为方法区的运行时数据结构
(3)在Java堆中生成一个代表这个类的java.lang.Class对象,作为对方法区中这些数据的访问入口
说白了就是类文件被类装载器装载进来之后,类中的内容(比如变量,常量,方法,对象等这些数
据得要有个去处,也就是要存储起来,存储的位置肯定是在JVM中有对应的空间)

5.1 官网概括

官网描述

Summary

The Java Virtual Machine defines various run-time data areas that are used
during execution of a program. Some of these data areas are created on Java
Virtual Machine start-up and are destroyed only when the Java Virtual Machine
exits. Other data areas are per thread. Per-thread data areas are created when a
thread is created and destroyed when the thread exits.
(Java虚拟机定义了所使用的各种运行时数据区域在程序执行期间。
其中一些数据区域是在Java上创建的虚拟机启动和销毁时,只有Java虚拟机退出。
其他数据区域是每个线程时创建每个线程的数据区域在线程退出时创建和销毁线程。)

5.2 图解

image.png

5.3 常规理解

5.3.1 Method Area(方法区)

此时回看装载阶段的第2步:(2)将这个字节流所代表的静态存储结构转化为方法区的运行时数据结构

如果这时候把从Class文件到装载的第(1)和(2)步合并起来理解的话,可以画个图

image.png

说明
(1)方法区在JDK8中就是Metaspace,在JDK6或7中就是Perm Space
(2)Run-Time Constant Pool

Class文件中除了有类的版本、字段、方法、接口等描述信息外,还有一项信息就是常量池,用于存放编译时期生成的各种字面量和符号引用,这部分内容将在类加载后进入方法区的运行时常量池中存放。

Each run-time constant pool is allocated from the Java Virtual Machine's method
area (§2.5.4).s

5.3.2 Heap(堆)

TheJavaVirtualMachinehasaheapthatissharedamongallJavaVirtualMachinethreads.Theheapistherun-timedataareafromwhichmemoryforall classinstancesandarraysisallocated.Theheapiscreatedonvirtualmachinestart-up.

此时回看装载阶段的第3步:
(3)在Java堆中生成一个代表这个类的java.lang.Class对象,作为对方法区中这些数据的访问入口

此时装载(1)(2)(3)的图可以改动一下

image.png

5.3.3 Java Virtual Machine Stacks(虚拟机栈)

经过上面的分析,类加载机制的装载过程已经完成,后续的链接,初始化也会相应的生效。

假如目前的阶段是初始化完成了,后续做啥呢?肯定是Use使用咯,不用的话这样折腾来折腾去有什么意义?那怎样才能被使用到?换句话说里面内容怎样才能被执行?比如通过主函数main调用其他方法,这种方式实际上是main线程执行之后调用的方法,即要想使用里面的各种内容,得要以线程为单位,执行相应的方法才行

那一个线程执行的状态如何维护?一个线程可以执行多少个方法?这样的关系怎么维护呢?

Each Java Virtual Machine thread has a private Java Virtual Machine stack,
created at the same time as the thread. A Java Virtual Machine stack stores
frames (§2.6).

写段伪代码/画图理解栈和栈帧

a(){
  b();
}
b(){
  c();
}
c(){
}

image.png

5.3.4 The pc Register(程序计数器)

我们都知道一个JVM进程中有多个线程在执行,而线程中的内容是否能够拥有执行权,是根据CPU调度来的。
假如线程A正在执行到某个地方,突然失去了CPU的执行权,切换到线程B了,然后当线程A再获得CPU执行权的时候,怎么能继续执行呢?这就是需要在线程中维护一个变量,记录线程执行到的位置

The Java Virtual Machine can support many threads of execution at once (JLS
§17). Each Java Virtual Machine thread has its own pc (program counter)
register. At any point, each Java Virtual Machine thread is executing the code
of a single method, namely the current method (§2.6) for that thread. If that
method is not native, the pc register contains the address of the Java Virtual
Machine instruction currently being executed. If the method currently being
executed by the thread is native, the value of the Java Virtual Machine's pc
register is undefined. The Java Virtual Machine's pc register is wide enough to
hold a returnAddress or a native pointer on the specific platform.

5.3.5 Native Method Stacks(本地方法栈)

如果当前线程执行的方法是Native类型的,这些方法就会在本地方法栈中执行

image.png

5.4 结合字节码指令理解Java虚拟机栈和栈帧

官网
栈帧:每个栈帧对应一个被调用的方法,可以理解为一个方法的运行空间

每个栈帧中包括局部变量表(Local Variables)、操作数栈(Operand Stack)、指向运行时常量池的引用(Areference to the run-time constant pool)、方法返回地址(Return Address)和附加信息。

class Person{
	private String name="Jack";
	private int age;
	private final double salary=100;
	private static String address;
	private final static String hobby="Programming";
	public void say(){
		System.out.println("person say...");
	}
	public static int calc(int op1,int op2){
		op1=3;
		int result=op1+op2;
		return result;
	}
	public static void order(){
	}
	public static void main(String[] args){
		calc(1,2);
		order();
	}
}

此时你需要一个能够看懂反编译指令的宝典官网当然网上也有很多,大家可以自己查找

Compiled from "Person.java"
class Person {
	...
	public static int calc(int, int);
		Code:
			0: iconst_3 //将int类型常量3压入[操作数栈]
			1: istore_0 //将int类型值存入[局部变量0]
			2: iload_0 //从[局部变量0]中装载int类型值入栈
			3: iload_1 //从[局部变量1]中装载int类型值入栈
			4: iadd //将栈顶元素弹出栈,执行int类型的加法,结果入栈
【For example, the iadd instruction (§iadd) adds two int values together.
It requires that the int values to be added be the top two values of the operand
stack, pushed there by previous instructions. Both of the int values are popped
from the operand stack. They are added, and their sum is pushed back onto the
operand stack. Subcomputations may be nested on the operand stack, resulting in
values that can be used by the encompassing computation.】
			5: istore_2 //将栈顶int类型值保存到[局部变量2]中
			6: iload_2 //从[局部变量2]中装载int类型值入栈
			7: ireturn //从方法中返回int类型的数据
		...
}

image.png

5.5 折腾一下

5.5.1 栈指向堆

如果在栈帧中有一个变量,类型为引用类型,比如Object obj=new Object(),这时候就是典型的栈中元素指向堆中的对象
image.png

5.5.2 方法区指向堆

方法区中会存放静态变量,常量等数据。如果是下面这种情况,就是典型的方法区中元素指向堆中的对象

private stati cObject obj= new Object();

image.png

5.5.3 堆指向方法区

What?堆还能指向方法区?
注意,方法区中会包含类的信息,堆中会有对象,那怎么知道对象是哪个类创建的呢?
image.png

思考:一个对象怎么知道它是由哪个类创建出来的?怎么记录?这就需要了解一个Java对象的具体信息咯。

5.5.4 Java对象内存布局

image.png

6. 内存模型

6.1 内存模型与运行时数据区

上面对运行时数据区描述了很多,其实重点存储数据的是堆和方法区(非堆),所以内存的设计也着重从这两方面展开(注意这两块区域都是线程共享的)。对于虚拟机栈,本地方法栈,程序计数器都是线程私有的。

6.2 图解

一块是非堆区,一块是堆区。
堆区分为两大块,一个是Old区,一个是Young区。
Young区分为两大块,一个是Survivor区(S0+S1),一块是Eden区。Eden:S0:S1=8:1:1 S0和S1一样大,也可以叫From和To。

画个图理解一下
image.png

根据之前对于Heap的介绍可以知道,一般对象和数组的创建会在堆中分配内存空间,关键是堆中有这么多区域,那一个对象的创建到底在哪个区域呢?

6.3 对象创建所在区域

一般情况下,新创建的对象都会被分配到Eden区,一些特殊的大的对象会直接分配到Old区

比如有对象A,B,C等创建在Eden区,但是Eden区的内存空间肯定有限,比如有100M,假如已经使用了100M或者达到一个设定的临界值,这时候就需要对Eden内存空间进行清理,即垃圾收集(Garbage Collect),这样的GC我们称之为Minor GC,Minor GC指得是Young区的GC
经过GC之后,有些对象就会被清理掉,有些对象可能还存活着,对于存活着的对象需要将其复制到Survivor区,然后再清空Eden区中的这些对象。

6.4 Survivor区详解

由图解可以看出,Survivor区分为两块S0和S1,也可以叫做From和To。
在同一个时间点上,S0和S1只能有一个区有数据,另外一个是空的

接着上面的GC来说,比如一开始只有Eden区和From中有对象,To中是空的。
此时进行一次GC操作,From区中对象的年龄就会+1,我们知道Eden区中所有存活的对象会被复制到To区,From区中还能存活的对象会有两个去处。
若对象年龄达到之前设置好的年龄阈值,此时对象会被移动到Old区,没有达到阈值的对象会被复制到To区
此时Eden区和From区已经被清空(被GC的对象肯定没了,没有被GC的对象都有了各自的去处)。
这时候From和To交换角色,之前的From变成了To,之前的To变成了From。
也就是说无论如何都要保证名为To的Survivor区域是空的。
Minor GC会一直重复这样的过程,知道To区被填满,然后会将所有对象复制到老年代中。

6.5 Old区详解

从上面的分析可以看出,一般Old区都是年龄比较大的对象,或者相对超过了某个阈值的对象。
在Old区也会有GC的操作,Old区的GC我们称作为Major GC

6.6 对象的一辈子理解

我是一个普通的Java对象,我出生在Eden区,在Eden区我还看到和我长的很像的小兄弟,我们在Eden区中玩了
挺长时间。有一天Eden区中的人实在是太多了,我就被迫去了Survivor区的“From”区,自从去了Survivor
区,我就开始漂了,有时候在Survivor的“From”区,有时候在Survivor的“To”区,居无定所。直到我18岁的
时候,爸爸说我成人了,该去社会上闯闯了。
于是我就去了年老代那边,年老代里,人很多,并且年龄都挺大的,我在这里也认识了很多人。在年老代里,我生
活了20年(每次GC加一岁),然后被回收。

image.png

6.7 常见问题

Minor GC:新生代
Major GC:老年代
Full GC:新生代+老年代
如果没有Survivor,Eden区每进行一次Minor GC,并且没有年龄限制的条件下,存活的对象就会被送到老年代。
这样一来,老年代很快被填满,触发Major GC(因为Major GC一般伴随着Minor GC,也可以看做触发了Full GC)。
老年代的内存空间远大于新生代,进行一次Full GC消耗的时间比Minor GC长得多。
执行时间长有什么坏处?频发的Full GC消耗的时间很长,会影响大型程序的执行和响应速度。

可能你会说,那就对老年代的空间进行增加或者较少咯。
假如增加老年代空间,更多存活对象才能填满老年代。虽然降低Full GC频率,但是随着老年代空间加大,
一旦发生Full GC,执行所需要的时间更长。
假如减少老年代空间,虽然Full GC所需时间减少,但是老年代很快被存活对象填满,Full GC频率增加。

所以Survivor的存在意义,就是减少被送到老年代的对象,进而减少Full GC的发生,Survivor的预筛选保证
只有经历16次Minor GC还能在新生代中存活的对象,才会被送到老年代。
最大的好处就是解决了碎片化。也就是说为什么一个Survivor区不行?第一部分中,我们知道了必须设置
Survivor区。假设现在只有一个Survivor区,我们来模拟一下流程:
刚刚新建的对象在Eden中,一旦Eden满了,触发一次Minor GC,Eden中的存活对象就会被移动到Survivor
区。这样继续循环下去,下一次Eden满了的时候,问题来了,此时进行Minor GC,Eden和Survivor各有一些
存活对象,如果此时把Eden区的存活对象硬放到Survivor区,很明显这两部分对象所占有的内存是不连续的,
也就导致了内存碎片化。
永远有一个Survivor space是空的,另一个非空的Survivor space无碎片。
新生代中的可用内存:复制算法用来担保的内存为9:1
可用内存中Eden:S1区为8:1
即新生代中Eden:S1:S2 = 8:1:1

7. 体验与验证

7.1 使用jvisualvm查看

visualgc插件下载链接 :
https://visualvm.github.io/pluginscenters.html --->选择对应版本链接--->Tools--->Visual GC
若上述链接找不到合适的,大家也可以自己在网上下载对应的版本
image.png

7.2 堆内存溢出

7.2.1 代码

@RestController
public class HeapController {
	List<Person> list=new ArrayList<Person>();
	@GetMapping("/heap")
	public String heap() throws Exception{
		while(true){
			list.add(new Person());
			Thread.sleep(1);
		}
	}
}

记得设置参数比如-Xmx20M -Xms20M

7.2.2 运行结果

访问->http://localhost:8080/heap
结果

Exception in thread "http-nio-8080-exec-2" java.lang.OutOfMemoryError: GC overhead limit exceeded

7.3 方法区内存溢出

比如向方法区中添加Class的信息

7.3.1 asm依赖和Class代码

<dependency>
	<groupId>asm</groupId>
	<artifactId>asm</artifactId>
	<version>3.3.1</version>
</dependency>
public class MyMetaspace extends ClassLoader {
	public static List<Class<?>> createClasses() {
		List<Class<?>> classes = new ArrayList<Class<?>>();
		for (int i = 0; i < 10000000; ++i) {
			ClassWriter cw = new ClassWriter(0);
			cw.visit(Opcodes.V1_1, Opcodes.ACC_PUBLIC, "Class" + i, null,"java/lang/Object", null);
			MethodVisitor mw = cw.visitMethod(Opcodes.ACC_PUBLIC, "<init>","()V", null, null);
			mw.visitVarInsn(Opcodes.ALOAD, 0);
			mw.visitMethodInsn(Opcodes.INVOKESPECIAL, "java/lang/Object","<init>", "()V");
			mw.visitInsn(Opcodes.RETURN);
			mw.visitMaxs(1, 1);
			mw.visitEnd();
			Metaspace test = new Metaspace();
			byte[] code = cw.toByteArray();
			Class<?> exampleClass = test.defineClass("Class" + i, code, 0,code.length);
			classes.add(exampleClass);
		}
		return classes;
	}
}

7.3.2 代码

@RestController
public class NonHeapController {
	List<Class<?>> list=new ArrayList<Class<?>>();
	@GetMapping("/nonheap")
	public String nonheap() throws Exception{
		while(true){
			list.addAll(MyMetaspace.createClasses());
			Thread.sleep(5);
		}
	}
}

设置Metaspace的大小,比如-XX:MetaspaceSize=50M -XX:MaxMetaspaceSize=50M

7.3.3 运行结果

访问->http://localhost:8080/nonheap

java.lang.OutOfMemoryError: Metaspace
	at java.lang.ClassLoader.defineClass1(Native Method) ~[na:1.8.0_191]
	at java.lang.ClassLoader.defineClass(ClassLoader.java:763) ~[na:1.8.0_191]

7.4 虚拟机栈

7.4.1 代码演示StackOverFlow

public class StackDemo {
	public static long count=0;
	public static void method(long i){
		System.out.println(count++);
		method(i);
	}
	public static void main(String[] args) {
		method(1);
	}
}

7.4.2 运行结果

image.png

7.4.3 理解和说明

Stack Space用来做方法的递归调用时压入Stack Frame(栈帧)。所以当递归调用太深的时候,就有可能耗
尽Stack Space,爆出StackOverflow的错误。
-Xss128k:设置每个线程的堆栈大小。JDK 5以后每个线程堆栈大小为1M,以前每个线程堆栈大小为256K。
根据应用的线程所需内存大小进行调整。在相同物理内存下,减小这个值能生成更多的线程。但是操作系统对
一个进程内的线程数还是有限制的,不能无限生成,经验值在3000~5000左右。

线程栈的大小是个双刃剑,如果设置过小,可能会出现栈溢出,特别是在该线程内有递归、大的循环时出现溢
出的可能性更大,如果该值设置过大,就有影响到创建栈的数量,如果是多线程的应用,就会出现内存溢出的
错误。