2000年,JDK 1.3发布,Java Hot Spot Virtual Machine正式发布,成为Java的默认虚拟机。
2006年,JDK 6发布。同年,Java开源并建立了OpenJDK。顺理成章,Hotspot虚拟机也成为了OpenJDK中的默认虚拟机。
2008年,Oracle收购了BEA,得到了JRockit虚拟机。
2010年,Oracle收购了Sun,获得了Java的商标和HotSpot虚拟机。
2011年,JDK 7 中正式启用G1垃圾收集器。
2017年,JDK 9 中G1成为默认的GC,代替CMS。IBM也开源了J9 虚拟机。
2018年,JDK 11 LTS版本,发布革命性的ZGC,调整jdk授权许可。
2019年, JDK 12发布,增加了Shenandoah gc。
虚拟机,就是虚拟的计算机,是用来执行一系列虚拟计算机指令的软件。大体可以分为系统虚拟机和程序虚拟机。
Visual Box,VMWare就是系统虚拟机,它们完全是对物理计算机的仿真,提供了一个可运行的完整的操作系统软件平台。 Java虚拟机就是典型的程序虚拟机,它专门为执行单个计算机程序而设计。
无论是哪种虚拟机,其上所运行的软件都被限制于虚拟机提供的资源中。
Java虚拟机就是一台执行字节码(这个字节码可以是Java语言生成的,也可以是其他语言生成的)的虚拟计算机。
java源码(xxx.java)
编译(前端编译):词法分析、语法分析、语法/抽象语法树、语义分析、注解抽象语法树和字节码生成器。
字节码(xxx.class)
Java虚拟机:类加载器,字节码校验器,字节码解释器和JIT编译器
二进制指令
操作系统
Java编译器输入的指令流基本上是一种基于栈的指令集架构,另外一种指令架构是基于寄存器的指令架构。
栈式架构特点:
寄存器式架构特点:
5. 典型应用是x86的二进制指令集:传统pc以及Android的Davlik虚拟机。
6. 指令集架构完全依赖硬件,可移植性差。
7. 性能优秀和执行高效。
8. 花费更少的指令(指令条数少)去完成一项操作。
9. 大部分情况下, 基于寄存器架构的指令集往往都以一地址指令、二地址指令和三地址指令为主。基于栈的指令架构往往以零地址指令为主。
举例:两种指令架构下实现2+3
iconst_2 // 常量2入栈
istore_1
iconst_3 // 常量3入栈
istore_2
iload_1
iload_2
iadd // 常量2,3出栈,执行相加
istore_0 // 结果5入栈
mov eax,2 // eax 初始值设置为2
add eax,3 // 将寄存器内的值+3
【启动】
Java虚拟机的启动是通过引导类加载器(Bootstrap class loader)创建一个初始类(initial class)来完成的,这个类由虚拟机的具体实现指定的。
【执行】
一个运行中的Java虚拟机有一个清晰的任务:执行java程序。
程序开始执行时它才运行,程序结束时它就停止。
执行一个Java程序的时候,真正执行的是一个Java虚拟机的进程。
【退出】
【Sun Classic VM】
1996年,JDK1.0发布了第一款商用的java虚拟机,Sun Classic VM。jdk 1.4的时候被淘汰掉了。
此VM只提供解释器。
如果要使用jit编译器,需要进行外挂。一旦使用了JIT,JIT就会接管虚拟机的执行系统。解释器就不再工作。解释器和编译器不能配合工作。
现在HotSpot虚拟机中内置了此虚拟机。
【Exact VM】
【HotSpot VM】
【JRockit VM】
【J9】
【Azul VM】
【Liquid VM】
【Apache Harmony】
【Micorsoft JVM】
【TaobaoJVM】
【Dalvik VM】
【Graal VM】
文件头特定的文件标识就是“咖啡baby”。
所有的类加载器不是继承关系,可以看做是等级关系,永远都是最高等级的bootstrap先加载对象,其加载不了的才轮到后面。
【Bootstrap类加载器】
bootstrap加载器加载jre/lib/rt.jar
,resources.jar
或者sun.boot.class.path
路径中的内容,Object类,String类,ArrayList等都是其加载的。
查看启动类加载器的加载路径
URL[] urls = sun.misc.Launcher.getBootstrapClassPath().getURLs();
加载扩展类和应用程序类加载器,并指定为他们的父类加载器。
出于安全考虑,Bootstrap启动类加载器只加载包名为java、javax、sun等开头的类。
【Ext类加载器】
扩展类加载器加载的是 jre/lib/ext/*.jar中的内容。
如果用户创建jar包也放在了ext目录中, 也会自动由ext类加载器进行加载。
查看扩展类加载器的加载路径
String extDirs = System.getProperty("java.ext.dirs");
String dirArr = extDirs.split(";");
【系统类加载器】
应用程序类加载器加载Java编码中自定义的对象。
负责加载环境变量classpath或者系统属性java.class.path指定路径下的类库。
系统类加载器是程序中默认的类加载器,一般来说,Java应用的类都有它来完成。
可以通过如下方式获取到此类加载器:ClassLoader.getSystemClassLoader()
验证用例程序
package org.example.classloader;
import com.sun.nio.zipfs.JarFileSystemProvider;
public class ClassLoaderTest {
public static void main(String[] args) {
Object o = new Object();
System.out.println(o.getClass().getClassLoader()); // bootstrap class loader 获得不到的,返回值为null
System.out.println("==========================================");
MyObject myObject = new MyObject();
System.out.println(myObject.getClass().getClassLoader());
System.out.println(myObject.getClass().getClassLoader().getParent());
System.out.println(myObject.getClass().getClassLoader().getParent().getParent());
System.out.println("==========================================");
JarFileSystemProvider provider = new JarFileSystemProvider();
System.out.println(provider.getClass().getClassLoader());
System.out.println(provider.getClass().getClassLoader().getParent());
}
}
class MyObject {
}
null
==========================================
sun.misc.Launcher$AppClassLoader@18b4aac2
sun.misc.Launcher$ExtClassLoader@14ae5a5
null
==========================================
sun.misc.Launcher$ExtClassLoader@14ae5a5
null
从JVM规范的角度上讲,类加载器分为两种:引导类加载器(Bootstrap ClassLoader)和自定义类加载器(User-defined ClassLoader)。Java虚拟机规范中将所有的派生于ClassLoader的类加载器全部划归为自定义类加载器。
获取classLoader的方式:
clazz.getClassLoader();
Thread.currentThread().getContextClassLoader();
ClassLoader.getSystemClassLoader();
DriverManger.getCallerClassLoader();
java.lang.ClassLoader
, 建议把自定义的类加载逻辑放在findClass()
方法中。用一个案例证明双亲委派机制保证了Java代码的安全性。
package java.lang;
public class String {
public static void main(String[] args) {
System.out.println("Hello World");
}
}
错误: 在类 java.lang.String 中找不到 main 方法, 请将 main 方法定义为:
public static void main(String[] args)
否则 JavaFX 应用程序类必须扩展javafx.application.Application
双亲委派机制的好处:
加载(Loading)-> 【验证(Verification)-> 准备(preparation)-> 解析(Resolution)】-> 初始化(Initilization)
--------------------------【这个就是链接过程】
【加载】
.class文件的来源:
【验证】
【准备】
【解析】
【初始化】
4. 初始化阶段就是执行类构造器方法
的过程.
不同于类的构造器(关联:构造器是虚拟机视角下的
)
5.
不需要定义,是由javac编译器自动收集类中的所有类变量的赋值动作和静态代码块中的语句合并而来。 类构造器方法中的指令按照语句在源文件中出现的顺序执行。
6. 若一个类具有父类,JVM会保证子类的
执行前,父类的
方法已经执行完毕。
7. 虚拟机必须保证一个类的
方法在多线程环境下被同步加锁。
8.
public class ClassInitTest {
static {
number = 20;
// 报错:非法的前向引用
// System.out.println(number);
}
// prepare : number = 0;
// initial : 20 ---> 10
private static int number = 10;
public static void main(String[] args) {
System.out.println(ClassInitTest.number); // 10
}
}
JVM中表示两个class对象是否为同一个类的两个必要条件:
JVM必须知道一个类型是由启动类加载器加载的还是由用户类加载器加载的。如果一个类型是由用户类加载器加载的,那么JVM会将这个类加载器的一个引用作为类型信息的一部分保存在方法区中。 当解析一个类型到另一个类型的引用的时候,JVM需要保证这两个类型的类加载器是相同的。
Java程序对类的使用分为:主动使用和被动使用。
主动使用情况:
1 创建类的实例
2 访问某个类或者接口的静态变量,或者对该静态变量赋值
3 调用类的静态方法
4 反射(例如Class.forName(“xxxx”))
5 初始化一个类的子类
6 Java虚拟机启动时被标明为启动类的类
7 JDK7开始提供的动态语言支持:java.lang.invoke.MethodHandle
实例的解析结果REF_getStatci
、REF-putStatic
和REF-invokeStatic
句柄对应的类没有初始化,那么就需要初始化
除了主动使用的情况,都是被动使用,被动使用的时候不会导致类的初始化。
PC Register是唯一一个在Java虚拟机规范中没有规定任何OutOfMemoryError的区域。
为什么要有PC寄存器?
因为CPU会在不同的线程之间来回切换,切换回来之后,需要知道接着从哪里开始执行。
JVM字节码解释器需要通过改变PC寄存器中的值来明确下一条应该执行什么样的字节码指令。
PC寄存器为什么要设置成为线程私有?
为了能准确记录各个线程正在执行的字节码地址,最好的解决办法就是为每一个线程都分配一个PC寄存器。
方法区的大小决定了系统可以保存多少个类,如果系统定义了太多类,方法区溢出,虚拟机同样会抛出OutOfMemoryError。例如加载了大量的第三方的jar包;Tomcat部署的工程过多。大量的生成反射类。
jdk7以前是永久代,使用的JVM中的内存
JDK8之后,使用元空间。元空间不在虚拟机设置的内存中,而是使用本地内存。
【java 7】
https://www.oracle.com/java/technologies/javase/vmoptions-jsp.html
https://docs.oracle.com/cd/E74363_01/ohi_vbp_-_installation_guide–20160224-094432-html-chunked/s66.html
https://docs.oracle.com/javase/7/docs/technotes/tools/windows/java.html
-XX:PermSize 设置永久代初始分配空间. 默认值是20.75M. (宋红康)
Option and default value | Description |
---|---|
-XX:MaxPermSize=64m | Size of the Permanent Generation. [5.0 and newer: 64 bit VMs are scaled 30% larger; 1.4 amd64: 96m; 1.3.1 -client: 32m.]。 64位机器默认是82M(宋红康) |
【java 8】 | |
https://docs.oracle.com/javase/8/docs/technotes/tools/windows/java.html | |
https://docs.oracle.com/javase/8/docs/technotes/tools/unix/java.html |
XX:MetaspaceSize=size
Sets the size of the allocated class metadata space that will trigger a garbage collection the first time it is exceeded. This threshold for a garbage collection is increased or decreased depending on the amount of metadata used. The default size depends on the platform.
windows下默认值是21M
-XX:MaxMetaspaceSize=size
默认不设限。 -1。 设置案例 -XX:MaxMetaspaceSize=256m
栈管运行,堆管存储。
线程私有。生命周期和线程一致。
8种基本类型的变量 + 对象的引用变量 + 实例方法都是在函数的栈内存中分配。
一个栈帧就对应一个Java方法。
栈是一种快速有效的存储方式,访问速度仅次于程序计数器。 栈不存在GC也不存在OOM问题。
Java虚拟机规范允许Java栈的大小是动态的或者是固定不变的。
如果采用固定大小的虚拟机栈,那么每一个线程的栈容量可以在线程创建的时候独立选定。如果线程请求分配的栈容量超过了虚拟机栈允许的最大容量,Java虚拟机会抛出一个StackOverFlowError
。
如果Java虚拟机栈可以动态扩展,并且在尝试扩展的时候无法申请到足够的内存,或者在创建新的线程时没有足够的内存去创建对应的虚拟机栈,那么Java虚拟机会抛出OutOfMemoryError
.
使用-Xss
设置线程的最大栈空间。
不同线程中所包含的栈帧不允许存在相互引用,即不可能在一个栈帧之中应用另外一个线程的栈帧。
如果当前方法调用了其他方法,方法返回之际,当前栈帧会传回此方法的执行结果给前一个栈帧,接着,虚拟机会丢弃当前栈帧,使得前一个栈帧成为当前栈帧。
Java函数返回方式有两种:一种是正常的函数返回,例如使用了return指令;另外一种是抛出异常(这里是真正的抛出异常。如果异常被捕获处理,那就是正常函数返回。 )。无论是哪种方式,都会导致栈帧被弹出。
【栈帧的内部结构】
1 局部变量表,Local Variables
局部变量表也被称为局部变量数组或者本地变量表。
定义为一个数字数组,主要用于存储方法参数和定义在方法体内的局部变量(包括基本数据类型,引用类型和returnAddress类型等)。
局部变量表为线程私有,不存在数据安全问题。
局部变量表所需的容量大小是在编译期确定下来的,并保存在方法的Code属性的maximum local variables数据项中。在方法运行期间是不会改变局部变量表的大小的。
对一个函数而言,它的参数和局部变量越多,使得局变量表膨胀,它的栈帧就越大。
局部变量表中的变量只在当前方法调用中有效。在方法执行时,虚拟机通过使用局部变量表完成参数值到参数变量列表的传递过程。当方法调用结束之后,随着方法栈帧的销毁,局部变量表也会随之销毁。
局部变量表最基本的存储单元是Slot(变量槽)。在局部变量表里,32位以内的类型只占用一个slot(包括returnAddress类型),64位类型(long和double)需要占用两个slot。byte、short、char在存储之前会被转换为int;boolean类型也会被转换为int,0表示false,非0表示true。
如果需要访问局部变量表中一个64bit的局部变量(long或者double)值时,只需要使用前一个索引(64位的占两个slot)即可。
如果当前帧是由构造方法或者实例方法创建的,那么该对象的this引用会被放在index为0的slot处,其余的参数按照参数列表的顺序继续排列。
Slot是可以重复利用的.
public void test4() {
int a = 0;
{
int b = 0;
b = a + 1;
}
// 局部变量表的长度就是3
// 变量c使用之前已经销毁的变量b的slot
int c = a + 1;
}
index Name
2 b
0 this
1 a
2 c
【静态变量和局部变量对比】
变量的分类
按照数据类型分:① 基本数据类型 ② 引用数据类型
按照在类中声明的位置分: ① 成员变量:在使用前都经历过默认的初始化过程
<1> 类变量:linking的prepare阶段,给类变量赋默认初始值;initial阶段:执行静态代码块中的语句,赋值。
<2> 实例变量:随着对象的创建,会在堆空间中分配实例变量空间,并进行默认赋值。
② 局部变量:在使用前,必须要进行显式的赋值。否则编译不通过。
public void test5Temp() {
int num;
// 直接编译报错:Variable 'num' might not have been initialized.
System.out.println(num);
}
在栈帧中,与性能调优关系最密切的部分就是局部变量表。在方法执行时,虚拟机使用局部变量表完成方法的传递。
局部变量表中的变量是重要的垃圾回收的根节点,只要被局部变量表中直接或者间接引用的对象都不会被回收。
2 操作数栈, Operand stack,或者称为表达式栈
操作数栈,在方法执行过程中, 根据字节码指令,向栈中写入数据或者从栈中提取数据。
例如
[8] [23]
[15] -----------add 操作执行之后---------> [其他元素]
[其他元素]
如果被调用的方法有返回值,其返回值会被压入当前栈帧的操作数栈中,并更新pc寄存器中下一条需要执行的指令的偏移地址。
操作数栈中元素的数据类型必须与字节码指令的序列严格匹配。这由编译器在编译期间进行验证,同时在类加载过程中的类检验阶段的数据流分析阶段会再次验证。
Java虚拟机的解释器是基于栈的执行引擎,这里的栈就是操作数栈。
操作数栈主要用于保存计算过程的中间结果, 同时作为计算过程中变量临时的存储空间。 操作数栈就是执行引擎的一个工作区,当一个方法开始执行的时候,会创建新的栈帧,操作数栈也是空的。 操作数栈的深度在编译期间就一定确定,保存在Code属性的max_stack中。32位长度的类型占用一个栈深度,64位的占用两个。操作数栈并不能通过数组索引方式访问,只能通过入栈和出栈操作来完成数据访问。
【栈顶缓存技术】
基于栈式架构的虚拟机使用的零地址指令更加紧凑,但是完成一项操作的时候必然要使用更多的入栈和出栈指令,这时就意味着将需要更多的指令分派次数(instruction dispatch)和内存读写次数。
由于操作数是存储在内存中的,因此频繁的内存读写必然会影响执行速度。为了解决此问题,HotSpot JVM设计者们提出了栈顶缓存(ToS, Top-of-Stack Cashing)技术,将栈顶元素全部缓存在物理CPU的寄存器中,为此降低了对内存的读写次数,提升执行引擎的执行效率。
3 动态链接,Dynamic linking,或者称为指向运行时常量池的方法引用
每一个栈帧内部都包含一个指向运行时常量池中该帧所属方法的引用。包含这个应用的目的就是为了支持当前方法能够实现动态链接。 比如:invokedynamic指令
在Java源文件被编译到字节码文件中时,所有的变量和方法引用都作为符号引用(Symbolic Reference)保存在class文件的常量池中。 例如:描述一个方法调用了另外的其他方法时,就是通过常量池中指向方法的符号引用来表示的,那么动态链接的作用就是将这些符号引用转换为调用方法的直接引用。
为什么需要常量池?
常量池的作用就是提供一些符合和常量,便于指令识别。
【方法的调用】
静态链接:当一个字节码文件被装载到JVM内部时,如果被调用的目标方法在编译期可知,且运行期保持不变。这种情况下调用方法的符号引用转为直接引用的过程称为静态连接。
动态链接:如果被调用方法在编译期无法确定下来,换言之,只能在程序运行期将调用方法的符号引用转换为直接引用,这种引用转换过程具有动态性,因此也被称为动态链接。
绑定:绑定是一个字段、方法或者类在符号引用被替换为直接引用的过程,这个过程仅仅发生一次。
早期绑定:静态链接,目标方法在编译期可知,并且运行期间保持不变,可以直接静态连接。
晚期绑定:动态链接。
C语言这种面向过程的只有早期绑定。面向对象的语言,具有多态性,具备早期绑定和晚期绑定两种绑定方式。
非虚方法:编译期就确定了调用版本,并且运行时不可变。 此种就称为非虚方法。
非非虚方法就是虚方法。
普通调用指令
invokestatic:调用静态方法,解析阶段确定唯一方法版本。
invokespecial:调用方法、私有及父类方法,解析阶段确定唯一方法版本。
invokevirtual:调用所有的虚方法,也会调用final修饰的方法,但是final修饰的方法不是虚方法
invokeinterface:调用接口方法。
动态调用指令
invokedynamic:动态解析出需要调用的方法,然后执行。
前四条指令固化在虚拟机内部,方法的调用执行完全不可人为干预。invokedynamic指令支持用于确定方法版本。
静态类型语言:对类型的检查在编译期。判断变量自身的类型信息。
动态类型语言:对类型的检查在运行期。判断变量值的类型信息,变量没有类型信息。
【Java语言中方法覆写的本质】
(1) 找到操作数栈顶的第一个元素所执行的对象的实际类型,记为C
(2) 如果在类型C中找到与常量中描述符合并且简单名称都相符的方法,则进行访问权限校验,如果通过则返回这个方法的直接引用,查找过程结束;如果不通过,则返回java.lang.IllegalAccessError
(3) 否则, 按照继承关系从下往上依次对C的各个父类进行第(2)步的搜索和验证过程
(4)如果始终没有找到合适的方法,则抛出java.lang.AbstractMethodError
java.lang.IllegalAccessError
介绍:程序试图访问或修改一个属性,或者程序试图调用一个方法,但是程序没有对这个属性或者方法的访问权限。一般这种情况就会引起编译器异常。如果这个错误发生在运行时,就说明一个类发生了不兼容的改变。
为了提高性能,JVM在类的方法区建立虚方法表(virtual method table)。使用索引表来代替查找。每个类中都有虚方法表,表中存放各个方法的实际入口。 虚方法表会在类加载过程中的链接阶段(Resolving阶段)被创建并初始化,类的变量初始值准备完成之后,JVM会把该类的方法表也初始化完毕。
4 方法返回地址,Return Address,或者称为方法正常异常退出的定义
存放调用该方法的PC寄存器的值
正常退出保存的是PC寄存器的值,异常退出就不保存了。异常退出的返回地址要根据异常表来确定,栈帧中不会保存这部分信息。
ireturn:返回值是boolean,byte,char,short或者int
lreturn:long
freturn: float
dreturn: double
areturn:引用类型
return:没有返回值的,void方法,构造方法,静态代码块等。
5 附加信息
例如,对程序调试提供支持的信息。
【栈溢出】
StackOverFlowError
Java虚拟机规范规定,堆可以处于物理上不连续的内存空间中,但是在逻辑上应该是连续的。
堆空间中可以专门划分线程私有缓冲区(Thread Local Allocation Buffer,TLAB)。
java 8 以及以后逻辑上分为三部分:新生代+老年代+元空间(方法区)。
-Xms :堆(年轻代+年老带)的起始大小,ms是memory start
-Xmx:堆的最大大小
默认情况下,初始堆大小是物理内存 / 64; 最大内存是物理内存 / 4;
查看设置的参数:
方式一:jps / jstat -gc 进程id
方式二:-XX:+PrintGcDetails
Eden满了就会触发YGC(又被称为MinorGC),会回收Eden区和Survivor区中的对象。
幸存者区s0, s1区的运行规则:复制之后有交换,空的就是to区。
垃圾回收:频繁在新生区收集,很少在老年代收集,几乎不再永久代/元空间收集。
GC按照回收区域分为部分收集(Partical GC)和整体收集(Full GC)。
部分收集分为:(1)新生代收集:Minor GC / Young GC, 只是新生代的垃圾收集。触发条件:Eden区满的时候。Minor GC会引发STW,暂停其他用户的线程,等垃圾回收结束,用户线程才会恢复运行。(2)老年代收集:Major GC / Old GC, 只是老年代的垃圾收集。目前,只有CMS GC会有单独收集老年代的行为。注意很多时候Major GC和Full GC混淆使用,需要具体分辨是老年代回收还是整体回收。触发条件:老年代空间不足的时候,会先尝试触发minor gc。如果minor gc之后空间还是不足的,则会触发Major gc。(3)混合收集:Mixed GC,收集整个新生代以及部分老年代的垃圾收集。目前,只有G1 GC会有这种行为。
整堆收集:Full GC, 收集整个Java堆和方法区。
Full GC执行的情况有:(1)调用System.gc()
时,系统建议执行Full GC,但是不是必然执行。 (2)老年代空间不足。(3)方法区空间不足。(4)通过Minor GC后进入老年代的平均大小大于老年代的可用内存。(5)向to区复制时,对象大小大于to区可用内存,则把该对象转存到老年代,且老年代的可用内存小于该对象大小。
不分代也可以,分代的唯一理由就是GC性能优化。
对Eden区进行划分,为每一个线程分配一个私有的缓存区域。
JVM将TLAB作为内存分配的首选。
默认情况下,TLAB空间非常小,仅有Eden空间的1% 。
【栈上分配】
如果经过逃逸分析后发现,一个对象并没有逃逸出方法的话那么就可以被优化成栈上分配。
【同步省略】
逃逸分析会进行锁消除优化。
public void f() {
Object hollis = new Object();
synchronized (hollis) {
System.out.println(hollis);
}
}
=====优化后=======
public void f() {
Object hollis = new Object();
System.out.println(hollis);
}
【标量替换】
标量是指无法再分解成更小数据的数据。Java中的原始数据类型就是标量。 相对的,哪些还可以分解的数据叫做聚合量。 Java中的对象就是聚合量。
在JIT阶段,如果经过逃逸分析发现一个对象不会被外界访问的话,那么经过jit优化,就会把这个对象拆解成若干个标量来进行替代。这就是标量替换。
【元数据区】
逃逸分析并不成熟。逃逸分析本身也是需要极大的性能消耗,不能保证逃逸分析能带来收益。
intern字符串缓存和静态变量并不是在元数据区,而是直接在堆上分配的。
所以,对象基本上都是分配在堆上的。
[1] https://www.bilibili.com/video/BV1jJ411t71s?p=5&spm_id_from=pageDriver&vd_source=f4dcb991bbc4da0932ef216329aefb60