运行时数据区（虚拟机栈）
虚拟机栈背景
由于跨平台性，CPU架构也不同，所以不能设计为基于寄存器的，java的指令都是基于栈来设计的。
优点是跨平台，指令集小，编译器容易实现，缺点是性能下降，实现同样的功能需要更多的指令。本文主要介绍虚拟机栈相关知识
虚拟机栈-Java Virtual Machine Stack
- java虚拟机栈（Java Virtual Machine Stack），早期也叫Java栈。
- 每个线程在创建时都会创建一个虚拟机栈，其内部保存一个个的栈帧（Stack Frame），对应这个一次次的java方法调用。它是线程私有的
- 生命周期和线程是一致的
- 作用：主管java程序的运行，它保存方法的局部变量（8种基本数据类型、对象的引用地址）、部分结果，并参与方法的调用和返回。
- 局部变量：相对于成员变量（或属性），如果是基本数据变量，则在栈中创建，随栈销毁而销毁。对象一般在堆中创建，栈中对象句柄为堆中对象的引用。逃逸分析可在栈中创建对象，后面篇章中介绍
- 基本数据变量： 相对于引用类型变量（类，数组，接口），基本数据变量在栈中创建，随栈销毁而销毁。
运行时数据区结构图
栈的特点
- 栈是一种快速有效的分配存储方式，访问速度仅次于PC寄存器（程序计数器）
- JVM直接对java栈的操作只有两个
- 每个方法执行，伴随着进栈（入栈，压栈）
- 执行结束后的出栈工作
- 对于栈来说不存在垃圾回收问题
栈和堆区别
- 栈
- 栈是运行时的单位，即：栈解决程序的运行问题，即程序如何执行，或者说如何处理数据。
- 栈空间存放 基本数据类型的局部变量，以及引用数据类型的对象的引用
- 每个线程在创建时都会创建一个虚拟机栈，其内部保存一个个的栈帧（Stack Frame），对应这个一次次的java方法调用。它是线程私有的，生命周期和线程是一致的.
- 堆
- 堆是存储的单位，即： 堆解决的是数据存储的问题，即数据怎么放、放在哪儿。
- 一般来讲，对象主要都是放在堆空间的，是运行时数据区比较大的一块，它是线程公有的。
JVM线程和操作系统线程关系
线程是一个程序里的运行单元。JVM允许-一个应用有多个线程并行的执行。
-
在HotSpotJVM里，每个线程都与操作系统的本地线程直接映射。
- 当一个Java线程准备好执行以后，此时一个操作系统的本地线程也同时创建。Java线程执行终止后，本地线程也会回收I
-
操作系统负责所有线程的安排调度到任何一个可用的CPU上。一旦本地线程初始化成功，它就会调用Java线程中的run()方法。
-
系统空间是给操作系统使用的，用户空间是应用程序使用的，应用程序如果需要访问系统空间，需要进行系统调用，从用户态切换到内核态；在 Java1.2 之后. Linux中的JVM是基于pthread实现的, 可以直接说 Java 线程就是依赖操作系统实现的，是1:1的关系。
JVM守护线程
- 虚拟机线程:这种线程的操作是需要JVM达到安全点才会出现。这些操作必须在不同的线程中发生的原因是他们都需要JVM达到安全点，这样堆才不会变化。这种线程的执行类型包括"stop-the-world"的垃圾收集，线程栈收集，线程挂起以及偏向锁撒销。
- 周期任务线程:这种线程是时间周期事件的体现(比如中断)，他们一般用于周期性操作的调度执行。
- GC线程:这种线程对在JVM里不同种类的垃圾收集行为提供了支持。
- 编译线程:这种线程在运行时会将字节码编译成到本地代码。
- 信号调度线程:这种线程接收信号并发送给JVM，在它内部通过调用适当的方法进行处理。
进程和线程区别
-
进程：操作系统分配资源的最小单位是进程，进程与进程之间相关隔离，每个进程有自己的内存空间，文件描述符，CPU调度以进程作为最小调度单元
-
线程：线程存在与进程当中，是操作系统调度执行的最小单位。说通俗点，线程就是干活的。
线程私有和公有
-
每个线程: 独立包括程序计数器、栈、本地栈。
-
线程间共享: 堆、堆外内存(永久代或元空间、代码缓存)
栈的运行原理
- 每个线程都有自己的栈，栈中的数据都是以栈帧(Stack Frame)的格式存在
- 在这个线程上正在执行的每个方法都对应各自的一个栈帧
- 栈帧是一个内存区块，是一个数据集，维系着方法执行过程中的各种数据信息
- JVM直接对java栈的操作只有两个，就是对栈帧的压栈和出栈，遵循先进后出/后进先出的和原则。
- 在一条活动线程中，一个时间点上，只会有一个活动的栈帧。即只有当前正在执行的方法的栈帧（栈顶栈帧）是有效的，这个栈帧被称为当前栈帧(Current Frame),与当前栈帧对应的方法就是当前方法（Current Frame）
- 执行引擎运行的所有字节码指令只针对当前栈帧进行操作
- 如果在该方法中调用了其他方法，对应的新的栈帧会被创建出来，放在栈的顶端，成为新的当前栈帧。
- 不同线程中所包含的栈帧是不允许相互引用的，即不可能在另一个栈帧中引用另外一个线程的栈帧
- 如果当前方法调用了其他方法，方法返回之际，当前栈帧会传回此方法的执行结果给前一个栈帧，接着，虚拟机会丢弃当前栈帧，使得前一个栈帧重新成为当前栈帧
- Java方法有两种返回函数的方式，一种是正常的函数返回，使用return指令；另外一种是抛出异常。不管使用哪种方式，都会导致栈帧被弹出。
public class StackFrameTest {
public static void main(String[] args) {
try {
StackFrameTest test = new StackFrameTest();
test.method1();
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("main()正常结束");
}
public void method1(){
System.out.println("method1()开始执行...");
method2();
System.out.println("method1()执行结束...");
// System.out.println(10 / 0);
// return ;//可以省略
}
public int method2() {
System.out.println("method2()开始执行...");
int i = 10;
int m = (int) method3();
System.out.println("method2()即将结束...");
return i + m;
}
public double method3() {
System.out.println("method3()开始执行...");
double j = 20.0;
System.out.println("method3()即将结束...");
return j;
}
}
复制代码方法的结束方式分为两种：
- 正常结束，以return为代表
- 方法执行中出现未捕获处理的异常，以抛出异常的方式结束
入栈出栈结果输出：
method1()开始执行...
method2()开始执行...
method3()开始执行...
method3()即将结束...
method2()即将结束...
method1()执行结束...
main()正常结束
复制代码栈中异常
java虚拟机规范允许Java栈的大小是动态的或者是固定不变的
- 固定大小：如果线程请求的栈深度大于虚拟机所允许的最大深度，将抛出StackOverflowError异常。
- 动态拓展：如果虚拟机在扩展栈时无法申请到足够的内存空间，则抛出OutOfMemoryError异常。
栈StackOverFlowError
方法递归调用，当超出栈深度时报StackOverFlowError错误。
/**
* 演示栈中的异常:StackOverflowError
*
* 默认情况下：count : 11420
* 可设置栈的大小： -Xss256k : count : 2465
*/
public class StackErrorTest {
private static int count = 1;
public static void methodA() {
count++;
System.out.println(count);
methodA();
}
public static void main(String[] args) {
methodA();
}
}
复制代码栈OutOfMemoryError
如果测试时不限于单线程，通过不断的建立线程的方式倒是可以产生内存溢出异常，如下代码所示。但是这样产生的内存溢出异常与栈空间是否足够大并不存在任何联系，或者准确的说，在这种情况下，为每个线程的栈分配的内存越大，反而越容易产生内存溢出异常。
如果使用虚拟机默认参数，栈深度在大多数情况下（因为每个方法压入栈的帧大小并不是一样的，所以只能说在大多数情况下）达到1000~2000完全没有问题，对于正常的方法调用（包括递归），这个深度应该完全够用了。但是，如果是建立过多线程导致的内存溢出，在不能减少线程数或者更换64位虚拟机的情况下，就只能通过减少最大堆和减少栈容量来换取更多的线程
代码执行时有较大的风险，可能会导致操作系统假死。
public class JavaVMStackOOM {
private void dontStop() {
while (true) {
}
}
public void stackLeakByThread() {
while (true) {
new Thread(new Runnable() {
@Override
public void run() {
dontStop();
}
}).start();
}
}
public static void main(String[] args) {
JavaVMStackOOM oom = new JavaVMStackOOM();
oom.stackLeakByThread();
}
}
复制代码设置栈的大小
- -Xss选项来设置线程的最大栈空间，栈的大小直接决定了函数调用的最大可达深度。（-Xss256k）
- JDK8默认栈大小：
Sets the thread stack size (in bytes). Append the letter k or K to indicate KB, m or M to indicate MB, or g or G to indicate GB. The default value depends on the platform:
-
Linux/x64 (64-bit): 1024 KB
-
macOS (64-bit): 1024 KB
-
Windows: The default value depends on virtual memory
The following examples set the thread stack size to 1024 KB in different units:
-Xss1m
-Xss1024k
-Xss1048576
This option is similar to
-XX:ThreadStackSize.
-Xss是-XX:ThreadStackSizeOpenJDK和Oracle JDK 的别名.
虽然它们以不同的方式解析参数:
-Xss可以接受带有K,M或G后缀的数字;
-XX:ThreadStackSize=需要一个整数(不带后缀) - 堆栈大小,以千字节为单位.
虚拟机栈内部结构
- 局部变量表（Local Variables）
- 操作数栈（Operand Stack）(或表达式栈)
- 动态链接（Dynamic Linking）(或执行运行时常量池的方法引用)
- 方法返回地址（Return Adress）（或方法正常退出或者异常退出的定义）
- 附加信息
局部变量表-Local Variable
-
局部变量表也被称之为局部变量数组或本地变量表
-
定义为一个数字数组，主要用于存储方法参数和定义在方法体内的局部变量，这些数据类型包括各类基本数据类型(boolean、byte、char、short、int、float)、对象引用(reference) ，以及returnAddress类型。reference类型表示对一个对象实例的引用
-
由于局部变量表是建立在线程的栈上，是线程的私有数据，因此不存在数据安全问题
-
局部变量表所需的容量大小是在编译期确定下来的，并保存在方法的Code属性的maximum local variables数据项中。 在方法运行期间是不会改变局部变量表的大小的。
-
方法嵌套调用的次数由栈的大小决定。一般来说，栈越大，方法嵌套调用次数越多。对一个函数而言，它的参数和局部变量越多，使得局部变量表膨胀,它的栈帧就越大，以满足方法调用所需传递的信息增大的需求。进而函数调用就会占用更多的栈空间，导致其嵌套调用次数就会减少。
-
局部变量表中的变量只在当前方法调用中有效。在方法执行时，虚拟机通过使用局部变量表完成参数值到参数变量列表的传递过程。当方法调用结束后，随着方法栈帧的销毁，局部变量表也会随之销毁。
字节码查看
public class LocalVariablesTest {
private int count = 0;
public static void main(String[] args) {
LocalVariablesTest test = new LocalVariablesTest();
int num = 10;
test.test1();
}
//练习：
public static void testStatic() {
LocalVariablesTest test = new LocalVariablesTest();
Date date = new Date();
int count = 10;
System.out.println(count);
//下面这行会报错：因为this变量不存在于当前方法的局部变量表中！！static随类的加载已经加载，this是实例对象。在后面
// System.out.println(this.count);
}
//关于Slot的使用的理解
public LocalVariablesTest() {
this.count = 1;
}
public void test1() {
Date date = new Date();
String name1 = "atguigu.com";
test2(date, name1);
System.out.println(date + name1);
}
public String test2(Date dateP, String name2) {
dateP = null;
name2 = "songhongkang";
double weight = 130.5;//占据两个slot
char gender = '男';
return dateP + name2;
}
public void test3() {
this.count++;
}
public void test4() {
int a = 0;
{
int b = 0;
b = a + 1;
}
//变量c使用之前已经销毁的变量b占据的slot的位置
int c = a + 1;
}
/*
变量的分类：按照数据类型分：① 基本数据类型 ② 引用数据类型
按照在类中声明的位置分：① 成员变量：在使用前，都经历过默认初始化赋值
类变量： linking的prepare阶段：给类变量默认赋值 ---> initial阶段：给类变量显式赋值即静态代码块赋值
实例变量：随着对象的创建，会在堆空间中分配实例变量空间，并进行默认赋值
② 局部变量：在使用前，必须要进行显式赋值的！否则，编译不通过
*/
public void test5Temp() {
int num;
//System.out.println(num);//错误信息：变量num未进行初始化
}
}
复制代码什么是槽slot
局部变最表是一组变量值存储空间，用于存放方法参数和方法内部定义的局部变量。在 Java程序被编译为 Class文件时，就在方法的 Code属性的max_locals数据项中确定了该方法所需要分配的最大局部变量表的容量。
局部变量表的容量以变量槽（variable slot，下称slot）为最小单位，虚拟机规范中并没有明确指明一个slot应占用的内存空间大小，只是很有“导向性”地说明每个slot都应该能存放一个boolean、byte、char、short、int、float、reference或returnAddress类型的数据，这种描述与明确指出“每个slot占用32位长度的内存空间”有一些差别，它允许slot的长度随着处理器、操作系统或虚拟机的不同而发生变化。不过无论如何，即使在64位虚拟机中使用了64位长度的内存空间来实现一个slot，虚拟机仍要使用对齐和补白的手段让slot在外观上看起来与32位虚拟机中的一致。
一个slot可以存放一个32位以内的数据类型，Java中占用32位以内的数据类型有boolean、byte、char、short、int、float、refcrcnce和retumAddress八种类型
referencc是对象的引用。虚拟机规范既没有说明它的长度，也没有明确指出这个引用应有怎样的结构，但是一般来说，虚拟机实现至少都应当能从此引用中直接或间接地查找到对象在Java堆中的起始地址索引和方法区中的对象类型数据。而：etumAddress是为字节码指令jsr、jsr_w和ret服务的，它指向了一条字节码指令的地址。
对于64位的数据类型，虚拟机会以高位在前的方式为其分配两个连续的slot空间。Java语言中明确规定的64位的数据类型只有long和double两种（reference类型则可能是32位也可能是64位）。值得一提的是，这里把long和double数据类型分割存储的做法与“long和double的非原子性协定”中把一次long和double数据类型读写分割为两次32位读写的做法类似，读者阅读到Java内存模型时可以对比一下。不过，由于局部变量表建立在线程的堆栈上，是线程私有的数据，无论读写两个连续的 slot 是否是原子操作，都不会引起数据安全问题。
虚拟机通过索引定位的方式使用局部变量表，索引值的范围是从0开始到局部变量表最大的slot数量。如果是32位数据类型的变量，索引n就代表了使用第n个slot, 如果是64位数据类型的变量，则说明要使用第n和第n+l两个slot。在方法执行时，虚拟机是使用局部变量表完成参数值到参数变量列表的传递过程的，如果是实例方法（非 static的方法），那么局部变量表中第0位索引的slot默认是用于传递方法所属对象实例的引用，在方法中可以通过关键字“this”来访问这个隐含的参数。其余参数则按照参数表的顺序来排列，占用从1开始的局部变量slot，参数表分配完毕后，再根据方法体内部定义的变量顺序和作用域分配其余的slot。
局部变量表中的slot是可重用的，方法体中定义的变量，其作用域并不一定会覆盖整个方法体，如果当前字节码PC计数器的值已经超出了某个变量的作用域，那么这个变量对应的slot就可以交给其他变量使用。这样的设计不仅仅是为了节省栈空间，在某些情况下slot的复用会直接影响到系统的垃圾收集行为。
槽slot结构和特点
- 参数值的存放总是在局部变量数组的index0开始，到数组长度-1的索引结束
- 局部变量表，最基本的存储单元是Slot(变量槽)
- 局部变量表中存放编译期可知的各种基本数据类型（8种），引用类型（reference），returnAddress类型的变量。
- 在局部变量表里，32位以内的类型只占用一个slot（包括returnAddress类型），64位的类型（long和double）占用两个slot。
- byte、short、char、float在存储前被转换为int，boolean也被转换为int，0表示false，非0表示true；
- long和double则占据两个slot。
- JVM会为局部变量表中的每一个slot都分配一个访问索引，通过这个索引即可成功访问到局部变量表中指定的局部变量值
- 当一个实例方法被调用的时候，它的方法参数和方法体内部定义的局部变量将会按照声明顺序被复制到局部变量表中的每一个slot上
- 如果需要访问局部变量表中一个64bit的局部变量值时，只需要使用前一个索引即可。（比如：访问long或者double类型变量）
- 如果当前帧是由构造方法或者实例方法创建的（意思是当前帧所对应的方法是构造器方法或者是普通的实例方法）,那么该对象引用this将会存放在index为0的slot处,其余的参数按照参数表顺序排列。
- 静态方法中不能引用this，是因为静态方法所对应的栈帧当中的局部变量表中不存在this
- slot的数量保持不变,编译期就知道最大局部变量表的容量。
槽slot的重复利用
栈帧中的局部变量表中的槽位是可以重复利用的，如果一个局部变量过了其作用域，那么在其作用域之后申明的新的局部变量就很有可能会复用过期局部变量的槽位，从而达到节省资源的目的。
字节码判断局部变量作用域
例如：局部变量a
起始PC：2
长度：7
起始PC=2=源码的8行=System.out.println(a);
即从定义了a后，a的作用域从源码8行开始有效，直到指令号为2+7=9=int b = 0;都是有效的
操作数栈(或表达式栈)-Operand Stack
-
每一个独立的栈帧中除了包含局部变量表以外，还包含一个后进先出(Last-In-First-Out)的操作数栈，也可以称之为表达式栈(Expression Stack) 。
-
操作数栈，在方法执行过程中，根据字节码指令，往栈中写入数据或提取数据，即入栈(push)/出栈(pop)。
- 某些字节码指令将值压入操作数栈，其余的字节码指令将操作数取出栈。使用它们后再把结果压入栈。
- 比如:执行复制、交换、求和等操作
-
如果被调用的方法带有返回值的话，其返回值将会被压入当前栈帧的操作数栈中，并更新PC寄存器中下一条需要执行的字节码指令。
-
操作数栈中元素的数据类型必须与字节码指令的序列严格匹配，这由编译器在编译器期间进行验证，同时在类加载过程中的类检验阶段的数据流分析阶段要再次验证。
-
另外，我们说Java虚拟机的解释引擎是基于栈的执行引擎，其中的栈指的就是操作数栈。
-
操作数栈，主要用于保存计算过程的中间结果，同时作为计算过程中变量临时的存储空间。
-
操作数栈就是JVM执行引擎的一个工作区，当一个方法刚开始执行的时候，一个新的栈帧也会随之被创建出来，这个方法的操作数栈是空的。
-
每一个操作数栈都会拥有一个明确的栈深度用于存储数值，其所需的最大深度在编译期就定义好了，保存在方法的Code属性中，为max_stack的值。
-
栈中的任何一个元素都是可以任意的Java数据类型。
- 32bit的类型占用一个栈单位深度
- 64bit的类型占用两个栈单位深度
-
操作数栈并非采用访问索引的方式来进行数据访问的，而是只能通过标准的入栈(push)和出栈(pop)操作来完成一次数据访问。
当一个方法刚刚开始执行时，其操作数栈是空的，随着方法执行和字节码指令的执行，会从局部变量表或对象实例的字段中复制常量或变量写入到操作数栈，再随着计算的进行将栈中元素出栈到局部变量表或者返回给方法调用者，也就是出栈/入栈操作。一个完整的方法执行期间往往包含多个这样出栈/入栈的过程。
虚拟机栈和操作数栈区别
- 虚拟机栈是由栈帧组成，一个栈帧对应一个方法调用。
- 操作数栈是栈帧的一部分，负责一个栈帧内的指令入栈(push)/出栈(pop)。如一个方法内的两个数求和等操作。
字节码指令分析
JVM中 int 类型数值，根据 取值范围将 入栈的 字节码指令 就分为4类：
-
取值 -1~5 采用
iconst指令； -
取值 -128~127 采用
bipush指令； -
取值 -32768~32767 采用
sipush指令； -
取值 -2147483648~2147483647 采用
ldc指令。
更多介绍访问字节码指令介绍网址：
docs.oracle.com/javase/spec…
public void testAddOperation() {
//byte、short、char、boolean：都以int型来保存
byte i = 15;
int j = 8;
int k = i + j;
// int m = 800;
}
复制代码使用jclasslib插件或反编译class文件（ javap -v xxx.class） 进行反编译，得到 class 反编译后的文件。
字节码指令如下：
0 bipush 15 //第一个指令：操作数栈入栈15
2 istore_1 //将int类型的值从操作数栈出栈存储到局部变量表 第2个槽位置(0为this)
3 bipush 8 //操作数栈入栈8
5 istore_2 //然后将int类型的值从操作数栈出栈存储到局部变量表 第3个槽位置
6 iload_1 //加载局部变量第2个槽位值压入操作数栈
7 iload_2 //加载局部变量第3个槽位值压入操作数栈
8 iadd //操作数栈中出栈两个数相加再入栈
9 istore_3 //然后将int类型的值从操作数栈出栈存储到局部变量表 第4个槽位置(即是k的值)
10 return //方法结束返回
复制代码注意：
- 从局部变量表篇章知道非静态方法第一个槽位为this。所以istore_0 = this
- PC寄存器（程序计数器）指针也会相应变化
栈顶缓存技术
-
前面提过，基于栈式架构的虚拟机所使用的零地址指令更加紧凑，但完成一项操作的时候必然需要使用更多的入栈和出栈指令，这同时也就意味着将需要更多的指令分派(instruction dispatch) 次数和内存读/写次数。
-
由于操作数是存储在内存中的，因此频繁地执行内存读/写操作必然会影响执行速度。为了解决这个问题，HotSpot JVM的设计者们提出了栈顶缓存(ToS，Top-of-Stack Cashing)技术，将栈项元素全部缓存在物理CPU的寄存器中，以此降低对内存的读/写次数，提升执行引擎的执行效率。
动态链接(或执行运行时常量池的方法引用)-Dynamic Linking
-
每一个栈帧内部都包含一个指向运行时常量池中该栈帧所属方法的引用。包含这个引用的目的就是为了支持当前方法的代码能够实现动态链接(Dynamic Linking)。比如: invokedynamic指令
-
在Java源文件被编译到字节码文件中时，所有的变量和方法引用都作为符号引用(Symbolic Reference) 保存在class文件的常量池里(还没有解析成（链接阶段-解析阶段）运行时常量池的直接引用)。
比如:描述一个方法调用了另外的其他方法时，就是通过常量池中指向方法的符号引用来表示的，那么动态链接的作用就是为了将这些符号引用转换为调用方法的直接引用。转换过程在：链接阶段-解析阶段
静态链接和动态链接区别
在JVM中，将符号引用转换为调用方法的直接引用与方法的绑定机制相关。
- 静态链接:
当一个字节码文件被装载进JVM内部时，如果被调用的目标方法在编译期可知,且运行期保持不变时。这种情况下将调用方法的符号引用转换为直接引用的过程称之为静态链接。
- 动态链接:
如果被调用的方法在编译期无法被确定下来，也就是说，只能够在程序运行期将调用方法的符号引用转换为直接引用，由于这种引用转换过程具备动态性，因此也就被称之为动态链接。
早期绑定和晚期绑定区别
静态链接和动态链接对应的方法的绑定机制为:早期绑定(Early Binding) 和晚期绑定(Late Binding)。绑定是一个字段、方法或者类在符号引用被替换为直接引用的过程，这仅仅发生一次。
- 早期绑定
早期绑定就是指被调用的目标方法如果在编译期可知，且运行期保持不变时,即可将这个方法与所属的类型进行绑定，这样一来，由于明确了被调用的目标方法究竟是哪-一个，因此也就可以使用静态链接的方式将符号引用转换为直接引用。
- 晚期绑定
如果被调用的方法在编译期无法被确定下来，只能够在程序运行期根据实际的类型绑定相关的方法，这种绑定方式也就被称之为晚期绑定。
虚方法和非虚方法区别
- 背景
随着高级语言的横空出世，类似于Java- -样的基于面向对象的编程语言如今越来越多，尽管这类编程语言在语法风格上存在一-定的差别，但是它们彼此之间始终保持着一个共性，那就是都支持封装、继承和多态等面向对象特性，既然这一类的编程语言具备多态特性，那么自然也就具备早期绑定和晚期绑定两种绑定方式。
Java中任何一个普通的方法其实都具备虛函数的特征，它们相当于C++语言中的虚函数(C++中则需要使用关键virtual来显式定义)。如果在Java程序中不希望某个方法拥有虛函数的特征时，则可以使用关键字final来标记这个方法。
- 非虚方法:
- 如果方法在编译期就确定了具体的调用版本，这个版本在运行时是不可变的。这样的方法称为非虚方法。
- 静态方法、私有方法、final方法、实例构造器、父类方法都是非虚方法。
- 其他方法称为虚方法。
虚拟机中提供了以下几条方法调用指令:
- 普通调用指令:
- invokestatic: 调用静态方法，解析阶段确定唯一方法版本
- invokespecial: 调用init方法(构造方法)、私有及父类方法，解析阶段确定唯一方法版本
- invokevirtual: 调用所有虛方法
- invokeinterface:调用接口方法
- 动态调用指令:
- invokedynamic:动态解析出需要调用的方法，然后执行
前四条指令固化在虚拟机内部，方法的调用执行不可人为干预，而invokedynamic指令则支持由用户确定方法版本。其中invokestatic指令和invokespecial指令调用的方法称为非虚方法，其余的(final修饰的除外)称为虚方法。
invokedynamic指令
JVM字节码指令集一直比较稳定，一直到Java7中才增加了一个invokedynamic指令，这是Java为了实现「动态类型语言」支持而做的一种改进。
但是在Java7中并没有提供直接生成invokedynamic指令的方法，需要借助ASM这种底层字节码工具来产生invokedynamic指令。直到Java8的Lambda表达式的出现，invokedynamic指令的生成，在Java中才有了直接的生成方式。
Java7中增加的动态语言类型支持的本质是对Java虚拟机规范的修改，而不是对Java语言规则的修改，这一块相对来讲比较复杂，增加了虚拟机中的方法调用，最直接的受益者就是运行在Java平台的动态语言的编译器。
静态语言和动态语言区别
动态类型语言和静态类型语言两者的区别就在于对类型的检查是在编译期还是在运行期，满足前者就是静态类型语言，反之是动态类型语言。
说的再直白一点就是，静态类型语言是判断变量自身的类型信息;动态类型语言是判断变量值的类型信息，变量没有类型信息，变量值才有类型信息（即是根据值确定变量类型），这是动态语言的一个重要特征。
类似强类型语言（java）和弱类型语言（js）
重写的本质
Java语言中方法重写的本质:
- 找到操作数栈项的第一个元素所执行的对象的实际类型，记作C.
- 如果在过程结束;如果不通类型C中找到与常量中的描述符合简单名称都相符的方法则进行访问权限校验，如果通过则返回这个方法的直接引用，查找过，则返回java.lang.IllegalAccessError异常。
- 否则，按照继承关系从下往上依次对C的各个父类进行第2步的搜索和验证过程。
- 如果始终没有找到合适的方法，则抛出java.lang.AbstractMethodError异常。
IllegalAccessError介绍:
程序试图访问或修改一个属性或调用一个方法，这个属性或方法，你没有权限访问。一般的，这个会引起编译器异常。这个错误如果发生在运行时，就说明一个类发生了不兼容的改变。
子类对象的多态性的使用前提:
- 类的继承关系
- 方法的重写
虚方法表
在面向对象的编程中，会很频繁的使用到动态分派，如果在每次动态分派的过程中都要重新在类的方法元数据中搜索合适的目标的话就可能影响到执行效率。因此，为了提高性能，JVM采用在类的方法区建立一个虚方法表(virtual method table) (非虛方法不会出现在表中)来实现。使用索引表来代替查找。
- 每个类中都有一个虚方法表，表中存放着各个方法的实际入口。
那么虚方法表什么时候被创建?
- 虚方法表会在类加载的链接阶段被创建并开始初始化，类的变量初始值准备完成之后，JVM会把该类的方法表也初始化完毕。
虚方法例子介绍
/**
* 虚方法表的举例
*
*/
interface Friendly {
void sayHello();
void sayGoodbye();
}
class Dog {
public void sayHello() {
}
@Override
public String toString() {
return "Dog";
}
}
class Cat implements Friendly {
public void eat() {
}
@Override
public void sayHello() {
}
@Override
public void sayGoodbye() {
}
@Override
protected void finalize() {
}
@Override
public String toString() {
return "Cat";
}
}
class CockerSpaniel extends Dog implements Friendly {
@Override
public void sayHello() {
super.sayHello();
}
@Override
public void sayGoodbye() {
}
}
复制代码Cat类虚方法表
Dog类虚方法表
CockerSpanielg类虚方法表
总结：
虚方法表建立是为了提高程序的执行效率。通过建立虚方法表。使得重写的方法的直接引用指向子类的重写方法的地址。继承的方法指向父类方法的地址，不再层层向上判断是否有该方法如：子类里边找不到一个方法索，那么jvm会直接去父类查找方法，不需要重新在父类里边遍历了。
方法返回地址（或方法正常退出或者异常退出的定义）-Return Adress
-
存放调用该方法的pc寄存器的值。
-
一个方法的结束，有两种方式:
-
- 正常执行完成
-
- 出现未处理的异常，非正常退出
-
-
无论通过哪种方式退出，在方法退出后都返回到该方法被调用的位置。方法正常退出时，调用者的pc计数器的值作为返回地址，即调用该方法的指令的下一条指令的地址。而通过异常退出的，返回地址是要通过异常表来确定，栈帧中一般不会保存这部分信息。
正常完成出口
执行引擎遇到任意一个方法返回的字节码指令(return) ，会有返回值传递给上层的方法调用者，简称正常完成出口;
-
一个方法在正常调用完成之后究竟需要使用哪一个返回指令还需要根据方法返回值的实际数据类型而定。
-
在字节码指令中，返回指令包含
- ireturn：当返回值是boolean,byte,char,short和int类型时使用
- lreturn：返回值为long
- freturn：返回值为float
- dreturn：返回值为double
- areturn：返回值为引用类
- return：供声明为void的方法、实例初始化方法、类和接口的初始化方法使用。
异常完成出口
在方法执行的过程中遇到了异常(Exception) ，并且这个异常没有在方法内进行处理，也就是只要在本方法的异常表中没有搜索到匹配的异常处理器，就会导致方法退出。简称异常完成出口。
- 方法执行过程中抛出异常时的异常处理，存储在一个异常处理表，方便在发生异常的时候找到处理异常的代码。
本质上，方法的退出就是当前栈帧出栈的过程。此时，需要恢复上层方法的局部变量表、操作数栈、将返回值压入调用者栈帧的操作数栈、设置PC寄存器值等，让调用者方法继续执行下去。正常完成出口和异常完成出口的区别在于:通过异常完成出口退出的不会给他的上层调用者产生任何的返回值。
异常结构图
- Error： 不应该捕获的异常，此时程序已经无法恢复，需要终止线程，或者终止虚拟机。
- Exception: 可能需要捕获，并且处理的异常。
- RuntimeException： 运行时异常，非检查型异常(Error也是非检查型异常)
- 其他Exception子类：检查型异常，需要代码中显式捕获。或者方法用
throws标记
- JVM是如何捕获异常的
- 编译而成的字节码中，每个方法都附带一个异常表。
- 异常表中每一个条目代表一个异常处理器
- 触发异常时，JVM会遍历异常表，比较触发异常的字节码的索引值是否在异常处理器的from指针到to指针的范围内。
- 范围匹配后，会去比较异常类型和异常处理器中的type是否相同。
- 类型匹配后，会跳转到target指针所指向的字节码(catch代码块的开始位置)
- 如果没有匹配到异常处理器，会弹出当前方法对应的Java栈帧，并对调用者重复上述操作。
- 异常处理表
| from | to | target | type |
|---|---|---|---|
| 0 | 3 | 6 | IOException |
| 0 | 3 | 11 | Exception |
- 什么是异常处理器？其组成部分有哪些？
- 异常处理器由from指针、to指针、target指针，以及所捕获的异常类型所构成(type)。
- 这些指针的数值就是字节码的索引(bytecode index, bci),可以直接去定位字节码。
- from指针和to指针，标识了该异常处理器所监控的返回
- target指针，指向异常处理器的起始位置。如catch代码块的起始位置
- type：捕获的异常类型，如Exception
- 如果在方法的异常表中没有匹配到异常处理器，会怎么样？
- 会弹出当前方法对应的Java栈帧
- 在调用者上重复异常匹配的流程。
- 最坏情况下，JVM需要编译当前线程Java栈上所有方法的异常表
- finally代码块是如何去实现的？
- 在编译阶段对finally代码块进行处理
- 当前版本Java编译器的做法，是复制finally代码块的内容，分别放到所有正常执行路径，以及异常执行路径的出口中。
- finally代码块
public class Test {
// 便于查看字节码
private int tryBlock;
private int catchBlock;
private int finallyBlock;
private int methodExit;
public void test(){
try {
tryBlock = 0;
}catch (Exception e){
catchBlock = 1;
}finally {
finallyBlock = 2;
}
methodExit = 3;
}
}
复制代码查看字节码指令：javap -v Test.class
0: aload_0
1: iconst_0
2: putfield #2 // Field tryBlock:I
5: aload_0
6: iconst_2
7: putfield #3 // Field finallyBlock:I
10: goto 35
13: astore_1
14: aload_0
15: iconst_1
16: putfield #5 // Field catchBlock:I
19: aload_0
20: iconst_2
21: putfield #3 // Field finallyBlock:I
24: goto 35
27: astore_2
28: aload_0
29: iconst_2
30: putfield #3 // Field finallyBlock:I
33: aload_2
34: athrow
35: aload_0
36: iconst_3
37: putfield #6 // Field methodExit:I
40: return
Exception table:
from to target type
0 5 13 Class java/lang/Exception
0 5 27 any
13 19 27 any
复制代码有三份finally代码块
- 第一份复制的finally代码块，位于try代码后。try代码块出现异常跳转到catch代码块，如果catch无法捕获，会跳转到最后一份finally代码块。
- 第二份复制的finally代码块，位于catch代码后。catch代码块出现异常会跳转到最后一份finally代码块。
- 最后一份finally代码块，位于异常执行路径，运行完后，抛出any异常。try和catch代码块中的finally代码块，如果出现了异常，也会直接抛出any异常。
- javap中用any代指所有种类的异常。
jclasslib插件查看
-
起始PC=from
-
结束PC=to
-
跳转PC=target
-
捕获类型=type
-
form 0 到 to 5指令之前如运行异常为Exception，跳转到目标13指令（catchBlock = 1;）
-
form 0 到 to 5指令之前如运行异常不为Exception，跳转到目标27指令（finallyBlock = 2;）
-
。。。
附加信息
栈帧中还允许携带与Java虚拟机实现相关的一些附加信息。例如，对程序调试提供支持的信息。一般大多数博客介绍都只是上面四种结构。附加信息这里不再详说。
栈的调优思路
- 问题
- 举例栈溢出的情况? (StackOverflowError)
递归超过栈深度，通过-Xss设置栈的大小; 如果是动态分配栈内存，超过了栈内存，还会存在00M问题。
- 调整栈大小，就能保证不出现溢出吗?
不能，只能是延迟栈溢出的时间，不能从根本上解决问题，应该优化代码逻辑顺序。
- 分配的栈内存越大越好吗?
不是!分配栈内存越大，每个线程得到内存越大，虚拟机一定资源下，相应的线程数也就减少。虚拟机整体并发下降，分配过多内存没有使用也是浪费。
- 垃圾回收是否会涉及到虚拟机栈?
不会的!虚拟机栈是线程私有，伴随着栈帧出栈，内存也就等到了回收。
- 方法中定义的局部变量是否线程安全?
具体问题具体分析，不一定是安全的，除了一些对象引用外逃（逃逸分析）会造成局部变量线程不安全问题。
- 调优
在栈帧中，与性能调优关系最为密切的部分就是局部变量表。在方法执行时，虚拟机使用局部变量表完成方法的传递
局部变量表中的变量也是重要的垃圾回收根节点，只要被局部变量表中直接或间接引用的对象都不会被回收
局部变量表因是线程私有，可在运行结束后回收。对于代码编写方便性和可阅读性等适当取舍调整即可。
拾遗-变量分类
- 按照数据类型分：
-
基本数据类型
-
引用数据类型
- 按照在类中声明的位置分：
- 成员变量：在使用前，都经历过默认初始化赋值
static修饰：类变量：类加载linking的准备阶段给类变量默认赋值——>初始化阶段给类变量显式赋值即静态代码块赋值；
不被static修饰：实例变量：随着对象的创建，会在堆空间分配实例变量空间，并进行默认赋值
- 局部变量：在使用前，必须要进行显式赋值的！否则，编译不通过
深入理解JVM系列
- 1.深入理解JVM（一）一一 简介和体系结构
- 2.深入理解JVM（二）一一 类加载器子系统
- 3.深入理解JVM（三）一一 运行时数据区（虚拟机栈）
- 4.深入理解JVM（四）一一 运行时数据区（程序计数器+本地方法栈）
- 5.深入理解JVM（五）一一 运行时数据区（堆）
- 6.深入理解JVM（六）一一 运行时数据区（方法区）
- 7.深入理解JVM（七）一一 执行引擎（解释器和JIT编译器）
- 8.深入理解JVM（八）一一 字符串常量池
- 9.深入理解JVM（九）一一 对象实例化和内存布局
- 10.深入理解JVM（十）一一 字节码层面剖析程序执行过程
- 11.深入理解JVM（十一）一一 垃圾回收相关概念
- 12.深入理解JVM（十二）一一 垃圾回收相关算法
- 13.深入理解JVM（十三）一一 详解垃圾回收器
- 14.深入理解JVM（十四）一一 对象分布图
- 15.深入理解JVM（十五）一一 class文件结构
- 16.深入理解JVM（十六）一一 字节码指令集
- 17.深入理解JVM（十七）一一 类的生命周期详解
- 18.深入理解JVM（十八）一一 再谈类的加载器
- 19.深入理解JVM（十九）一一 JVM监控及诊断工具(命令行）
- 20.深入理解JVM（二十）一一 JVM监控及诊断工具(GUI)
- 21.深入理解JVM（二十一）一一 JVM运行时参数(收藏篇)
- 22.深入理解JVM（二十二）一一 分析GC日志
- 23.深入理解JVM（二十三）一一 OOM场景及解决方案
近期评论