虚拟机栈
介绍
为什么使用栈
由于跨平台性的设计，Java 的指令都是根据栈来设计的。不同平台 CPU 架构不同，所以不能设计为基于寄存器的 「如果设计成基于寄存器的，耦合度高，性能会有所提升，因为可以对具体的 CPU 架构进行优化，但是跨平台性大大降低」。
优点是跨平台，指令集小，编译器容易实现，缺点是性能下降，实现同样的功能需要更多的指令。
内存中栈和堆
首先栈是运行时的单位，而堆是存储的单位。
栈解决程序的运行问题，即程序如何执行，或者说如何处理数据。
堆解决的是数据存储的问题，即数据怎么放，放哪里。
虚拟机栈基本内容
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 引用类型变量 ( 类、数组、接口 )
虚拟机栈的特点
栈是一种快速有效的分配存储方式，访问速度仅次于程序计数器
JVM 自己对 Java 栈操作只有两个
每个方法执行，伴随着进栈（ 入栈、压栈 ）
执行结束后的出栈工作
不存在垃圾回收问题
栈不需要 GC，但可能存在 OOM ( Out Of Memory )
虚拟机栈的异常
如果采用固定大小的 Java 虚拟机栈，那每一个线程的 Java 虚拟机栈容量可以在线程创建的时候独立选定。如果线程请求分配的栈容量超过 Java 虚拟机栈允许的最大容量，Java 虚拟机将会抛出一个 StackOverflowError 异常
如果 Java 虚拟机栈可以动态扩展，并且在尝试扩展的时候无法申请到足够的内存，或者在创建新的线程时没有足够的内存去创建对应的虚拟机栈，那 Java 虚拟机将会抛出一个 OutofMemoryError 异常
设置栈内存大小
[配置文档地址]
我们可以使用参数 -Xss 选项来设置线程的最大栈空间，栈的大小直接决定了函数调用的最大可达深度。
栈的存储单位位
栈可以存储什么
每个线程都有自己的栈，栈中的数据都是以栈帧（Stack Frame）的格式存在
在这个线程上正在执行的每个方法都各自对应一个栈帧（Stack Frame）。
栈帧是一个内存区块，是一个数据集，维系着方法执行过程中的各种数据信息。
栈运行原理
JVM 直接对 Java 栈的操作只有两个，就是对栈帧的压栈和出栈，遵循先进后出（后进先出）原则
在一条活动线程中，一个时间点上，只会有一个活动的栈帧。即只有当前正在执行的方法的栈帧（栈顶栈帧）是有效的。这个栈帧被称为当前栈帧（Current Frame），与当前栈帧相对应的方法就是当前方法（Current Method），定义这个方法的类就是当前类（Current Class）
执行引擎运行的所有字节码指令只针对当前栈帧进行操作。
如果在该方法中调用了其他方法，对应的新的栈帧会被创建出来，放在栈的顶端，成为新的当前帧。
不同线程中所包含的栈帧是不允许存在相互引用的，即不可能在一个栈帧之中引用另外一个线程的栈帧。
如果当前方法调用了其他方法，方法返回之际，当前栈帧会传回此方法的执行结果给前一个栈帧，接着，虚拟机会丢弃当前栈帧，使得前一个栈帧重新成为当前栈帧。
Java方法有两种返回函数的方式
一种是正常的函数返回，使用 return 指令。
另一种是方法执行中出现未捕获处理的异常，以抛出异常的方式结束。
但不管使用哪种方式，都会导致栈帧被弹出。
栈帧内部结构
局部变量表（Local Variables）
操作数栈（Operand Stack）（或表达式栈）
动态链接（Dynamic Linking）（或指向运行时常量池的方法引用）
方法返回地址（Return Address）（或方法正常退出或者异常退出的定义）
一些附加信息
并行每个线程下的栈都是私有的，因此每个线程都有自己各自的栈，并且每个栈里面都有很多栈帧，栈帧的大小主要由局部变量表 和 操作数栈决定的。
局部变量表
概念
局部变量表也被称之为 局部变量数组 或 本地变量表
定义为一个数字数组，主要用于存储 方法参数 和 定义在方法体内的局部变量，这些数据类型包括
各类基本数据类型
对象引用（reference）
returnAddress返回值类型
由于局部变量表是建立在线程的栈上，是线程的私有数据，因此不存在数据安全问题
局部变量表所需的容量大小是在编译期确定下来的，并保存在方法的 Code 属性的 maximum local variables 数据项中。在 方法运行期间 是 不会改变局部变量表的大小 的。
方法嵌套调用的次数由栈的大小决定。一般来说，栈越大，方法嵌套调用次数越多。
对一个函数而言，它的参数和局部变量越多，使得局部变量表膨胀，它的栈帧就越大，以满足方法调用所需传递的信息增大的需求。
进而函数调用就会占用更多的栈空间，导致其嵌套调用次数就会减少。
局部变量表中的变量只在当前方法调用中有效。
在方法执行时，虚拟机通过使用局部变量表完成参数值到参数变量列表的传递过程。
当方法调用结束后，随着方法栈帧的销毁，局部变量表也会随之销毁。
查看一些基本信息
public class LocalVariablesTest {
private int count = 0;
public static void main(String[] args) {
LocalVariablesTest test = new LocalVariablesTest();
int num = 10;
}
}
上图可知
局部变量栈长度为 3 主要有
args、test、num字节码共 11 行
没有异常
行号表
生效行数和剩余有效行数都是针对于字节码文件的行数
本地变量表
起始PC 和 长度构成局部变量的作用域
Start PC == 11表示在字节码的 11 行开始生效，也就是 Java 代码对应的第 10 行。而声明 int num 在 java 代码的是第 9 行，说明是从声明的下一行开始生效Length 5表示局部变量剩余有效行数，main 方法字节码指令总共有 12 行，从 10 行开始生效，那么剩下就是12 - 11 1。Ljava/lang/String前面的 L 表示引用类型
关于 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 也相当于一个变量 ）
Slot 代码示例
this 存放在 index = 0 的位置
public class LocalVariablesTest {
private void test() {
System.out.println("111");
}
}
64位的类型（1ong和double）占用两个slot
private void test() {
System.out.println("111");
long a = 1;
int c = 2;
double b = 0.0;
}
Slot 的重复利用
栈帧中的局部变量表中的槽位是可以重用的，如果一个局部变量过了其作用域，那么在其作用域之后申明新的局部变量变就很有可能会复用过期局部变量的槽位，从而达到节省资源的目的。
private void test() {
System.out.println("111");
int a = 1;
{
int c = 2;
c = a + 1;
}
double b = 0.0;
}
静态变量与局部变量的对比
按照数据类型分类
基本数据类型
引用数据类型
按照在类中声明的位置分类
成员变量：在使用前，都经历过默认初始化赋值
类变量: 链接的准备阶段：给类变量默认赋值 阶段：给类变量显式赋值即静态代码块赋值
实例变量：随着对象的创建，会在堆空间中分配实例变量空间，并进行默认赋值
局部变量：在使用前，必须要进行显式赋值的！否则，编译不通过。
补充说明
在栈帧中，与性能调优关系最为密切的部分就是前面提到的局部变量表。在方法执行时，虚拟机使用局部变量表完成方法的传递。
局部变量表中的变量也是重要的垃圾回收根节点，只要被局部变量表中直接或间接引用的对象都不会被回收。
操作数栈
操作数栈的特点
每一个独立的栈帧除了包含局部变量表以外，还包含一个后进先出（Last - In - First -Out）的 操作数栈，也可以称之为表达式栈（Expression Stack）
操作数栈，在方法执行过程中，根据字节码指令，往栈中写入数据或提取数据，即入栈（push）和 出栈（pop）
某些字节码指令将值压入操作数栈，其余的字节码指令将操作数取出栈。使用它们后再把结果压入栈，
比如：执行复制、交换、求和等操作
public void testAddOperation() {
//byte、short、char、boolean：都以int型来保存
byte i = 15;
int j = 8;
int k = i + j;
// int m = 800;
}
字节码
0 bipush 15 // 将 15 推进操作栈中
2 istore_1 // 操作数栈的元素存储到局部变量表 1 的位置
3 bipush 8 // 将 8 推进操作栈中
5 istore_2 // 操作数栈的元素存储到局部变量表 2 的位置
6 iload_1 // 取出局部变量表中索引为 1 的数据入操作数栈
7 iload_2 // 取出局部变量表中索引为 2 的数据入操作数栈
8 iadd // 执行引擎相加
9 istore_3 // 存储在局部变量表 3 的位置
10 return // 返回操作数栈的作用
操作数栈，主要用于保存计算过程的中间结果，同时作为计算过程中变量临时的存储空间。
操作数栈就是 JVM 执行引擎的一个工作区，当一个方法刚开始执行的时候，一个新的栈帧也会随之被创建出来，这时方法的操作数栈是空的。
每一个操作数栈都会拥有一个明确的栈深度用于存储数值，其所需的最大深度在编译期就定义好了，保存在方法的 Code 属性中，为 maxstack 的值。
栈中的任何一个元素都是可以任意的 Java 数据类型
32bit 的类型占用一个栈单位深度
64bit 的类型占用两个栈单位深度
操作数栈并非采用访问索引的方式来进行数据访问的，而是只能通过标准的入栈和出栈操作来完成一次数据访问。只不过操作数栈是用数组这个结构来实现的而已
如果被调用的方法带有返回值的话，其返回值将会被压入当前栈帧的操作数栈中，并更新PC寄存器中下一条需要执行的字节码指令。
操作数栈中元素的数据类型必须与字节码指令的序列严格匹配，这由编译器在编译器期间进行验证，同时在类加载过程中的类检验阶段的数据流分析阶段要再次验证。
我们说 Java 虚拟机的解释引擎是基于栈的执行引擎，其中的栈指的就是操作数栈。
栈顶缓存技术
栈顶缓存技术：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++;
}
}
java 常量池
Constant pool:
#1 = Methodref #9.#23 // java/lang/Object."<init>":()V
#2 = Fieldref #8.#24 // com/xiaou/day02/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 // com/xiaou/day02/DynamicLinkingTest.methodA:()V
#8 = Class #32 // com/xiaou/day02/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 Lcom/xiaou/day02/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 com/xiaou/day02/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;)Vjava 方法A 方法B
public void methodA();
descriptor: ()V
flags: ACC_PUBLIC
Code:
stack=2, locals=1, args_size=1
0: getstatic #3 // Field java/lang/System.out:Ljava/io/PrintStream;
3: ldc #4 // String methodA()....
5: invokevirtual #5 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
8: return
LineNumberTable:
line 7: 0
line 8: 8
LocalVariableTable:
Start Length Slot Name Signature
0 9 0 this Lcom/xiaou/day02/DynamicLinkingTest;
public void methodB();
descriptor: ()V
flags: ACC_PUBLIC
Code:
stack=3, locals=1, args_size=1
0: getstatic #3 // Field java/lang/System.out:Ljava/io/PrintStream;
3: ldc #6 // String methodB()....
5: invokevirtual #5 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
8: aload_0
9: invokevirtual #7 // Method methodA:()V
12: aload_0
13: dup
14: getfield #2 // Field num:I
17: iconst_1
18: iadd
19: putfield #2 // Field num:I
22: return
LineNumberTable:
line 11: 0
line 12: 8
line 13: 12
line 14: 22
LocalVariableTable:
Start Length Slot Name Signature
0 23 0 this Lcom/xiaou/day02/DynamicLinkingTest;
在 methodB 调用 methodA 的过程 在常量池中寻找调用时信息
为什么要用常量池呢
因为在不同的方法，都可能调用常量或者方法，所以只需要存储一份即可，然后记录其引用即可，节省了空间。
常量池的作用：就是为了提供一些符号和常量，便于指令的识别。
方法的调用
静态链接与动态链接
在 JVM 中，将符号引用转换为调用方法的直接引用与方法的绑定机制相关。
静态链接
当一个字节码文件被装载进 JVM 内部时，如果被调用的目标方法在编译期确定，且运行期保持不变时，这种情况下将调用方法的符号引用转换为直接引用的过程称之为静态链接
动态链接
如果被调用的方法在编译期无法被确定下来，也就是说，只能够在程序运行期将调用的方法的符号转换为直接引用，由于这种引用转换过程具备动态性，因此也被称之为动态链接。
早期绑定与晚期绑定
静态链接 与 动态链接 针对的是方法。早期绑定和晚期绑定范围更广。早期绑定涵盖了静态链接，晚期绑定涵盖了动态链接。
静态链接 和 动态链接 对应的方法的绑定机制为：早期绑定（Early Binding）和 晚期绑定（Late Binding）。绑定是一个 字段、方法 或者 类 在符号引用被替换为直接引用的过程，这仅仅发生一次
不管哪一种绑定一旦绑定了就不会再更改
早期绑定
早期绑定就是指被调用的目标方法如果在编译期可知，且运行期保持不变时，即可将这个方法与所属的类型进行绑定，这样一来，由于明确了被调用的目标方法究竟是哪一个，因此也就可以使用静态链接的方式将符号引用转换为直接引用。
晚期绑定
如果被调用的方法在编译期无法被确定下来，只能够在程序运行期根据实际的类型绑定相关的方法，这种绑定方式也就被称之为晚期绑定。
演示
class Animal {
public void eat() {
System.out.println("动物进食");
}
}
@FunctionalInterface
interface Hunt {
void hunt();
}
class Dog extends Animal implements Hunt {
@Override
public void eat() {
System.out.println("狗吃骨头");
}
@Override
public void hunt() {
System.out.println("捕食耗子，多管闲事");
}
}
class Cat extends Animal implements Hunt {
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(Hunt h) {
h.hunt(); // 表现为：晚期绑定
}
}
showAnimal 方法字节码
0 aload_1
1 invokevirtual #2 <com/xiaou/day02/Animal.eat : ()V>
4 returnshowHunt 方法的字节码
0 aload_1
1 invokeinterface #3 <com/xiaou/day02/Hunt.hunt : ()V> count 1
6 returnCat eat 方法的字节码
0 aload_0
1 invokespecial #3 <com/xiaou/day02/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
Cat 构造方法的字节码
// 无参数
0 aload_0
1 invokespecial #1 <com/xiaou/day02/Animal.<init> : ()V>
4 return
// 有参数
0 aload_0
1 invokespecial #2 <com/xiaou/day02/Cat.<init> : ()V>
4 return
晚期绑定指令
invokevirtual
invokeinterface
早期绑定指令
invokespecial
多态与绑定
随着高级语言的横空出世，类似于 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
// 因为此方法声明有final，不能被子类重写，所以也认为此方法是非虚方法。
showFinal();
//虚方法如下：
// 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();
}
在 son 类中的 show 方法的字节码
0 ldc #11 <atguigu.com>
2 invokestatic #12 <com/xiaou/day02/Son.showStatic : (Ljava/lang/String;)V>
5 ldc #13 <good!>
7 invokestatic #14 <com/xiaou/day02/Father.showStatic : (Ljava/lang/String;)V>
10 aload_0
11 ldc #15 <hello!>
13 invokespecial #16 <com/xiaou/day02/Son.showPrivate : (Ljava/lang/String;)V>
16 aload_0
17 invokespecial #17 <com/xiaou/day02/Father.showCommon : ()V>
20 aload_0
21 invokevirtual #18 <com/xiaou/day02/Son.showFinal : ()V>
24 aload_0
25 invokevirtual #19 <com/xiaou/day02/Son.showCommon : ()V>
28 aload_0
29 invokevirtual #20 <com/xiaou/day02/Son.info : ()V>
32 aconst_null
33 astore_1
34 aload_1
35 invokeinterface #21 <com/xiaou/day02/MethodInterface.methodA : ()V> count 1
40 return关于 invokedynamic 指令
但是在 Java7 中并没有提供直接生成 invokedynamic 指令的方法，需要借助 ASM 这种底层字节码工具来产生 invokedynamic 指令。直到 Java8 的 Lambda 表达式的出现，invokedynamic 指令的生成，在 Java 中才有了直接的生成方式。
@FunctionalInterface
interface Func {
public boolean func(String str);
}
public class LambdaTest {
public void lambda(Func func) {
return;
}
public static void main(String[] args) {
Lambda lambda = new Lambda();
Func func = s -> {
return true;
};
lambda.lambda(func);
lambda.lambda(s -> {
return true;
});
}
}
虚方法表
在方法区建立，加快虚方法的查找
在面向对象的编程中，会很频繁的使用到动态分派，如果在每次动态分派的过程中都要重新在类的方法元数据中搜索合适的目标的话就可能影响到执行效率。因此，为了提高性能，JVM 采用在类的 方法区 建立一个虚方法表（virtual method table）来实现，非虚方法不会出现在表中。使用索引表来代替查找。「上面动态分派的过程，我们可以看到如果子类找不到，还要从下往上找其父类，非常耗时」
每个类中都有一个虚方法表，表中存放着各个方法的实际入口。
虚方法表会在类加载的 链接阶段 被 创建并开始初始化，类的变量初始值准备完成之后，JVM会把该类的虚方法表也初始化完毕。
Java语言中方法重写的本质
使用 动态分派 方式
找到操作数栈顶的第一个元素所执行的对象的实际类型，记作 C。
如果在类型 C 中找到与常量中的描述符合简单名称都相符的方法，则进行访问权限校验。
如果通过则返回这个方法的直接引用，查找过程结束
如果不通过，则返回
java.lang.IllegalAccessError异常
否则，按照继承关系从下往上依次对 C 的各个父类进行第 2 步的搜索和验证过程。
如果始终没有找到合适的方法，则抛出
java.lang.AbstractMethodError异常。
IllegalAccessError介绍
程序试图访问或修改一个属性或调用一个方法，这个属性或方法，你没有权限访问。
一般的，这个会引起编译器异常。这个错误如果发生在运行时，就说明一个类发生了不兼容的改变。比如，你把应该有的 jar 包放从工程中拿走了，或者 Maven 中存在 jar 包冲突
方法返回地址
方法返回地址、动态链接、一些附加信息 也叫做帧数据区
作用
存放调用该方法的 pc 寄存器的值。一个方法的结束，有两种方式：
正常执行完成
出现未处理的异常，非正常退出
无论通过哪种方式退出，在方法退出后都返回到该方法被调用的位置。方法正常退出时，调用者的 PC 计数器的值作为返回地址，即调用该方法的指令的下一条指令的地址。而通过异常退出的，返回地址是要通过异常表来确定，栈帧中一般不会保存这部分信息。
本质上，方法的退出就是当前栈帧出栈的过程。此时，需要恢复上层方法的局部变量表、操作数栈、将返回值压入调用者栈帧的操作数栈、设置 PC 寄存器值等，让调用者方法继续执行下去。
正常完成出口和异常完成出口的区别在于：通过异常完成出口退出的不会给他的上层调用者产生任何的返回值。
正常退出
执行引擎遇到任意一个方法返回的字节码指令（return），会有返回值传递给上层的方法调用者，简称正常完成出口；
一个方法在正常调用完成之后，究竟需要使用哪一个返回指令，还需要根据方法返回值的实际数据类型而定。
在字节码指令中，返回指令包含：
ireturn：当返回值是 boolean，byte，char，short 和 int 类型时使用
lreturn：Long类型
freturn：Float类型
dreturn：Double类型
areturn：引用类型
return：返回值类型为void的方法、实例初始化方法、类和接口的初始化方法
异常退出
在方法执行过程中遇到异常（Exception），并且这个异常没有在方法内进行处理，也就是只要在本方法的异常表中没有搜索到匹配的异常处理器，就会导致方法退出，简称 异常完成出口。
方法执行过程中，抛出异常时的异常处理，存储在一个异常处理表，方便在发生异常的时候找到处理异常的代码
异常处理表
public void demo1() {
try {
int a = 10;
}catch (Exception e) {
e.printStackTrace();
}finally {
System.out.println("finally");
}
}
从表中也可以发现 finally 代码块中的代码始终执行
一些附加信息
栈帧中还允许携带与 Java 虚拟机实现相关的一些附加信息。例如：对程序调试提供支持的信息。