虚拟机栈
...大约 32 分钟JVMJVM上篇
[TOC]
虚拟机栈
概述
Java 虚拟机栈是描述 Java 方法运行过程的内存模型。
Java 虚拟机栈会为每一个即将运行的 Java 方法创建一块叫做“栈帧”的区域，用于存放该方法运行过程中的一些信息，如：
- 局部变量表
- 操作数栈
- 动态链接
- 方法出口信息
- ......
内存中的栈和堆
- 首先栈是运行时的单位，而堆是存储的单位。
- 即：栈解决程序的运行问题，即程序如何执行，或者说如何处理数据。堆解决的是数据存储的问题，即数据怎么放，放哪里
基本内容
Java虚拟机栈是什么？
- Java虚拟机栈（Java Virtual Machine Stack），早期也叫Java栈。每个线程在创建时都会创建一个虚拟机栈，其内部保存一个个的栈帧（Stack Frame），对应着一次次的Java方法调用，栈是线程私有的
public class StackTest {
public static void main(String[] args) {
StackTest test = new StackTest();
test.methodA();
}
public void methodA() {
int i = 10;
int j = 20;
methodB();
}
public void methodB(){
int k = 30;
int m = 40;
}
}
- 虚拟机栈的生命周期
- 生命周期和线程一致，也就是线程结束了，该虚拟机栈也销毁了
- 虚拟机栈的作用
- 主管Java程序的运行，它保存方法的局部变量（8 种基本数据类型、对象的引用地址）、部分结果，并参与方法的调用和返回。
- 局部变量 vs 成员变量来说的（或属性）
- 基本数据类型变量 vs 引用类型变量（类、数组、接口）
特点
运行速度特别快,仅仅次于 PC 寄存器。
局部变量表随着栈帧的创建而创建，它的大小在编译时确定，创建时只需分配事先规定的大小即可。在方法运行过程中，局部变量表的大小不会发生改变。
Java 虚拟机栈会出现两种异常：StackOverFlowError 和 OutOfMemoryError。
- StackOverFlowError 若 Java 虚拟机栈的大小不允许动态扩展，那么当线程请求栈的深度超过当前 Java 虚拟机栈的最大深度时，抛出 StackOverFlowError 异常。
- OutOfMemoryError 若允许动态扩展，那么当线程请求栈时内存用完了，无法再动态扩展时，抛出 OutOfMemoryError 异常。* Java 虚拟机栈也是线程私有，随着线程创建而创建，随着线程的结束而销毁。
出现 StackOverFlowError 时，内存空间可能还有很多。
对于栈来说不存在垃圾回收问题
- 栈不需要GC，但是可能存在OOM
JVM直接对Java栈的操作只有两个：
- 每个方法执行，伴随着进栈（入栈、压栈）
- 执行结束后的出栈工作
面试题：栈中可能出现的异常？
- Java 虚拟机规范允许Java栈的大小是动态的或者是固定不变的。
- 如果采用固定大小的Java虚拟机栈，那每一个线程的Java虚拟机栈容量可以在线程创建的时候独立选定。如果线程请求分配的栈容量超过Java虚拟机栈允许的最大容量，Java虚拟机将会抛出一个StackoverflowError 异常。
- 如果Java虚拟机栈可以动态扩展，并且在尝试扩展的时候无法申请到足够的内存，或者在创建新的线程时没有足够的内存去创建对应的虚拟机栈，那Java虚拟机将会抛出一个 OutofMemoryError 异常。
设置栈内存大小
概念
官方文档：https://docs.oracle.com/en/java/javase/11/tools/java.html#GUID-3B1CE181-CD30-4178-9602-230B800D4FAE
我们可以使用参数 -Xss 选项来设置线程的最大栈空间，栈的大小直接决定了函数调用的最大可达深度。
Sets the thread stack size (in bytes). Append the letter `k` or `K` to indicate KB, `m` or `M` to indicate MB, and `g` or `G` to indicate GB. The default value depends on the platform:
* Linux/x64 (64-bit): 1024 KB
* macOS (64-bit): 1024 KB
* Oracle Solaris/x64 (64-bit): 1024 KB
* Windows: The default value depends on virtual memory
示例
// 演示栈中异常：StackOverflowError
// Exception in thread "main" java.lang.StackOverflowError
public class StackErrorTest {
public static void main(String[] args) {
main(args);
}
}
如何测试XSS参数
public class StackErrorTest {
private static int count = 1;
public static void main(String[] args) {
System.out.println(count);
count++;
main(args);
}
}
本台电脑默认执行了：11411次
11409
11410
11411
*** java.lang.instrument ASSERTION FAILED ***: "!errorOutstanding" with message transform method call failed at JPLISAgent.c line: 844
设置了-Xss256k的VM Option后：执行了2469次
2466
2467
2468
2469
*** java.lang.instrument ASSERTION FAILED ***: "!errorOutstanding" with message transform method call failed at JPLISAgent.c line: 844
栈的存储结构
存储什么？
- 每个线程都有自己的栈，栈中的数据都是以栈帧（Stack Frame）的格式存在
- 在这个线程上正在执行的每个方法都各自对应一个栈帧（Stack Frame）。
- 栈帧是一个内存区块，是一个数据集，维系着方法执行过程中的各种数据信息。
运行原理
- JVM直接对Java栈的操作只有两个，就是对栈帧的压栈和出栈，遵循先进后出（后进先出）原则
- 在一条活动线程中，一个时间点上，只会有一个活动的栈帧。即只有当前正在执行的方法的栈帧（栈顶栈帧）是有效的。这个栈帧被称为当前栈帧（Current Frame），与当前栈帧相对应的方法就是当前方法（Current Method），定义这个方法的类就是当前类（Current Class）
- 执行引擎运行的所有字节码指令只针对当前栈帧进行操作。
- 如果在该方法中调用了其他方法，对应的新的栈帧会被创建出来，放在栈的顶端，成为新的当前帧
- 不同线程中所包含的栈帧是不允许存在相互引用的，即不可能在一个栈帧之中引用另外一个线程的栈帧。
- 如果当前方法调用了其他方法，方法返回之际，当前栈帧会传回此方法的执行结果给前一个栈帧，接着，虚拟机会丢弃当前栈帧，使得前一个栈帧重新成为当前栈帧。
- Java方法有两种返回函数的方式。
- 一种是正常的函数返回，使用return指令。
- 另一种是方法执行中出现未捕获处理的异常，以抛出异常的方式结束。
- 但不管使用哪种方式，都会导致栈帧被弹出。
理解栈帧
public class StackFrameTest {
public static void main(String[] args) {
StackFrameTest test = new StackFrameTest();
test.method1();
}
public void method1() {
System.out.println("method1开始执行....");
method2();
System.out.println("method1执行结束....");
}
private int method2() {
System.out.println("method2开始执行....");
int i = 10;
method3();
System.out.println("method2即将结束....");
return i;
}
private double method3() {
System.out.println("method3开始执行....");
double j = 20.0;
System.out.println("method3执行结束....");
return j;
}
}
- 如果正常执行，如果下图所示，就会把当前方法压入栈中，当执行到方法3的时候，当前栈帧就指向方法3（method3）
- 如果方法3出现异常，就会抛出异常给方法2，如果方法2也没有处理异常的函数，就会抛给方法1以此类推（具体操作见下面的代码）
public class StackFrameTest {
public static void main(String[] args) {
StackFrameTest test = new StackFrameTest();
test.method1();
System.out.println("main()正常结束");
}
public void method1() {
System.out.println("method1开始执行....");
method2();
System.out.println("method1执行结束....");
}
private int method2() {
System.out.println("method2开始执行....");
int i = 10;
method3();
System.out.println("method2即将结束....");
System.out.println(10 / 0);
return i;
}
private double method3() {
System.out.println("method3开始执行....");
double j = 20.0;
System.out.println("method3执行结束....");
return j;
}
}
method1开始执行....
method2开始执行....
method3开始执行....
method3执行结束....
method2即将结束....
Exception in thread "main" java.lang.ArithmeticException: / by zero
at cn.zhiyucs.java1.StackFrameTest.method2(StackFrameTest.java:22)
at cn.zhiyucs.java1.StackFrameTest.method1(StackFrameTest.java:13)
at cn.zhiyucs.java1.StackFrameTest.main(StackFrameTest.java:7)
如果是在程序的main函数内加入一个try-catch来处理异常：
public static void main(String[] args) {
try {
StackFrameTest test = new StackFrameTest();
test.method1();
} catch (Exception e) {
e.printStackTrace();
} finally {
System.out.println("main()正常结束");
}
}
method2开始执行....
method3开始执行....
method3执行结束....
method2即将结束....
main()正常结束
java.lang.ArithmeticException: / by zero
如果方法都是正常结束的：可以看到
method1：void（可以在方法的返回加入return; 但一般是省略）
21: return
method2: int
25: ireturn
method3: double
21: dreturn
栈帧的内部结构
每个栈帧中存储着：
- 局部变量表（Local Variables）
- 操作数栈（Operand Stack）（或表达式栈）
- 动态链接（Dynamic Linking）（或指向运行时常量池的方法引用）
- 方法返回地址（Return Address）（或方法正常退出或者异常退出的定义）
- 一些附加信息
局部变量表
概念
- 定义为一个数字数组，主要用于存储方法参数、定义在方法体内部的局部变量，数据类型包括各类基本数据类型，对象引用，以及 return address 类型。
- 局部变量表容量大小是在编译期确定下来的。最基本的存储单元是 slot，32 位占用一个 slot，64 位类型（long 和 double）占用两个 slot。
- 定义为一个数字数组，主要用于存储方法参数和定义在方法体内的局部变量，这些数据类型包括各类基本数据类型、对象引用（reference），以及returnAddress返回值类型。
- 由于局部变量表是建立在线程的栈上，是线程的私有数据，因此不存在数据安全问题
- 方法嵌套调用的次数由栈的大小决定。一般来说，栈越大，方法嵌套调用次数越多。
- 对一个函数而言，它的参数和局部变量越多，使得局部变量表膨胀，它的栈帧就越大，以满足方法调用所需传递的信息增大的需求。
- 进而函数调用就会占用更多的栈空间，导致其嵌套调用次数就会减少。
- 局部变量表中的变量只在当前方法调用中有效。
- 在方法执行时，虚拟机通过使用局部变量表完成参数值到参数变量列表的传递过程。
- 当方法调用结束后，随着方法栈帧的销毁，局部变量表也会随之销毁。
例如这样一个示例：
public class LocalVariablesTest {
private int count = 0;
public static void main(String[] args) {
LocalVariablesTest test = new LocalVariablesTest();
int num = true;
test.test1();
}
public static void testStatic() {
new LocalVariablesTest();
new Date();
int count = 10;
System.out.println(count);
}
public LocalVariablesTest() {
this.count = 1;
}
public void test1() {
Date date = new Date();
String name1 = "atguigu.com";
this.test2(date, name1);
System.out.println(date + name1);
}
public String test2(Date dateP, String name2) {
dateP = null;
name2 = "songhongkang";
double weight = 130.5D;
char gender = true;
return dateP + name2;
}
public void test3() {
++this.count;
}
public void test4() {
int a = 0;
int b = false;
int c = a + 1;
c = a + 1;
}
}
通过javap -v反编译之后可以看到main函数局部变量表：
LocalVariableTable:
Start Length Slot Name Signature
0 16 0 args [Ljava/lang/String;
8 8 1 test Lcn/zhiyucs/java1/LocalVariablesTest;
11 5 2 num I
其中L表示引用，其后面的String，变量名为arg，test同理
I表示整数型，变量为其num
使用jclasslib进行详解
- 通过Code可以查看字节码
以及可以查看异常和杂项（字节码的长度、最大深度）
- 通过LineNumberTable可以查看每一个字节码指令的位置对应代码的位置
- 以及可以查看局部变量表的信息
对slot的理解
- 参数值的存放总是从局部变量数组索引 0 的位置开始，到数组长度-1的索引结束。
- 局部变量表，最基本的存储单元是Slot（变量槽），局部变量表中存放编译期可知的各种基本数据类型（8种），引用类型（reference），returnAddress类型的变量。
- 在局部变量表里，32位以内的类型只占用一个slot（包括returnAddress类型），64位的类型占用两个slot（1ong和double）。
- byte、short、char在储存前被转换为int，boolean也被转换为int，0表示false，非0表示true
- long和double则占据两个slot
- JVM会为局部变量表中的每一个Slot都分配一个访问索引，通过这个索引即可成功访问到局部变量表中指定的局部变量值
- 当一个实例方法被调用的时候，它的方法参数和方法体内部定义的局部变量将会按照顺序被复制到局部变量表中的每一个slot上
- 如果需要访问局部变量表中一个64bit的局部变量值时，只需要使用前一个索引即可。（比如：访问long或double类型变量）
- 如果当前帧是由构造方法或者实例方法创建的，那么该对象引用this将会存放在index为0的slot处，其余的参数按照参数表顺序继续排列。（this也相当于一个变量）
注：静态方法中是不可以用this的 -- 因为this变量不存在静态方法的局部变量表中
slot示例
- this存放在index=0的位置：
public void test3() {
++this.count;
}
- 64位类型，long和double占两个slot位置
public String test2(Date dateP, String name2) {
dateP = null;
name2 = "songhongkang";
double weight = 130.5D;
char gender = true;
return dateP + name2;
}
可以看到gender是5，weight是一个double在3的位置，以此就可以正面
slot重复利用
栈帧中的局部变量表中的槽位是可以重用的，如果一个局部变量过了其作用域，那么在其作用域之后申明新的局部变量变就很有可能会复用过期局部变量的槽位，从而达到节省资源的目的。
public void test4() {
int a = 0;
{
int b = 0;
b = a + 1;
}
int c = a + 1;
}
可以看到变量c是使用已销毁的变量b占据的slot的位置
静态变量与局部变量的对比
/**
* 变量的分类：按照数据类型分：1. 基本数据类型 2. 引用数据类型
* 按照在类中声明的位置分：成员变量：在使用前，都经历过默认初始化赋值
* 类变量：linking的prepare阶段：给类变量默认赋值 --> initial阶段：给类变量显式赋值即静态代码块赋值
* 实例变量：随着对象的创建会在堆空间中分配实例变量空间，并进行默认赋值
* 局部变量：在使用前，必须要进行显式赋值！否则编译不通过
*/
public void testTemp5() {
int num;
System.out.println(num); // 错误信息：变量num未进行初始化
}
- 参数表分配完毕之后，再根据方法体内定义的变量的顺序和作用域分配。
- 我们知道成员变量有两次初始化的机会**，**第一次是在“准备阶段”，执行系统初始化，对类变量设置零值，另一次则是在“初始化”阶段，赋予程序员在代码中定义的初始值。
- 和类变量初始化不同的是，局部变量表不存在系统初始化的过程，这意味着一旦定义了局部变量则必须人为的初始化，否则无法使用。
补充：
- 在栈帧中，与性能调优关系最为密切的部分就是前面提到的局部变量表。在方法执行时，虚拟机使用局部变量表完成方法的传递。
- 局部变量表中的变量也是重要的垃圾回收根节点，只要被局部变量表中直接或间接引用的对象都不会被回收。
操作数栈
特点
- 每一个独立的栈帧除了包含局部变量表以外，还包含一个后进先出（Last - In - First -Out）的 操作数栈，也可以称之为表达式栈（Expression Stack）
- 操作数栈，在方法执行过程中，根据字节码指令，往栈中写入数据或提取数据，即入栈（push）和 出栈（pop）
- 某些字节码指令将值压入操作数栈，其余的字节码指令将操作数取出栈。使用它们后再把结果压入栈，
- 比如：执行复制、交换、求和等操作
作用
- 操作数栈，主要用于保存计算过程的中间结果，同时作为计算过程中变量临时的存储空间。
- 操作数栈就是JVM执行引擎的一个工作区，当一个方法刚开始执行的时候，一个新的栈帧也会随之被创建出来，这时方法的操作数栈是空的。
- 每一个操作数栈都会拥有一个明确的栈深度用于存储数值，其所需的最大深度在编译期就定义好了，保存在方法的Code属性中，为maxstack的值。
- 栈中的任何一个元素都是可以任意的Java数据类型
- 32bit的类型占用一个栈单位深度
- 64bit的类型占用两个栈单位深度
- 操作数栈并非采用访问索引的方式来进行数据访问的，而是只能通过标准的入栈和出栈操作来完成一次数据访问。只不过操作数栈是用数组这个结构来实现的而已
- 如果被调用的方法带有返回值的话，其返回值将会被压入当前栈帧的操作数栈中，并更新PC寄存器中下一条需要执行的字节码指令。
- 操作数栈中元素的数据类型必须与字节码指令的序列严格匹配，这由编译器在编译器期间进行验证，同时在类加载过程中的类检验阶段的数据流分析阶段要再次验证。
- 另外，我们说Java虚拟机的解释引擎是基于栈的执行引擎，其中的栈指的就是操作数栈。
代码追踪
public class OperandStackTest {
public OperandStackTest() {
}
public void testAddOperation() {
byte i = 15;
int j = 8;
int var10000 = i + j;
}
}
反编译后的字节码为：
0 bipush 15
2 istore_1
3 bipush 8
5 istore_2
6 iload_1
7 iload_2
8 iadd
9 istore_3
10 return
流程解析：
PC寄存器的地址为进行调整
- bitpush 15 ： 把15放入局部变量表中
- istore_x：把其放入到操作数栈，该数的索引为x，栈顶指向该操作数
- iload_x：从局部变量表中把索引为x的变量取出来
- 此时当前的操作栈已经放入了两个数据（15、8）
- iadd：需要执行引擎给CPU进行运算
- istore_3：计算得到的23放入到操作数栈中
- return：计算结束
总结：以上的操作数栈的最大深度为2，局部变量表为4
大致思路可以联想此图
类型转换说明
- 因为 8 可以存放在 byte 类型中，所以压入操作数栈的类型为 byte ，而不是 int ，所以执行的字节码指令为 bipush 8
- 但是存储在局部变量的时候，会转成 int 类型的变量：istore_4
- m改成800之后，byte存储不了，就成了short型，sipush 800
再如一个例子：testGetSum() 方法字节码指令：一上来就加载 getSum() 方法的返回值()
public int getSum() {
int m = 10;
int n = 20;
int k = m + n;
return k;
}
public void testGetSum() {
// aload_0 获取上一个栈帧返回的结果，并保存在操作数栈中
int i = getSum();
int j = 10;
}
面试题：i++和++i的区别（字节码篇解释）
public void add() {
// 第1类问题
int i1 = 10;
i1++;
int i2 = 10;
++i2;
// 第2类问题
int i3 = 10;
int i4 = i3++;
int i5 = 10;
int i6 = ++i5;
// 第3类问题
int i7 = 10;
i7 = i7++;
int i8 = 10;
i8 = ++i8;
// 第4类问题
int i9 = 10;
int i10 = i9++ + ++i9;
}
对应字节码为：
0 bipush 10
2 istore_1
3 iinc 1 by 1
6 bipush 10
8 istore_2
9 iinc 2 by 1
12 bipush 10
14 istore_3
15 iload_3
16 iinc 3 by 1
19 istore 4
21 bipush 10
23 istore 5
25 iinc 5 by 1
28 iload 5
30 istore 6
32 bipush 10
34 istore 7
36 iload 7
38 iinc 7 by 1
41 istore 7
43 bipush 10
45 istore 8
47 iinc 8 by 1
50 iload 8
52 istore 8
54 bipush 10
56 istore 9
58 iload 9
60 iinc 9 by 1
63 iinc 9 by 1
66 iload 9
68 iadd
69 istore 10
71 return
栈顶缓存（Top Of Stack Cashing）技术
- 前面提过，基于栈式架构的虚拟机所使用的零地址指令更加紧凑，但完成一项操作的时候必然需要使用更多的入栈和出栈指令，这同时也就意味着将需要更多的指令分派（instruction dispatch）次数（也就是你会发现指令很多）和导致内存读/写次数多，效率不高。
- 由于操作数是存储在内存中的，因此频繁地执行内存读/写操作必然会影响执行速度。为了解决这个问题，HotSpot JVM的设计者们提出了栈顶缓存（Tos，Top-of-Stack Cashing）技术，将栈顶元素全部缓存在物理CPU的寄存器中，以此降低对内存的读/写次数，提升执行引擎的执行效率**。**
- 寄存器的主要优点：指令更少，执行速度快，但是指令集（也就是指令种类）很多
动态链接
概览：
- 每一个栈帧内部都包含一个指向运行时常量池中****该栈帧所属方法的引用。包含这个引用的目的就是为了支持当前方法的代码能够实现****动态链接（Dynamic Linking），比如：invokedynamic指令
- 在Java源文件被编译到字节码文件中时，所有的变量和方法引用都作为符号引用（Symbolic Reference）保存在class文件的常量池里。比如：描述一个方法调用了另外的其他方法时，就是通过常量池中指向方法的符号引用来表示的，那么动态链接的作用就是为了将这些符号引用转换为调用方法的直接引用
例如：
public class DynamicLinkingTest {
int num = 10;
public void methodA() {
System.out.println("methodA......");
}
public void methodB() {
System.out.println("methodB......");
methodA();
num++;
}
}
字节码如下：
0 getstatic #3 <java/lang/System.out : Ljava/io/PrintStream;>
3 ldc #6 <methodB......>
5 invokevirtual #5 <java/io/PrintStream.println : (Ljava/lang/String;)V>
8 aload_0
9 invokevirtual #7 <cn/zhiyucs/java1/DynamicLinkingTest.methodA : ()V>
12 aload_0
13 dup
14 getfield #2 <cn/zhiyucs/java1/DynamicLinkingTest.num : I>
17 iconst_1
18 iadd
19 putfield #2 <cn/zhiyucs/java1/DynamicLinkingTest.num : I>
22 return
- 在methodB() 方法中通过 invokevirtual #7 指令，查看下面的常量池可以看到调用了#8和#31
- #8 当前类
- #31 调用#19 #13
- #19 void
- #13 ()V
- 属性是从
getfield #2 <cn/zhiyucs/java1/DynamicLinkingTest.num : I> 调用了#8和#24- #8 当前类
- #24
- #10
- #11 Int类型
常量池如下：
Constant pool:
#1 = Methodref #9.#23 // java/lang/Object."<init>":()V
#2 = Fieldref #8.#24 // cn/zhiyucs/java1/DynamicLinkingTest.num:I
#3 = Fieldref #25.#26 // java/lang/System.out:Ljava/io/PrintStream;
#4 = String #27 // methodA......
#5 = Methodref #28.#29 // java/io/PrintStream.println:(Ljava/lang/String;)V
#6 = String #30 // methodB......
#7 = Methodref #8.#31 // cn/zhiyucs/java1/DynamicLinkingTest.methodA:()V
#8 = Class #32 // cn/zhiyucs/java1/DynamicLinkingTest
#9 = Class #33 // java/lang/Object
#10 = Utf8 num
#11 = Utf8 I
#12 = Utf8 <init>
#13 = Utf8 ()V
#14 = Utf8 Code
#15 = Utf8 LineNumberTable
#16 = Utf8 LocalVariableTable
#17 = Utf8 this
#18 = Utf8 Lcn/zhiyucs/java1/DynamicLinkingTest;
#19 = Utf8 methodA
#20 = Utf8 methodB
#21 = Utf8 SourceFile
#22 = Utf8 DynamicLinkingTest.java
#23 = NameAndType #12:#13 // "<init>":()V
#24 = NameAndType #10:#11 // num:I
#25 = Class #34 // java/lang/System
#26 = NameAndType #35:#36 // out:Ljava/io/PrintStream;
#27 = Utf8 methodA......
#28 = Class #37 // java/io/PrintStream
#29 = NameAndType #38:#39 // println:(Ljava/lang/String;)V
#30 = Utf8 methodB......
#31 = NameAndType #19:#13 // methodA:()V
#32 = Utf8 cn/zhiyucs/java1/DynamicLinkingTest
#33 = Utf8 java/lang/Object
#34 = Utf8 java/lang/System
#35 = Utf8 out
#36 = Utf8 Ljava/io/PrintStream;
#37 = Utf8 java/io/PrintStream
#38 = Utf8 println
#39 = Utf8 (Ljava/lang/String;)V
结论：通过 #7 我们就能找到需要调用的 methodA() 方法，并进行调用，在上面，其实还有很多符号引用，比如 Object、System、PrintStream 等等
为什么要用常量池呢？
- 因为在不同的方法，都可能调用常量或者方法，所以只需要存储一份即可，然后记录其引用即可，节省了空间。
- 常量池的作用：就是为了提供一些符号和常量，便于指令的识别
方法的调用
静态链接和动态链接
在JVM中，将符号引用转换为调用方法的直接引用与方法的绑定机制相关
- 静态链接：
当一个字节码文件被装载进JVM内部时，如果被调用的目标方法在编译期确定，且运行期保持不变时，这种情况下将调用方法的符号引用转换为直接引用的过程称之为静态链接
- 动态链接：
如果被调用的方法在编译期无法被确定下来，也就是说，只能够在程序运行期将调用的方法的符号转换为直接引用，由于这种引用转换过程具备动态性，因此也被称之为动态链接。
早期绑定与晚期绑定
静态链接与动态链接针对的是方法。早期绑定和晚期绑定范围更广。早期绑定涵盖了静态链接，晚期绑定涵盖了动态链接。
静态链接和动态链接对应的方法的绑定机制为：早期绑定（Early Binding）和晚期绑定（Late Binding）。绑定是一个字段、方法或者类在符号引用被替换为直接引用的过程，这仅仅发生一次。
- 早期绑定
早期绑定就是指被调用的目标方法如果在编译期可知，且运行期保持不变时，即可将这个方法与所属的类型进行绑定，这样一来，由于明确了被调用的目标方法究竟是哪一个，因此也就可以使用静态链接的方式将符号引用转换为直接引用。
- 晚期绑定
如果被调用的方法在编译期无法被确定下来，只能够在程序运行期根据实际的类型绑定相关的方法，这种绑定方式也就被称之为晚期绑定。
class Animal {
public void eat() {
System.out.println("动物进食");
}
}
interface Huntable {
void hunt();
}
class Dog extends Animal implements Huntable {
@Override
public void eat() {
System.out.println("狗吃骨头");
}
@Override
public void hunt() {
System.out.println("捕食耗子，多管闲事");
}
}
class Cat extends Animal implements Huntable {
public Cat() {
super();//表现为：早期绑定
}
public Cat(String name) {
this();//表现为：早期绑定
}
@Override
public void eat() {
super.eat();//表现为：早期绑定
System.out.println("猫吃鱼");
}
@Override
public void hunt() {
System.out.println("捕食耗子，天经地义");
}
}
public class AnimalTest {
public void showAnimal(Animal animal) {
animal.eat();//表现为：晚期绑定
}
public void showHunt(Huntable h) {
h.hunt();//表现为：晚期绑定
}
}
字节码中：
invokevirtual 体现为晚期绑定
invokeinterface 也体现为晚期绑定
invokespecial 体现为早期绑定
eat.class
0 aload_0
1 invokespecial #3 <cn/zhiyucs/java2/Animal.eat : ()V>
4 getstatic #4 <java/lang/System.out : Ljava/io/PrintStream;>
7 ldc #5 <猫吃鱼>
9 invokevirtual #6 <java/io/PrintStream.println : (Ljava/lang/String;)V>
12 return
AnimalTest.class
- showAnimal
0 aload_1
1 invokevirtual #2 <cn/zhiyucs/java2/Animal.eat : ()V>
4 return
- showHunt
0 aload_1
1 invokevirtual #2 <cn/zhiyucs/java2/Animal.eat : ()V>
4 return
多态与绑定
- 随着高级语言的横空出世，类似于Java一样的基于面向对象的编程语言如今越来越多，尽管这类编程语言在语法风格上存在一定的差别，但是它们彼此之间始终保持着一个共性，那就是都支持封装、继承和多态等面向对象特性，既然这一类的编程语言具备多态特性，那么自然也就具备早期绑定和晚期绑定两种绑定方式。
- Java中任何一个普通的方法其实都具备虚函数的特征，它们相当于C++语言中的虚函数（C++中则需要使用关键字virtual来显式定义）。如果在Java程序中不希望某个方法拥有虚函数的特征时，则可以使用关键字final来标记这个方法。
虚方法和非虚方法
- 如果方法在编译期就确定了具体的调用版本，这个版本在运行时是不可变的。这样的方法称为非虚方法。
- 静态方法、私有方法、final方法、实例构造器、父类方法都是非虚方法。
- 其他方法称为虚方法。
子类对象的多态性的使用前提（非虚方法和这里是相抵触的）：
- 类的继承关系
- 方法的重写
虚拟机中调用方法的指令
- 普通指令：
invokestatic：调用静态方法，解析阶段确定唯一方法版本
invokespecial：调用
<init>方法、私有及父类方法，解析阶段确定唯一方法版本invokevirtual：调用所有虚方法
invokeinterface：调用接口方法
- 动态调用指令
invokedynamic：动态解析出需要调用的方法，然后执行
前四条指令固化在虚拟机内部，方法的调用执行不可人为干预。而invokedynamic指令则支持由用户确定方法版本。其中invokestatic指令和invokespecial指令调用的方法称为非虚方法，其余的（final修饰的除外）称为虚方法。
class Father {
public Father() {
System.out.println("father的构造器");
}
public static void showStatic(String str) {
System.out.println("father " + str);
}
public final void showFinal() {
System.out.println("father show final");
}
public void showCommon() {
System.out.println("father 普通方法");
}
}
public class Son extends Father {
public Son() {
//invokespecial
super();
}
public Son(int age) {
//invokespecial
this();
}
//不是重写的父类的静态方法，因为静态方法不能被重写！
public static void showStatic(String str) {
System.out.println("son " + str);
}
private void showPrivate(String str) {
System.out.println("son private" + str);
}
public void show() {
//invokestatic
showStatic("atguigu.com");
//invokestatic
super.showStatic("good!");
//invokespecial
showPrivate("hello!");
//invokespecial
super.showCommon();
//invokevirtual
showFinal();//因为此方法声明有final，不能被子类重写，所以也认为此方法是非虚方法。
//虚方法如下：
/*
invokevirtual 你没有显示的加super.，编译器认为你可能调用子类的showCommon(即使son子类没有重写，也 会认为)，所以编译期间确定不下来，就是虚方法。
*/
showCommon();
info();
MethodInterface in = null;
//invokeinterface
in.methodA();
}
public void info() {
}
public void display(Father f) {
f.showCommon();
}
public static void main(String[] args) {
Son so = new Son();
so.show();
}
}
interface MethodInterface {
void methodA();
}
invokedynamic 指令
- JVM字节码指令集一直比较稳定，一直到Java7中才增加了一个invokedynamic指令，这是Java为了实现【动态类型语言】支持而做的一种改进。
- 但是在Java7中并没有提供直接生成invokedynamic指令的方法，需要借助ASM这种底层字节码工具来产生invokedynamic指令。直到Java8的Lambda表达式的出现，invokedynamic指令的生成，在Java中才有了直接的生成方式。
- Java7中增加的动态语言类型支持的本质是对Java虚拟机规范的修改，而不是对Java语言规则的修改，这一块相对来讲比较复杂，增加了虚拟机中的方法调用，最直接的受益者就是运行在Java平台的动态语言的编译器。
方法重写的本质
- 找到操作数栈顶的第一个元素所执行的对象的实际类型，记作C。
- 如果在类型C中找到与常量中的描述符合简单名称都相符的方法，则进行访问权限校验。
- 如果通过则返回这个方法的直接引用，查找过程结束
- 如果不通过，则返回java.lang.IllegalAccessError 异常
- 否则，按照继承关系从下往上依次对C的各个父类进行第2步的搜索和验证过程。
- 如果始终没有找到合适的方法，则抛出java.lang.AbstractMethodError异常。
上面这个过程称为动态分派
IllegalAccessError介绍
- 程序试图访问或修改一个属性或调用一个方法，这个属性或方法，你没有权限访问。一般的，这个会引起编译器异常。这个错误如果发生在运行时，就说明一个类发生了不兼容的改变。
- 比如，你把应该有的jar包放从工程中拿走了，或者Maven中存在jar包冲突
虚方法表
- 在面向对象的编程中，会很频繁的使用到动态分派，如果在每次动态分派的过程中都要重新在类的方法元数据中搜索合适的目标的话就可能影响到执行效率。
- 因此，为了提高性能，
JVM采用在类的方法区建立一个虚方法表（virtual method table）来实现，非虚方法不会出现在表中。使用索引表来代替查找。 - 每个类中都有一个虚方法表，表中存放着各个方法的实际入口。
虚方法表是什么时候被创建的呢？虚方法表会在类加载的链接阶段被创建并开始初始化，类的变量初始值准备完成之后，JVM会把该类的虚方法表也初始化完毕。- 如图所示：如果类中重写了方法，那么调用的时候，就会直接在该类的虚方法表中查找
例子1：
如图所示：如果类中重写了方法，那么调用的时候，就会直接在该类的虚方法表中查找
具体解释：比如说son在调用toString的时候，Son没有重写过，Son的父类Father也没有重写过，那就直接调用Object类的toString。那么就直接在虚方法表里指明toString直接指向Object类。下次Son对象再调用toString就直接去找Object，不用先找Son-->再找Father-->最后才到Object的这样的一个过程。
例子2：
public class VirtualMethodTable {
}
interface Friendly {
void sayHello();
void sayGoodbye();
}
class Dog {
public void sayHello() {
}
@Override
public String toString() {
return "Dog";
}
}
class Cat implements Friendly {
public void eat() {
}
public void sayHello() {
}
public void sayGoodbye() {
}
protected void finalize() {
}
public String toString() {
return "Cat";
}
}
class CockerSpaniel extends Dog implements Friendly {
public void sayHello() {
super.sayHello();
}
public void sayGoodbye() {
}
}
方法返回地址
- 存放
调用该方法的pc寄存器的值。 - 一个方法的结束，有两种方式：
- 正常执行完成
- 出现未处理的异常，非正常退出* 无论通过哪种方式退出，在方法退出后都返回到该方法被调用的位置。方法正常退出时，
调用者的pc计数器的值作为返回地址，即调用该方法的指令的下一条指令的地址。而通过异常退出的，返回地址是要通过异常表来确定，栈帧中一般不会保存这部分信息。
- 本质上，方法的退出就是当前栈帧出栈的过程。此时，需要恢复上层方法的局部变量表、操作数栈、将返回值压入调用者栈帧的操作数栈、设置PC寄存器值等，让调用者方法继续执行下去。
正常完成出口和异常完成出口的区别在于：通过异常完成出口退出的不会给他的上层调用者产生任何的返回值。
方法退出的两种方式
当一个方法开始执行后，只有两种方式可以退出这个方法：
- 执行引擎遇到任意一个方法返回的字节码指令（return），会有返回值传递给上层的方法调用者，简称
正常完成出口 - 一个方法在正常调用完成之后，究竟需要使用哪一个返回指令，还需要根据方法返回值的实际数据类型而定。
- 在字节码指令中，返回指令包含：
- ireturn：当返回值是
boolean，byte，char，short和int类型时使用 - lreturn：Long类型
- freturn：Float类型
- dreturn：Double类型
- areturn：引用类型
- return：返回值类型为void的方法、构造器、类和接口的初始化方法* 在方法执行过程中遇到异常（Exception），并且这个异常没有在方法内进行处理，也就是只要在本方法的异常表中没有搜索到匹配的异常处理器，就会导致方法退出，简称
异常完成出口。 - 方法执行过程中，抛出异常时的异常处理，存储在一个异常处理表，方便在发生异常的时候找到处理异常的代码
异常处理表
- 反编译字节码文件，可得到 Exception table
- from ：字节码指令起始地址
- to ：字节码指令结束地址
- target ：出现异常跳转至地址为 11 的指令执行
- type ：捕获异常的类型
public class ReturnAddressTest {
public boolean methodBoolean() {
return false;
}
public byte methodByte() {
return 0;
}
public short methodShort() {
return 0;
}
public char methodChar() {
return 'a';
}
public int methodInt() {
return 0;
}
public long methodLong() {
return 0L;
}
public float methodFloat() {
return 0.0f;
}
public double methodDouble() {
return 0.0;
}
public String methodString() {
return null;
}
public Date methodDate() {
return null;
}
public void methodVoid() {
}
static {
int i = 10;
}
public void method2() {
methodVoid();
try {
method1();
} catch (IOException e) {
e.printStackTrace();
}
}
public void method1() throws IOException {
FileReader fis = new FileReader("atguigu.txt");
char[] cBuffer = new char[1024];
int len;
while ((len = fis.read(cBuffer)) != -1) {
String str = new String(cBuffer, 0, len);
System.out.println(str);
}
fis.close();
}
}
一些附加信息
栈帧中还允许携带与Java虚拟机实现相关的一些附加信息。例如：对程序调试提供支持的信息。
面试题
举例栈溢出的情况？（StackOverflowError）
通过-Xss设置栈的大小：OOM
调整栈大小，就能保证不出现栈溢出
不能。调整栈大小只能让栈溢出出现的情况晚一些，但不能保证不会出现栈溢出
分配栈的内存越大越好吗？
不是，一定时间内降低了栈溢出的概率，但是会挤占其它的线程空间，因为整个虚拟机的内存空间是有限的
垃圾回收是否会涉及到虚拟机栈？
不会的
方法中定义的局部变量是否线程安全？
何为线程安全？
- 如果只有一个线程才可以操作此数据，则必是线程安全的。
- 如果有多个线程操作此数据，则此数据是共享数据。如果不考虑同步机制的话，会存在线程安全问题。
具体问题具体分析：
- 如果对象是在内部产生，并在内部消亡，没有返回到外部，那么它就是线程安全的，反之则是线程不安全的。