虚拟机栈
虚拟机栈的概述
虚拟机栈的出现背景
- 由于跨平台性的设计，Java的指令都是根据栈来设计的。不同平台CPU架构不同，所以不能设计为基于寄存器的【如果设计成基于寄存器的，耦合度高，性能会有所提升，因为可以对具体的CPU架构进行优化，但是跨平台性大大降低】。
- 优点是跨平台，指令集小，编译器容易实现，缺点是性能下降，实现同样的功能需要更多的指令。
内存中的栈与堆
有不少Java开发人员一提到Java内存结构，就会非常粗粒度地将JVM中的内存区理解为仅有Java堆（heap）和Java栈（stack）？为什么？
- 首先栈是运行时的单位，而堆是存储的单位。
- 即：栈解决程序的运行问题，即程序如何执行，或者说如何处理数据。堆解决的是数据存储的问题，即数据怎么放，放哪里。
虚拟机栈基本内容
-
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 引用类型变量（类、数组、接口）
虚拟机栈的特点
-
栈是一种快速有效的分配存储方式，访问速度仅次于程序计数器。
-
JVM直接对Java栈的操作只有两个：
- 每个方法执行，伴随着进栈（入栈、压栈）
- 执行结束后的出栈工作
-
对于栈来说不存在垃圾回收问题
- 栈不需要GC，但是可能存在OOM
虚拟机栈的异常
面试题：栈中可能出现的异常？
-
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 选项来设置线程的最大栈空间，栈的大小直接决定了函数调用的最大可达深度。
-Xss1m
-Xss1024k
-Xss1048576
举例
public class StackErrorTest {
private static int count = 1;
public static void main(String[] args) {
System.out.println(count);
count++;
main(args);
}
}
没设置参数前
部分输出结果：
11404
11405
11406
Exception in thread "main" java.lang.StackOverflowError
at sun.nio.cs.UTF_8$Encoder.encodeLoop(UTF_8.java:691)
说明栈在11406这个深度溢出了
设置栈参数之后
部分输出结果
2474
2475
2476
Exception in thread "main" java.lang.StackOverflowError
at sun.nio.cs.UTF_8.updatePositions(UTF_8.java:77)
说明参数起作用了
栈的存储单位
栈中存储什么？
- 每个线程都有自己的栈，栈中的数据都是以**栈帧（Stack Frame）**的格式存在
- 在这个线程上正在执行的每个方法都各自对应一个栈帧（Stack Frame）。
- 栈帧是一个内存区块，是一个数据集，维系着方法执行过程中的各种数据信息。
复习：
- OOP的基本概念：类、对象
- 类中的基本属性：field（属性、字段、域）、method
栈运行原理
- JVM直接对Java栈的操作只有两个，就是对栈帧的压栈和出栈，遵循先进后出（后进先出）原则
- 在一条活动线程中，一个时间点上，只会有一个活动的栈帧。即只有当前正在执行的方法的栈帧（栈顶栈帧）是有效的。这个栈帧被称为当前栈帧（Current Frame），与当前栈帧相对应的方法就是当前方法（Current Method），定义这个方法的类就是当前类（Current Class）
- 执行引擎运行的所有字节码指令只针对当前栈帧进行操作。
- 如果在该方法中调用了其他方法，对应的新的栈帧会被创建出来，放在栈的顶端，成为新的当前帧。
下面写一段简单的代码：
public class StackFrameTest {
public static void main(String[] args) {
method01();
}
private static int method01() {
System.out.println("方法1的开始");
int i = method02();
System.out.println("方法1的结束");
return i;
}
private static int method02() {
System.out.println("方法2的开始");
int i = method03();;
System.out.println("方法2的结束");
return i;
}
private static int method03() {
System.out.println("方法3的开始");
int i = 30;
System.out.println("方法3的结束");
return i;
}
}
执行结果为
方法1的开始
方法2的开始
方法3的开始
方法3的结束
方法2的结束
方法1的结束
满足栈先进后出的概念，通过Idea的 DEBUG，能够看到栈信息
栈执行原理
- 不同线程中所包含的栈帧是不允许存在相互引用的，即不可能在一个栈帧之中引用另外一个线程的栈帧。
- 如果当前方法调用了其他方法，方法返回之际，当前栈帧会传回此方法的执行结果给前一个栈帧，接着，虚拟机会丢弃当前栈帧，使得前一个栈帧重新成为当前栈帧。
- 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;
test.test1();
}
//练习：
public static void testStatic(){
LocalVariablesTest test = new LocalVariablesTest();
Date date = new Date();
int count = 10;
System.out.println(count);
//因为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;
}
}
D:\IdeaProjects\jvm\out\production\jvm\com\atguigu\java1>javap -v LocalVariablesTest.class
Classfile /D:/IdeaProjects/jvm/out/production/jvm/com/atguigu/java1/LocalVariablesTest.class
Last modified 2021-2-25; size 1855 bytes
MD5 checksum a4132be0a9c394c0330cc4c68b56f4f1
Compiled from "LocalVariablesTest.java"
public class com.atguigu.java1.LocalVariablesTest
minor version: 0
major version: 52
flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
#1 = Class #59 // com/atguigu/java1/LocalVariablesTest
#2 = Methodref #1.#60 // com/atguigu/java1/LocalVariablesTest."<init>":()V
#3 = Methodref #1.#61 // com/atguigu/java1/LocalVariablesTest.test1:()V
#4 = Class #62 // java/util/Date
#5 = Methodref #4.#60 // java/util/Date."<init>":()V
#6 = Fieldref #63.#64 // java/lang/System.out:Ljava/io/PrintStream;
#7 = Methodref #65.#66 // java/io/PrintStream.println:(I)V
#8 = Methodref #21.#60 // java/lang/Object."<init>":()V
#9 = Fieldref #1.#67 // com/atguigu/java1/LocalVariablesTest.count:I
#10 = String #68 // atguigu.com
#11 = Methodref #1.#69 // com/atguigu/java1/LocalVariablesTest.test2:(Ljava/util/Date;Ljava/lang/String;)Ljava/lang/String;
#12 = Class #70 // java/lang/StringBuilder
#13 = Methodref #12.#60 // java/lang/StringBuilder."<init>":()V
#14 = Methodref #12.#71 // java/lang/StringBuilder.append:(Ljava/lang/Object;)Ljava/lang/StringBuilder;
#15 = Methodref #12.#72 // java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
#16 = Methodref #12.#73 // java/lang/StringBuilder.toString:()Ljava/lang/String;
#17 = Methodref #65.#74 // java/io/PrintStream.println:(Ljava/lang/String;)V
#18 = String #75 // songhongkang
#19 = Double 130.5d
#21 = Class #76 // java/lang/Object
#22 = Utf8 count
#23 = Utf8 I
#24 = Utf8 main
#25 = Utf8 ([Ljava/lang/String;)V
#26 = Utf8 Code
#27 = Utf8 LineNumberTable
#28 = Utf8 LocalVariableTable
#29 = Utf8 args
#30 = Utf8 [Ljava/lang/String;
#31 = Utf8 test
#32 = Utf8 Lcom/atguigu/java1/LocalVariablesTest;
#33 = Utf8 num
#34 = Utf8 testStatic
#35 = Utf8 ()V
#36 = Utf8 date
#37 = Utf8 Ljava/util/Date;
#38 = Utf8 <init>
#39 = Utf8 this
#40 = Utf8 test1
#41 = Utf8 name1
#42 = Utf8 Ljava/lang/String;
#43 = Utf8 test2
#44 = Utf8 (Ljava/util/Date;Ljava/lang/String;)Ljava/lang/String;
#45 = Utf8 dateP
#46 = Utf8 name2
#47 = Utf8 weight
#48 = Utf8 D
#49 = Utf8 gender
#50 = Utf8 C
#51 = Utf8 test3
#52 = Utf8 test4
#53 = Utf8 b
#54 = Utf8 a
#55 = Utf8 c
#56 = Utf8 test5Temp
#57 = Utf8 SourceFile
#58 = Utf8 LocalVariablesTest.java
#59 = Utf8 com/atguigu/java1/LocalVariablesTest
#60 = NameAndType #38:#35 // "<init>":()V
#61 = NameAndType #40:#35 // test1:()V
#62 = Utf8 java/util/Date
#63 = Class #77 // java/lang/System
#64 = NameAndType #78:#79 // out:Ljava/io/PrintStream;
#65 = Class #80 // java/io/PrintStream
#66 = NameAndType #81:#82 // println:(I)V
#67 = NameAndType #22:#23 // count:I
#68 = Utf8 atguigu.com
#69 = NameAndType #43:#44 // test2:(Ljava/util/Date;Ljava/lang/String;)Ljava/lang/String;
#70 = Utf8 java/lang/StringBuilder
#71 = NameAndType #83:#84 // append:(Ljava/lang/Object;)Ljava/lang/StringBuilder;
#72 = NameAndType #83:#85 // append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
#73 = NameAndType #86:#87 // toString:()Ljava/lang/String;
#74 = NameAndType #81:#88 // println:(Ljava/lang/String;)V
#75 = Utf8 songhongkang
#76 = Utf8 java/lang/Object
#77 = Utf8 java/lang/System
#78 = Utf8 out
#79 = Utf8 Ljava/io/PrintStream;
#80 = Utf8 java/io/PrintStream
#81 = Utf8 println
#82 = Utf8 (I)V
#83 = Utf8 append
#84 = Utf8 (Ljava/lang/Object;)Ljava/lang/StringBuilder;
#85 = Utf8 (Ljava/lang/String;)Ljava/lang/StringBuilder;
#86 = Utf8 toString
#87 = Utf8 ()Ljava/lang/String;
#88 = Utf8 (Ljava/lang/String;)V
{
public static void main(java.lang.String[]);
descriptor: ([Ljava/lang/String;)V
flags: ACC_PUBLIC, ACC_STATIC
Code:
stack=2, locals=3, args_size=1
0: new #1 // class com/atguigu/java1/LocalVariablesTest
3: dup
4: invokespecial #2 // Method "<init>":()V
7: astore_1
8: bipush 10
10: istore_2
11: aload_1
12: invokevirtual #3 // Method test1:()V
15: return
LineNumberTable:
line 13: 0
line 14: 8
line 15: 11
line 16: 15
LocalVariableTable:
Start Length Slot Name Signature
0 16 0 args [Ljava/lang/String;
8 8 1 test Lcom/atguigu/java1/LocalVariablesTest;
11 5 2 num I
public static void testStatic();
descriptor: ()V
flags: ACC_PUBLIC, ACC_STATIC
Code:
stack=2, locals=3, args_size=0
0: new #1 // class com/atguigu/java1/LocalVariablesTest
3: dup
4: invokespecial #2 // Method "<init>":()V
7: astore_0
8: new #4 // class java/util/Date
11: dup
12: invokespecial #5 // Method java/util/Date."<init>":()V
15: astore_1
16: bipush 10
18: istore_2
19: getstatic #6 // Field java/lang/System.out:Ljava/io/PrintStream;
22: iload_2
23: invokevirtual #7 // Method java/io/PrintStream.println:(I)V
26: return
LineNumberTable:
line 20: 0
line 21: 8
line 22: 16
line 23: 19
line 26: 26
LocalVariableTable:
Start Length Slot Name Signature
8 19 0 test Lcom/atguigu/java1/LocalVariablesTest;
16 11 1 date Ljava/util/Date;
19 8 2 count I
public com.atguigu.java1.LocalVariablesTest();
descriptor: ()V
flags: ACC_PUBLIC
Code:
stack=2, locals=1, args_size=1
0: aload_0
1: invokespecial #8 // Method java/lang/Object."<init>":()V
4: aload_0
5: iconst_0
6: putfield #9 // Field count:I
9: aload_0
10: iconst_1
11: putfield #9 // Field count:I
14: return
LineNumberTable:
line 29: 0
line 10: 4
line 30: 9
line 31: 14
LocalVariableTable:
Start Length Slot Name Signature
0 15 0 this Lcom/atguigu/java1/LocalVariablesTest;
public void test1();
descriptor: ()V
flags: ACC_PUBLIC
Code:
stack=3, locals=3, args_size=1
0: new #4 // class java/util/Date
3: dup
4: invokespecial #5 // Method java/util/Date."<init>":()V
7: astore_1
8: ldc #10 // String atguigu.com
10: astore_2
11: aload_0
12: aload_1
13: aload_2
14: invokevirtual #11 // Method test2:(Ljava/util/Date;Ljava/lang/String;)Ljava/lang/String;
17: pop
18: getstatic #6 // Field java/lang/System.out:Ljava/io/PrintStream;
21: new #12 // class java/lang/StringBuilder
24: dup
25: invokespecial #13 // Method java/lang/StringBuilder."<init>":()V
28: aload_1
29: invokevirtual #14 // Method java/lang/StringBuilder.append:(Ljava/lang/Object;)Ljava/lang/StringBuilder;
32: aload_2
33: invokevirtual #15 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
36: invokevirtual #16 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
39: invokevirtual #17 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
42: return
LineNumberTable:
line 34: 0
line 35: 8
line 36: 11
line 37: 18
line 38: 42
LocalVariableTable:
Start Length Slot Name Signature
0 43 0 this Lcom/atguigu/java1/LocalVariablesTest;
8 35 1 date Ljava/util/Date;
11 32 2 name1 Ljava/lang/String;
public java.lang.String test2(java.util.Date, java.lang.String);
descriptor: (Ljava/util/Date;Ljava/lang/String;)Ljava/lang/String;
flags: ACC_PUBLIC
Code:
stack=2, locals=6, args_size=3
0: aconst_null
1: astore_1
2: ldc #18 // String songhongkang
4: astore_2
5: ldc2_w #19 // double 130.5d
8: dstore_3
9: sipush 30007
12: istore 5
14: new #12 // class java/lang/StringBuilder
17: dup
18: invokespecial #13 // Method java/lang/StringBuilder."<init>":()V
21: aload_1
22: invokevirtual #14 // Method java/lang/StringBuilder.append:(Ljava/lang/Object;)Ljava/lang/StringBuilder;
25: aload_2
26: invokevirtual #15 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
29: invokevirtual #16 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
32: areturn
LineNumberTable:
line 41: 0
line 42: 2
line 43: 5
line 44: 9
line 45: 14
LocalVariableTable:
Start Length Slot Name Signature
0 33 0 this Lcom/atguigu/java1/LocalVariablesTest;
0 33 1 dateP Ljava/util/Date;
0 33 2 name2 Ljava/lang/String;
9 24 3 weight D
14 19 5 gender C
public void test3();
descriptor: ()V
flags: ACC_PUBLIC
Code:
stack=3, locals=1, args_size=1
0: aload_0
1: dup
2: getfield #9 // Field count:I
5: iconst_1
6: iadd
7: putfield #9 // Field count:I
10: return
LineNumberTable:
line 49: 0
line 50: 10
LocalVariableTable:
Start Length Slot Name Signature
0 11 0 this Lcom/atguigu/java1/LocalVariablesTest;
public void test4();
descriptor: ()V
flags: ACC_PUBLIC
Code:
stack=2, locals=3, args_size=1
0: iconst_0
1: istore_1
2: iconst_0
3: istore_2
4: iload_1
5: iconst_1
6: iadd
7: istore_2
8: iload_1
9: iconst_1
10: iadd
11: istore_2
12: return
LineNumberTable:
line 53: 0
line 55: 2
line 56: 4
line 59: 8
line 60: 12
LocalVariableTable:
Start Length Slot Name Signature
4 4 2 b I
0 13 0 this Lcom/atguigu/java1/LocalVariablesTest;
2 11 1 a I
12 1 2 c I
public void test5Temp();
descriptor: ()V
flags: ACC_PUBLIC
Code:
stack=0, locals=2, args_size=1
0: return
LineNumberTable:
line 72: 0
LocalVariableTable:
Start Length Slot Name Signature
0 1 0 this Lcom/atguigu/java1/LocalVariablesTest;
}
SourceFile: "LocalVariablesTest.java"
看完字节码后，可得结论：所以局部变量表所需的容量大小是在编译期确定下来的。
操作数栈
操作数栈的特点
-
每一个独立的栈帧除了包含局部变量表以外，还包含一个后进先出（Last - In - First -Out）的 操作数栈，也可以称之为表达式栈（Expression Stack）
-
操作数栈，在方法执行过程中，根据字节码指令，往栈中写入数据或提取数据，即入栈（push）和 出栈（pop）
- 某些字节码指令将值压入操作数栈，其余的字节码指令将操作数取出栈。使用它们后再把结果压入栈，
- 比如：执行复制、交换、求和等操作
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lbrM7atz-1616855476987)(assets/image-20210302084739543.png)]](https://i-blog.csdnimg.cn/blog_migrate/75d271dd2fff41ef5e8bb939c88ce5c9.png)
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KyAhzdyv-1616855476988)(assets/image-20210302084818454.png)]](https://i-blog.csdnimg.cn/blog_migrate/276a70ed9ddac56bd314e77b2d6839ee.png)
操作数栈的作用
- 操作数栈，主要用于保存计算过程的中间结果，同时作为计算过程中变量临时的存储空间。
- 操作数栈就是JVM执行引擎的一个工作区，当一个方法刚开始执行的时候，一个新的栈帧也会随之被创建出来，这时方法的操作数栈是空的。
- 每一个操作数栈都会拥有一个明确的栈深度用于存储数值，其所需的最大深度在编译期就定义好了，保存在方法的Code属性中，为maxstack的值。
- 栈中的任何一个元素都是可以任意的Java数据类型
- 32bit的类型占用一个栈单位深度
- 64bit的类型占用两个栈单位深度
- 操作数栈并非采用访问索引的方式来进行数据访问的，而是只能通过标准的入栈和出栈操作来完成一次数据访问。只不过操作数栈是用数组这个结构来实现的而已
- 如果被调用的方法带有返回值的话，其返回值将会被压入当前栈帧的操作数栈中，并更新PC寄存器中下一条需要执行的字节码指令。
- 操作数栈中元素的数据类型必须与字节码指令的序列严格匹配，这由编译器在编译器期间进行验证，同时在类加载过程中的类检验阶段的数据流分析阶段要再次验证。
- 另外，我们说Java虚拟机的解释引擎是基于栈的执行引擎，其中的栈指的就是操作数栈。
动态链接
动态链接（或指向运行时常量池的方法引用）
-
每一个栈帧内部都包含一个指向运行时常量池中该栈帧所属方法的引用。包含这个引用的目的就是为了支持当前方法的代码能够实现动态链接（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++;
}
}
对应字节码
Classfile /F:/IDEAWorkSpaceSourceCode/JVMDemo/out/production/chapter05/com/atguigu/java1/DynamicLinkingTest.class
Last modified 2020-11-10; size 712 bytes
MD5 checksum e56913c945f897c7ee6c0a608629bca8
Compiled from "DynamicLinkingTest.java"
public class com.atguigu.java1.DynamicLinkingTest
minor version: 0
major version: 52
flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
#1 = Methodref #9.#23 // java/lang/Object."<init>":()V
#2 = Fieldref #8.#24 // com/atguigu/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 // com/atguigu/java1/DynamicLinkingTest.methodA:()V
#8 = Class #32 // com/atguigu/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 Lcom/atguigu/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 com/atguigu/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
{
int num;
descriptor: I
flags:
public com.atguigu.java1.DynamicLinkingTest();
descriptor: ()V
flags: ACC_PUBLIC
Code:
stack=2, locals=1, args_size=1
0: aload_0
1: invokespecial #1 // Method java/lang/Object."<init>":()V
4: aload_0
5: bipush 10
7: putfield #2 // Field num:I
10: return
LineNumberTable:
line 7: 0
line 9: 4
LocalVariableTable:
Start Length Slot Name Signature
0 11 0 this Lcom/atguigu/java1/DynamicLinkingTest;
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 12: 0
line 13: 8
LocalVariableTable:
Start Length Slot Name Signature
0 9 0 this Lcom/atguigu/java1/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 16: 0
line 18: 8
line 20: 12
line 21: 22
LocalVariableTable:
Start Length Slot Name Signature
0 23 0 this Lcom/atguigu/java1/DynamicLinkingTest;
}
SourceFile: "DynamicLinkingTest.java"
1、在字节码指令中，methodB() 方法中通过 invokevirtual #7 指令调用了方法 A ，那么 #7 是个啥呢？
2、往上面翻，找到常量池的定义：#7 = Methodref #8.#31
- 先找 #8 ：
#8 = Class #32：去找 #32#32 = Utf8 com/atguigu/java1/DynamicLinkingTest- 结论：通过 #8 我们找到了
DynamicLinkingTest这个类
- 再来找 #31：
#31 = NameAndType #19:#13：去找 #19 和 #13#19 = Utf8 methodA：方法名为 methodA#13 = Utf8 ()V：方法没有形参，返回值为 void
3、结论：通过 #7 我们就能找到需要调用的 methodA() 方法，并进行调用
4、在上面，其实还有很多符号引用，比如 Object、System、PrintStream 等等
为什么要用常量池呢？
-
因为在不同的方法，都可能调用常量或者方法，所以只需要存储一份即可，然后记录其引用即可，节省了空间。
-
常量池的作用：就是为了提供一些符号和常量，便于指令的识别
方法返回地址
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TwFbrRcL-1616855477005)(assets/image-20210304130829612.png)]](https://i-blog.csdnimg.cn/blog_migrate/32bde132cf7a461e4bb0ee99645e7aef.png)
在一些帖子里，方法返回地址、动态链接、一些附加信息 也叫做帧数据区
- 存放调用该方法的pc寄存器的值。
- 一个方法的结束，有两种方式：
- 正常执行完成
- 出现未处理的异常，非正常退出
- 无论通过哪种方式退出，在方法退出后都返回到该方法被调用的位置。方法正常退出时，调用者的pc计数器的值作为返回地址，即调用该方法的指令的下一条指令的地址。而通过异常退出的，返回地址是要通过异常表来确定，栈帧中一般不会保存这部分信息。
方法退出的两种方式
当一个方法开始执行后，只有两种方式可以退出这个方法：
正常退出：
- 执行引擎遇到任意一个方法返回的字节码指令（return），会有返回值传递给上层的方法调用者，简称正常完成出口；
- 一个方法在正常调用完成之后，究竟需要使用哪一个返回指令，还需要根据方法返回值的实际数据类型而定。
- 在字节码指令中，返回指令包含：
- ireturn：当返回值是boolean，byte，char，short和int类型时使用
- lreturn：Long类型
- freturn：Float类型
- dreturn：Double类型
- areturn：引用类型
- return：返回值类型为void的方法、实例初始化方法、类和接口的初始化方法
异常退出：
- 在方法执行过程中遇到异常（Exception），并且这个异常没有在方法内进行处理，也就是只要在本方法的异常表中没有搜索到匹配的异常处理器，就会导致方法退出，简称异常完成出口。
-
方法执行过程中，抛出异常时的异常处理，存储在一个异常处理表，方便在发生异常的时候找到处理异常的代码
-
本质上，方法的退出就是当前栈帧出栈的过程。此时，需要恢复上层方法的局部变量表、操作数栈、将返回值压入调用者栈帧的操作数栈、设置PC寄存器值等，让调用者方法继续执行下去。
-
正常完成出口和异常完成出口的区别在于：通过异常完成出口退出的不会给他的上层调用者产生任何的返回值。
一些附加信息
栈帧中还允许携带与Java虚拟机实现相关的一些附加信息。例如：对程序调试提供支持的信息。
1923
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
