第5章-虚拟机栈
第5章-虚拟机栈
以下内容是由尚硅谷的宋红康老师整理，在此先感谢尚硅谷的教学课程；在此仅作为个人学学习笔记进行分享；视频教程地址：宋红康JVM：https://www.bilibili.com/video/BV1PJ411n7xZ
1-网络知识总结
1、虚拟机栈概述
1.1、虚拟机栈的出现背景
文档网址
https://docs.oracle.com/javase/specs/jvms/se8/html/index.html
虚拟机栈出现的背景
- 由于跨平台性的设计，Java的指令都是根据栈来设计的。不同平台CPU架构不同，所以不能设计为基于寄存器的。
- 优点是跨平台，指令集小，编译器容易实现，缺点是性能下降，实现同样的功能需要更多的指令。
内存中的栈与堆
首先栈是运行时的单位，而堆是存储的单位
- 栈解决程序的运行问题，即程序如何执行，或者说如何处理数据。
- 堆解决的是数据存储的问题，即数据怎么放，放哪里
1.2、虚拟机栈的存储内容
虚拟机栈的基本内容
Java虚拟机栈是什么？
Java虚拟机栈（Java Virtual Machine Stack），早期也叫Java栈。每个线程在创建时都会创建一个虚拟机栈，其内部保存一个个的栈帧（Stack Frame），对应着一次次的Java方法调用，栈是线程私有的
虚拟机栈的生命周期
生命周期和线程一致，也就是线程结束了，该虚拟机栈也销毁了
虚拟机栈的作用
主管Java程序的运行，它保存方法的局部变量（8 种基本数据类型、对象的引用地址）、部分结果，并参与方法的调用和返回。
- 局部变量，它是相比于成员变量来说的（或属性）
- 基本数据类型变量 VS 引用类型变量（类、数组、接口）
1.3、虚拟机栈的特点
栈的特点
栈是一种快速有效的分配存储方式，访问速度仅次于程序计数器。JVM直接对Java栈的操作只有两个：
- 每个方法执行，伴随着进栈（入栈、压栈）
- 执行结束后的出栈工作
对于栈来说不存在垃圾回收问题（栈存在溢出的情况）
1.4、虚拟机栈的异常
栈中可能出现的异常
面试题：栈中可能出现的异常
- Java 虚拟机规范允许Java栈的大小是动态的或者是固定不变的。
- 如果采用固定大小的Java虚拟机栈，那每一个线程的Java虚拟机栈容量可以在线程创建的时候独立选定。
- 如果线程请求分配的栈容量超过Java虚拟机栈允许的最大容量，Java虚拟机将会抛出一个StackoverflowError 异常。
- 如果Java虚拟机栈可以动态扩展，并且在尝试扩展的时候无法申请到足够的内存，或者在创建新的线程时没有足够的内存去创建对应的虚拟机栈，那Java虚拟机将会抛出一个 OutofMemoryError 异常。
栈异常演示
- 代码
public class StackErrorTest {private static int count = 1;public static void main(String[] args) {System.out.println(count);count++;main(args);}
}
- 递归调用 11418 次后，出现栈内存溢出
1.5、设置栈内存大小
设置栈内存的大小
- 我们可以使用参数 -Xss 选项来设置线程的最大栈空间，栈的大小直接决定了函数调用的最大可达深度。
-Xss1024m// 栈内存为 1024MBS
-Xss1024k// 栈内存为 1024KB
12
- 设置线程的最大栈空间：256KB
- 代码测试
public class StackErrorTest {private static int count = 1;public static void main(String[] args) {System.out.println(count);count++;main(args);}
}
- 递归 2471 次，栈内存溢出
2、栈的存储单位
2.1、栈的运行原理
栈存储什么？
- 每个线程都有自己的栈，栈中的数据都是以栈帧（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()执行结束...");}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;}
}
- 先执行的函数，最后执行结束
method1()开始执行...
method2()开始执行...
method3()开始执行...
method3()即将结束...
method2()即将结束...
method1()执行结束...
123456
- 反编译，可以看到每个方法后面都带有 return 语句或者 ireturn 语句
public void method1();descriptor: ()Vflags: ACC_PUBLICCode:stack=2, locals=1, args_size=10: getstatic #5 // Field java/lang/System.out:Ljava/io/PrintStream;3: ldc #6 // String method1()开始执行...5: invokevirtual #7 // Method java/io/PrintStream.println:(Ljava/lang/String;)V8: aload_09: invokevirtual #8 // Method method2:()I12: pop13: getstatic #5 // Field java/lang/System.out:Ljava/io/PrintStream;16: ldc #9 // String method1()执行结束...18: invokevirtual #7 // Method java/io/PrintStream.println:(Ljava/lang/String;)V21: returnLineNumberTable:line 16: 0line 17: 8line 18: 13line 19: 21LocalVariableTable:Start Length Slot Name Signature0 22 0 this Lcom/atguigu/java1/StackFrameTest;
1234567891011121314151617181920212223public int method2();descriptor: ()Iflags: ACC_PUBLICCode:stack=2, locals=3, args_size=10: getstatic #5 // Field java/lang/System.out:Ljava/io/PrintStream;3: ldc #10 // String method2()开始执行...5: invokevirtual #7 // Method java/io/PrintStream.println:(Ljava/lang/String;)V8: bipush 1010: istore_111: aload_012: invokevirtual #11 // Method method3:()D15: d2i16: istore_217: getstatic #5 // Field java/lang/System.out:Ljava/io/PrintStream;20: ldc #12 // String method2()即将结束...22: invokevirtual #7 // Method java/io/PrintStream.println:(Ljava/lang/String;)V25: iload_126: iload_227: iadd28: ireturnLineNumberTable:line 22: 0line 23: 8line 24: 11line 25: 17line 26: 25LocalVariableTable:Start Length Slot Name Signature0 29 0 this Lcom/atguigu/java1/StackFrameTest;11 18 1 i I17 12 2 m I
1234567891011121314151617181920212223242526272829303132public double method3();descriptor: ()Dflags: ACC_PUBLICCode:stack=2, locals=3, args_size=10: getstatic #5 // Field java/lang/System.out:Ljava/io/PrintStream;3: ldc #13 // String method3()开始执行...5: invokevirtual #7 // Method java/io/PrintStream.println:(Ljava/lang/String;)V8: ldc2_w #14 // double 20.0d11: dstore_112: getstatic #5 // Field java/lang/System.out:Ljava/io/PrintStream;15: ldc #16 // String method3()即将结束...17: invokevirtual #7 // Method java/io/PrintStream.println:(Ljava/lang/String;)V20: dload_121: dreturnLineNumberTable:line 30: 0line 31: 8line 32: 12line 33: 20LocalVariableTable:Start Length Slot Name Signature0 22 0 this Lcom/atguigu/java1/StackFrameTest;12 10 1 j D
123456789101112131415161718192021222324
2.2、栈的内部结构
栈帧内部结构
每个栈帧中存储着：
- 局部变量表（Local Variables）
- 操作数栈（Operand Stack）（或表达式栈）
- 动态链接（Dynamic Linking）（或指向运行时常量池的方法引用）
- 方法返回地址（Return Address）（或方法正常退出或者异常退出的定义）
- 一些附加信息
并行每个线程下的栈都是私有的，因此每个线程都有自己各自的栈，并且每个栈里面都有很多栈帧，栈帧的大小主要由局部变量表 和 操作数栈决定的
3、局部变量表
3.1、认识局部变量表
认识局部变量表
- 局部变量表：Local Variables，被称之为局部变量数组或本地变量表
- 定义为一个数字数组，主要用于存储方法参数和定义在方法体内的局部变量，这些数据类型包括各类基本数据类型、对象引用（reference），以及returnAddress类型。
- 由于局部变量表是建立在线程的栈上，是线程的私有数据，因此不存在数据安全问题
- 局部变量表所需的容量大小是在编译期确定下来的，并保存在方法的Code属性的maximum local variables数据项中。在方法运行期间是不会改变局部变量表的大小的。
- 方法嵌套调用的次数由栈的大小决定。一般来说，栈越大，方法嵌套调用次数越多。
- 对一个函数而言，它的参数和局部变量越多，使得局部变量表膨胀，它的栈帧就越大，以满足方法调用所需传递的信息增大的需求。
- 进而函数调用就会占用更多的栈空间，导致其嵌套调用次数就会减少。
- 局部变量表中的变量只在当前方法调用中有效。
- 在方法执行时，虚拟机通过使用局部变量表完成参数值到参数变量列表的传递过程。
- 当方法调用结束后，随着方法栈帧的销毁，局部变量表也会随之销毁。
局部变量表所需的容量大小是在编译期确定下来的
- 代码
import java.util.Date;public class LocalVariablesTest {private int count = 0;public static void main(String[] args) {LocalVariablesTest test = new LocalVariablesTest();int num = 10;test.test1();}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;char gender = '男';return dateP + name2;}
}
- 反编译后，可得结论：
- 在编译期间，局部变量的个数、每个局部变量的大小都已经被记录下来
- 所以局部变量表所需的容量大小是在编译期确定下来的
- 利用 JClassLib 也可以查看局部变量的个数
思考：
- 代码
public static void main(String[] args) {if(args == null){LocalVariablesTest test = new LocalVariablesTest();}int num = 10;
}
- 反编译后，提出问题：上面代码中的 test 变量跑哪儿哪了呢？
- 我估计 test 变量和 num 变量共用一个 slot
字节码中方法内部结构的剖析
- [Ljava/lang/String] ：
- [] 表示数组
- L 表示引用类型
- java/lang/String 表示 java.lang.String
- 合起来就是：main() 方法的形参类型为 String[]
- 字节码，字节码长度为 16（0~15）
- 方法异常信息表
- 杂项（Misc）
- 字节码指令行号和原始 java 代码行号的对应关系
- 注意：生效行数和剩余有效行数都是针对于字节码文件的行数
3.2、关于 Slot 的理解
关于 Slot 的理解
- 参数值的存放总是从局部变量数组索引 0 的位置开始，到数组长度-1的索引结束。
- 局部变量表，最基本的存储单元是Slot（变量槽），局部变量表中存放编译期可知的各种基本数据类型（8种），引用类型（reference），returnAddress类型的变量。
- 在局部变量表里，32位以内的类型只占用一个slot（包括returnAddress类型），64位的类型占用两个slot（long和double）。
- JVM会为局部变量表中的每一个Slot都分配一个访问索引，通过这个索引即可成功访问到局部变量表中指定的局部变量值
- 当一个实例方法被调用的时候，它的方法参数和方法体内部定义的局部变量将会按照顺序被复制到局部变量表中的每一个slot上
- 如果需要访问局部变量表中一个64bit的局部变量值时，只需要使用前一个索引即可。（比如：访问long或doub1e类型变量）
- 如果当前帧是由构造方法或者实例方法创建的，那么该对象引用this将会存放在index为0的slot处，其余的参数按照参数表顺序继续排列。
Slot 代码示例
this 存放在 index = 0 的位置：
- 代码
public void test3() {this.count++;
}
- 局部变量表：this 存放在 index = 0 的位置
64位的类型（long和double）占用两个slot
- 代码
public String test2(Date dateP, String name2) {dateP = null;name2 = "songhongkang";double weight = 130.5; // 占据两个slotchar gender = '男';return dateP + name2;
}
- weight 为 double 类型，index 直接从 3 蹦到了 5
static 无法调用 this
- this 不存在与 static 方法的局部变量表中，所以无法调用
//练习：
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);
}
3.3、Slot 的重复利用
Slot 的重复利用
栈帧中的局部变量表中的槽位是可以重用的，如果一个局部变量过了其作用域，那么在其作用域之后申明新的局部变量变就很有可能会复用过期局部变量的槽位，从而达到节省资源的目的。
- 代码
public void test4() {int a = 0;{int b = 0;b = a + 1;}// 变量c使用之前已经销毁的变量b占据的slot的位置int c = a + 1;
}
- 局部变量 c 重用了局部变量 b 的 slot 位置
静态变量与局部变量的对比
变量的分类：
-
按照数据类型分：
- 基本数据类型
- 引用数据类型
-
按照在类中声明的方式分：
- 成员变量
1-类变量：
-
linking的prepare阶段：给类变量默认赋值
-
initial阶段：给类变量显式赋值即静态代码块赋值
2-实例变量：随着对象的创建，会在堆空间中分配实例变量空间，并进行默认赋值
- 局部变量：在使用前，必须要进行显式赋值的！否则，编译不通过，应该是栈中数据弹出后，不会清除上次的值，再次使用时，如果不显示初始化，就会出现脏数据
- 参数表分配完毕之后，再根据方法体内定义的变量的顺序和作用域分配。
- 我们知道类变量表有两次初始化的机会，第一次是在“准备阶段”，执行系统初始化，对类变量设置零值，另一次则是在“初始化”阶段，赋予程序员在代码中定义的初始值。
- 和类变量初始化不同的是，局部变量表不存在系统初始化的过程，这意味着一旦定义了局部变量则必须人为的初始化，否则无法使用。
代码示例
- 报错：局部变量未初始化
补充说明
- 在栈帧中，与性能调优关系最为密切的部分就是前面提到的局部变量表。在方法执行时，虚拟机使用局部变量表完成方法的传递。
- 局部变量表中的变量也是重要的垃圾回收根节点，只要被局部变量表中直接或间接引用的对象都不会被回收。
4、操作数栈
4.1、操作数栈的特点
操作数栈的特点
操作数栈：Operand Stack
- 每一个独立的栈帧除了包含局部变量表以外，还包含一个后进先出（Last - In - First -Out）的 操作数栈，也可以称之为表达式栈（Expression Stack）
- 操作数栈，在方法执行过程中，根据字节码指令，往栈中写入数据或提取数据，即入栈（push）和 出栈（pop）
- 某些字节码指令将值压入操作数栈，其余的字节码指令将操作数取出栈。使用它们后再把结果压入栈，比如：执行复制、交换、求和等操作
代码举例
- 左边为 java 源代码，右边为 java 代码编译生成的字节码指令
4.2、操作数栈的作用
操作数栈的作用
- 操作数栈，主要用于保存计算过程的中间结果，同时作为计算过程中变量临时的存储空间。
- 操作数栈就是JVM执行引擎的一个工作区，当一个方法刚开始执行的时候，一个新的栈帧也会随之被创建出来，这时方法的操作数栈是空的（这个时候数组是有长度的，只是操作数栈为空）
- 每一个操作数栈都会拥有一个明确的栈深度用于存储数值，其所需的最大深度在编译期就定义好了，保存在方法的Code属性中，为maxstack的值。
- 栈中的任何一个元素都是可以任意的Java数据类型
- 32bit的类型占用一个栈单位深度
- 64bit的类型占用两个栈单位深度
- 操作数栈并非采用访问索引的方式来进行数据访问的，而是只能通过标准的入栈和出栈操作来完成一次数据访问
- 如果被调用的方法带有返回值的话，其返回值将会被压入当前栈帧的操作数栈中，并更新PC寄存器中下一条需要执行的字节码指令。
- 操作数栈中元素的数据类型必须与字节码指令的序列严格匹配，这由编译器在编译器期间进行验证，同时在类加载过程中的类检验阶段的数据流分析阶段要再次验证。
- 另外，我们说Java虚拟机的解释引擎是基于栈的执行引擎，其中的栈指的就是操作数栈。
操作数栈的深度
通过反编译生成的字节码指令查看操作数栈的深度
5、代码追踪
操作数栈代码追踪
- 代码
public void testAddOperation() {// byte、short、char、boolean：都以int型来保存byte i = 15;int j = 8;int k = i + j;
}
- 反编译得到的字节码指令
0 bipush 152 istore_13 bipush 85 istore_26 iload_17 iload_28 iadd9 istore_3
10 return
123456789
程序执行流程如下
- 首先执行第一条语句，PC寄存器指向的是0，也就是指令地址为0，然后使用bipush让操作数15入操作数栈。
- 执行完后，让PC + 1，指向下一行代码，下一行代码就是将操作数栈的元素存储到局部变量表1的位置，我们可以看到局部变量表的已经增加了一个元素
- 解释为什么局部变量表索引从 1 开始，因为该方法为实例方法，局部变量表索引为 0 的位置存放的是 this
-
然后PC+1，指向的是下一行。让操作数8也入栈，同时执行store操作，存入局部变量表中
-
然后从局部变量表中，依次将数据放在操作数栈中，等待执行 add 操作
- 然后将操作数栈中的两个元素执行相加操作，并存储在局部变量表3的位置
关于 int j = 8; 的说明
- 我们反编译得到的字节码指令如下
- 因为 8 可以存放在 byte 类型中，所以压入操作数栈的类型为 byte ，而不是 int ，所以执行的字节码指令为 bipush 8
- 然后执行将数值 8 存放在 int 类型的变量中：istore_2
关于调用方法，返回值入操作数栈的说明
- 代码
public int getSum() {int m = 10;int n = 20;int k = m + n;return k;
}public void testGetSum() {// 获取上一个栈桢返回的结果，并保存在操作数栈中int i = getSum();int j = 10;
}
- getSum() 方法字节码指令：最后带着个 ireturn
- testGetSum() 方法字节码指令：一上来就加载 getSum() 方法的返回值
++i 与 i++ 的区别
- 代码
// 程序员面试过程中， 常见的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;
}
- 下面，我根据字节码指令，简单说下 i++ 和 ++i 的区别
0 bipush 102 istore_13 iinc 1 by 16 bipush 108 istore_29 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
1234567891011121314151617181920212223242526272829303132333435
i++
- java 源代码
//第2类问题：
int i3 = 10;
int i4 = i3++;
- 字节码指令：
- bipush 10 ：将 10 压入操作数栈
- istore_3 ：将操作数栈中的 10 保存到变量 i3 中
- iload_3 ：将变量 i3 的值（10）加载至操作数栈中
- iinc 3 by 1：变量 i3 执行 +1 操作
- istore 4：将操作数栈中的值保存至变量 i4 中（10）
12 bipush 10
14 istore_3
15 iload_3
16 iinc 3 by 1
19 istore 4
12345
++i
- java 源代码
int i5 = 10;
int i6 = ++i5;
- 字节码指令
- bipush 10 ：将 10 压入操作数栈
- istore 5 ：将操作数栈中的 10 保存到变量 i5 中
- iinc 5 by 1：变量 i5 执行 +1 操作
- iload 5 ：将变量 i5 的值（11）加载至操作数栈中
- istore 6：将操作数栈中的值保存至变量 i6 中（11）
21 bipush 10
23 istore 5
25 iinc 5 by 1
28 iload 5
30 istore 6
12345
总结：
- i++：先将 i 的值加载到操作数栈，再将 i 的值加 1
- ++i：先将 i 的值加 1，在将 i 的值加载到操作数栈
6、栈顶缓存技术
栈顶缓存技术：Top Of Stack Cashing
- 前面提过，基于栈式架构的虚拟机所使用的零地址指令更加紧凑，但完成一项操作的时候必然需要使用更多的入栈和出栈指令，这同时也就意味着将需要更多的指令分派（instruction dispatch）次数和内存读/写次数。
- 由于操作数是存储在内存中的，因此频繁地执行内存读/写操作必然会影响执行速度。为了解决这个问题，HotSpot JVM的设计者们提出了栈顶缓存（Tos，Top-of-Stack Cashing）技术，将栈顶元素全部缓存在物理CPU的寄存器中，以此降低对内存的读/写次数，提升执行引擎的执行效率。
- 寄存器的主要优点：指令更少，执行速度快
7、动态链接
动态链接（或指向运行时常量池的方法引用）
动态链接：Dynamic Linking
- 每一个栈帧内部都包含一个指向运行时常量池中该栈帧所属方法的引用
- 包含这个引用的目的就是为了支持当前方法的代码能够实现动态链接（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++;}
}
- 在字节码指令中，methodB() 方法中通过 invokevirtual #7 指令调用了方法 A
- 那么 #7 是个啥呢？
public void methodB();descriptor: ()Vflags: ACC_PUBLICCode:stack=3, locals=1, args_size=10: 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;)V8: aload_09: invokevirtual #7 // Method methodA:()V12: aload_013: dup14: getfield #2 // Field num:I17: iconst_118: iadd19: putfield #2 // Field num:I22: returnLineNumberTable:line 16: 0line 18: 8line 20: 12line 21: 22LocalVariableTable:Start Length Slot Name Signature0 23 0 this Lcom/atguigu/java1/DynamicLinkingTest;1234567891011121314151617181920212223242526
-
往上面翻，找到常量池的定义：
#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
- 先找 #8 ：
-
结论：通过 #7 我们就能找到需要调用的 methodA() 方法，并进行调用
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
12345678910111213141516171819202122232425262728293031323334353637383940
- 在上面，其实还有很多符号引用，比如 Object、System、PrintStream 等等
为什么要用常量池呢？
- 因为在不同的方法，都可能调用常量或者方法，所以只需要存储一份即可，然后记录其引用即可，节省了空间
- 常量池的作用：就是为了提供一些符号和常量，便于指令的识别
8、解析和分派
8.1、静态链接与动态链接
静态链接机制与动态链接机制
在JVM中，将符号引用转换为调用方法的直接引用与方法的绑定机制相关
-
静态链接：
当一个字节码文件被装载进JVM内部时，如果被调用的目标方法在编译期确定，且运行期保持不变时，这种情况下将调用方法的符号引用转换为直接引用的过程称之为静态链接
-
动态链接：
如果被调用的方法在编译期无法被确定下来，也就是说，只能够在程序运行期将调用的方法的符号转换为直接引用，由于这种引用转换过程具备动态性，因此也被称之为动态链接。
8.2、早期绑定与晚期绑定
方法的绑定机制
静态链接和动态链接对应的方法的绑定机制为：早期绑定（Early Binding）和晚期绑定（Late Binding）。绑定是一个字段、方法或者类在符号引用被替换为直接引用的过程，这仅仅发生一次。
-
早期绑定
早期绑定就是指被调用的目标方法如果在编译期可知，且运行期保持不变时，即可将这个方法与所属的类型进行绑定，这样一来，由于明确了被调用的目标方法究竟是哪一个，因此也就可以使用静态链接的方式将符号引用转换为直接引用。
-
晚期绑定
如果被调用的方法在编译期无法被确定下来，只能够在程序运行期根据实际的类型绑定相关的方法，这种绑定方式也就被称之为晚期绑定。
代码示例
- 代码
/*** 说明早期绑定和晚期绑定的例子* * @author shkstart* @create 2020 上午 11:59*/
class Animal {public void eat() {System.out.println("动物进食");}
}interface Huntable {void hunt();
}class Dog extends Animal implements Huntable {@Overridepublic void eat() {System.out.println("狗吃骨头");}@Overridepublic void hunt() {System.out.println("捕食耗子，多管闲事");}
}class Cat extends Animal implements Huntable {public Cat() {super(); // 表现为：早期绑定}public Cat(String name) {this(); // 表现为：早期绑定}@Overridepublic void eat() {super.eat(); // 表现为：早期绑定System.out.println("猫吃鱼");}@Overridepublic 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 体现为早期绑定
8.3、多态性与方法绑定
多态性与方法绑定机制
- 随着高级语言的横空出世，类似于Java一样的基于面向对象的编程语言如今越来越多，尽管这类编程语言在语法风格上存在一定的差别，但是它们彼此之间始终保持着一个共性，那就是都支持封装、继承和多态等面向对象特性，既然这一类的编程语言具备多态特性，那么自然也就具备早期绑定和晚期绑定两种绑定方式。
- Java中任何一个普通的方法其实都具备虚函数的特征，它们相当于C++语言中的虚函数（C++中则需要使用关键字virtual来显式定义）。如果在Java程序中不希望某个方法拥有虚函数的特征时，则可以使用关键字final来标记这个方法。
虚方法与非虚方法
虚方法与非虚方法的区别
- 如果方法在编译期就确定了具体的调用版本，这个版本在运行时是不可变的。这样的方法称为非虚方法。
- 静态方法、私有方法、fina1方法、实例构造器、父类方法都是非虚方法。
- 其他方法称为虚方法。
子类对象的多态的使用前提：
- 类的继承关系
- 方法的重写
虚拟机中调用方法的指令
四条普通指令：
- invokestatic：调用静态方法，解析阶段确定唯一方法版本
- invokespecial：调用
<init>方法、私有及父类方法，解析阶段确定唯一方法版本 - invokevirtual：调用所有虚方法
- invokeinterface：调用接口方法
一条动态调用指令
invokedynamic：动态解析出需要调用的方法，然后执行
区别
- 前四条指令固化在虚拟机内部，方法的调用执行不可人为干预
- 而invokedynamic指令则支持由用户确定方法版本
- 其中invokestatic指令和invokespecial指令调用的方法称为非虚方法，其余的（fina1修饰的除外）称为虚方法。
代码示例：
- 代码
/*** 解析调用中非虚方法、虚方法的测试* * invokestatic指令和invokespecial指令调用的方法称为非虚方法* * @author shkstart* @create 2020 下午 12:07*/
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() {// invokespecialsuper();}public Son(int age) {// invokespecialthis();}// 不是重写的父类的静态方法，因为静态方法不能被重写！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() {// invokestaticshowStatic("atguigu.com");// invokestaticsuper.showStatic("good!");// invokespecialshowPrivate("hello!");// invokevirtual// 虽然字节码指令中显示为invokevirtual，但因为此方法声明有final，不能被子类重写，所以也认为此方法是非虚方法。showFinal();// invokespecialsuper.showCommon();// invokevirtual// 有可能子类会重写父类的showCommon()方法showCommon();info();MethodInterface in = null;// invokeinterfacein.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() 方法的字节码指令如下
关于 invokedynamic 指令
- JVM字节码指令集一直比较稳定，一直到Java7中才增加了一个invokedynamic指令，这是Java为了实现【动态类型语言】支持而做的一种改进。
- 但是在Java7中并没有提供直接生成invokedynamic指令的方法，需要借助ASM这种底层字节码工具来产生invokedynamic指令。直到Java8的Lambda表达式的出现，invokedynamic指令的生成，在Java中才有了直接的生成方式。
- Java7中增加的动态语言类型支持的本质是对Java虚拟机规范的修改，而不是对Java语言规则的修改，这一块相对来讲比较复杂，增加了虚拟机中的方法调用，最直接的受益者就是运行在Java平台的动态语言的编译器。
代码示例
- 代码
@FunctionalInterface
interface Func {public boolean func(String str);
}public class Lambda {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;});}
}
- 字节码指令
8.4、方法重写的本质
动态语言和静态语言
- 动态类型语言和静态类型语言两者的区别就在于对类型的检查是在编译期还是在运行期，满足前者就是静态类型语言，反之是动态类型语言。
- 说的再直白一点就是，静态类型语言是判断变量自身的类型信息；动态类型语言是判断变量值的类型信息，变量没有类型信息，变量值才有类型信息，这是动态语言的一个重要特征。
Java：String info = "mogu blog"; (Java是静态类型语言的，会先编译就进行类型检查)
JS：var name = "shkstart"; var name = 10;（运行时才进行检查）
方法重写的本质
Java 语言中方法重写的本质：
-
找到操作数栈顶的第一个元素所执行的对象的实际类型，记作C。
-
如果
在类型C中找到与常量中的描述符合简单名称都相符的方法
，则进行访问权限校验
- 如果通过则返回这个方法的直接引用，查找过程结束
- 如果不通过，则返回java.1ang.IllegalAccessError 异常
-
否则，按照继承关系从下往上依次对C的各个父类进行第2步的搜索和验证过程。
-
如果始终没有找到合适的方法，则抛出java.lang.AbstractMethodError异常。
IllegalAccessError介绍
- 程序试图访问或修改一个属性或调用一个方法，这个属性或方法，你没有权限访问。
- 一般的，这个会引起编译器异常。这个错误如果发生在运行时，就说明一个类发生了不兼容的改变。
- 比如，你把应该有的jar包放从工程中拿走了，或者Maven中存在jar包冲突
回看解析阶段
- 解析阶段就是将常量池内的符号引用转换为直接引用的过程
- 解析动作主要针对类或接口、字段、类方法、接口方法、方法类型等。对应常量池中的CONSTANT Class info、CONSTANT Fieldref info、CONSTANT Methodref info等
8.5、多态与虚方法表
虚方法表
- 在面向对象的编程中，会很频繁的使用到动态分派，如果在每次动态分派的过程中都要重新在类的方法元数据中搜索合适的目标的话就可能影响到执行效率。
- 因此，为了提高性能，JVM采用在类的方法区建立一个虚方法表（virtual method table）来实现，非虚方法不会出现在表中。使用索引表来代替查找。
- 每个类中都有一个虚方法表，表中存放着各个方法的实际入口。
- 虚方法表是什么时候被创建的呢？虚方法表会在类加载的链接阶段被创建并开始初始化，类的变量初始值准备完成之后，JVM会把该类的虚方法表也初始化完毕。
- 如图所示：如果类中重写了方法，那么调用的时候，就会直接在该类的虚方法表中查找
9、方法返回地址
方法返回地址（return address）
- 存放调用该方法的pc寄存器的值。一个方法的结束，有两种方式：
- 正常执行完成
- 出现未处理的异常，非正常退出
- 无论通过哪种方式退出，在方法退出后都返回到该方法被调用的位置。方法正常退出时，调用者的pc计数器的值作为返回地址，即调用该方法的指令的下一条指令的地址。而通过异常退出的，返回地址是要通过异常表来确定，栈帧中一般不会保存这部分信息。
- 本质上，方法的退出就是当前栈帧出栈的过程。此时，需要恢复上层方法的局部变量表、操作数栈、将返回值压入调用者栈帧的操作数栈、设置PC寄存器值等，让调用者方法继续执行下去。
- 正常完成出口和异常完成出口的区别在于：通过异常完成出口退出的不会给他的上层调用者产生任何的返回值。
方法退出的两种方式
当一个方法开始执行后，只有两种方式可以退出这个方法，
正常退出：
- 执行引擎遇到任意一个方法返回的字节码指令（return），会有返回值传递给上层的方法调用者，简称正常完成出口；
- 一个方法在正常调用完成之后，究竟需要使用哪一个返回指令，还需要根据方法返回值的实际数据类型而定。
- 在字节码指令中，返回指令包含：
- ireturn：当返回值是boolean，byte，char，short和int类型时使用
- lreturn：Long类型
- freturn：Float类型
- dreturn：Double类型
- areturn：引用类型
- return：返回值类型为void的方法、实例初始化方法、类和接口的初始化方法
异常退出：
- 在方法执行过程中遇到异常（Exception），并且这个异常没有在方法内进行处理，也就是只要在本方法的异常表中没有搜索到匹配的异常处理器，就会导致方法退出，简称异常完成出口。
- 方法执行过程中，抛出异常时的异常处理，存储在一个异常处理表，方便在发生异常的时候找到处理异常的代码
代码举例
- 代码
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() {// Method with no return}static {int i = 10;// Static initializer block}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();}
}
-
方法正常返回
-
ireturn
-
dreturn
-
areturn
-
-
异常处理表：
- 反编译字节码文件，可得到 Exception table
- from ：字节码指令起始地址
- to ：字节码指令结束地址
- target ：出现异常跳转至地址为 11 的指令执行
- type ：捕获异常的类型
10、一些附加信息
栈帧中还允许携带与Java虚拟机实现相关的一些附加信息。例如：对程序调试提供支持的信息。
11、栈相关面试题
举例栈溢出的情况？（StackOverflowError）
通过 -Xss 设置栈的大小
调整栈大小，就能保证不出现溢出么？
不能保证不溢出
分配的栈内存越大越好么？
不是，一定时间内降低了OOM概率，但是会挤占其它的线程空间，因为整个虚拟机的内存空间是有限的
垃圾回收是否涉及到虚拟机栈？
不会
方法中定义的局部变量是否线程安全？
何为线程安全？
- 如果只有一个线程才可以操作此数据，则必是线程安全的。
- 如果有多个线程操作此数据，则此数据是共享数据。如果不考虑同步机制的话，会存在线程安全问题。
具体问题具体分析：
- 如果对象是在内部产生，并在内部消亡，没有返回到外部，那么它就是线程安全的，反之则是线程不安全的。
- 看代码
/*** 面试题：* 方法中定义的局部变量是否线程安全？具体情况具体分析** 何为线程安全？* 如果只有一个线程才可以操作此数据，则必是线程安全的。* 如果有多个线程操作此数据，则此数据是共享数据。如果不考虑同步机制的话，会存在线程安全问题。* @author shkstart* @create 2020 下午 7:48*/
public class StringBuilderTest {// s1的声明方式是线程安全的public static void method1() {// StringBuilder:线程不安全StringBuilder s1 = new StringBuilder();s1.append("a");s1.append("b");//...}// sBuilder通过参数传递方法内，存在线程不安全的问题public static void method2(StringBuilder sBuilder) {sBuilder.append("a");sBuilder.append("b");//...}// 操作s1之后，将s1作为返回值返回，存在线程不安全的问题public static StringBuilder method3() {StringBuilder s1 = new StringBuilder();s1.append("a");s1.append("b");return s1;}// s1的操作：是线程安全的public static String method4() {StringBuilder s1 = new StringBuilder();s1.append("a");s1.append("b");return s1.toString();}public static void main(String[] args) {StringBuilder s = new StringBuilder();// 匿名线程操作s，存在线程不安全的问题new Thread(() -> {s.append("a");s.append("b");}).start();// 调用method2方法，传递s作为参数，存在线程不安全的问题method2(s);}
}
运行时数据区，哪些部分存在Error和GC？
| 运行时数据区 | 是否存在Error | 是否存在GC |
|---|---|---|
| 程序计数器 | 否 | 否 |
| 虚拟机栈 | 是（SOF） | 否 |
| 本地方法栈 | 是 | 否 |
| 方法区 | 是（OOM） | 是 |
| 堆 | 是（OOM） | 是 |
2-个人知识总结
1-当我谈虚拟机栈
-
1）栈是运行时的单位，而堆是存储的单位。
-
2）栈-没有垃圾回收-只有OOM
-
3）-Xss栈内存的设置
-
4）栈里面还有哪些东西->栈帧
-
5）方法和栈帧的关系
- OOP的基本概念：类、对象
- 类中基本结构：field（属性、字段、域）、method
-
6）栈帧里面还有哪些东西->LV、OS、DL、RA
- 1）局部变量表（Local Variables）
- 2）操作数栈（Operand Stack）（或表达式栈）
- 3）动态链接（Dynamic Linking）（或指向运行时常量池的方法引用）
- 4）方法返回地址（Return Address）（或方法正常退出或者异常退出的定义）
- 5）一些附加信息
-
7）字节码指令->写一个类自己尝试去分析
-
8）局部变量的知识要点
-
01）局部变量表所需的容量大小是在编译期确定下来的
-
02）利用 JClassLib 也可以查看局部变量的个数
-
03）[Ljava/lang/String] 含义
-
04）字节码、字节码长度查看
-
05）方法异常信息表
-
06）杂项（Misc）
-
07）字节码指令行号和原始 java 代码行号的对应关系
-
08）局部变量作用行数-生效行数和剩余有效行数都是针对于字节码文件的行数
-
09）局部变量表中Slot的理解-Slot可以被重复使用
-
10）64位的类型（long和double）占用两个slot
-
11）局部变量->slot槽->构造方法+this对象
-
-
9）
2-问题思考
1-栈/栈帧有没有【程序寄存器】指定要指定的【栈帧】
1-栈/栈帧有没有【程序寄存器】指定要指定的【栈帧】
不需要，【栈】里面是【栈帧1、栈帧2、栈帧3、栈帧4、栈帧5、栈帧6】，栈顶中就是要执行的方法；【程序寄存器】到【线程】粒度，但是不会到【更小的栈帧粒度】
栈帧内部确实不会使用程序计数器（Program Counter），而是使用栈指针（Stack Pointer）来指向当前栈帧的位置。
程序计数器主要用于线程私有，记录当前线程正在执行的字节码指令位置，帮助线程在方法之间切换时准确恢复执行状态。相比之下，栈帧的栈指针则用于管理方法调用和返回时的数据流动，它指向当前正在执行的栈帧在虚拟机栈中的位置。
因此，虽然栈帧在栈中按照调用顺序排列，但程序计数器并不直接与栈帧内部数据关联，而是与具体的线程执行状态相关联。
2-栈/栈帧有没有【程序寄存器】指定要指定的【栈帧】
栈会使用到【程序寄存器】吗？栈内部的栈帧按照顺序，第一个就是要执行的栈帧是不是不会要程序寄存器来指向
在计算机体系结构中，“程序寄存器”（Program Counter, PC）通常指的是一个特殊的处理器寄存器，它用来存储当前正在执行的指令的地址或者下一条即将执行的指令的地址。在不同上下文中，这个概念可能有不同的称呼，比如在某些文献中可能会被称为指令指针（Instruction Pointer, IP）。
对于Java虚拟机（JVM）来说，每个线程都拥有自己的程序计数器（Program Counter Register），它是线程私有的，不属于Java虚拟机栈的一部分。程序计数器用来存储当前线程所执行字节码的行号指示器，如果当前线程正在执行的是一个Java方法，则这个计数器记录的是正在执行的虚拟机字节码指令的地址；如果是在执行本地（Native）方法，则程序计数器的值通常是不确定的（undefined）。
当涉及到方法调用时，JVM栈中的栈帧确实不需要直接使用“程序寄存器”来指向第一个要执行的栈帧。栈帧的管理主要依赖于栈指针（如ESP寄存器在x86架构中），用于追踪栈的顶部位置，而哪个栈帧是当前执行的，是由每个线程独立的程序计数器来间接指示的。程序计数器会指向当前线程正在执行的方法对应的字节码指令，而这个方法的栈帧自然就是当前活跃的栈帧，因此，无需额外的寄存器来直接指向栈帧。
总结来说，栈帧的执行顺序和当前执行点更多是通过线程的程序计数器来间接控制和跟踪的，而不是直接由一个所谓的“程序寄存器”在栈内部进行指向。
2-JVM运行中栈帧中有哪些东西?
1-JVM运行中栈帧中有哪些东西?
JVM（Java虚拟机）运行中的栈帧包含了以下几个主要部分：
-
局部变量表（Local Variable Table）：用于存放方法参数和方法内部定义的局部变量。这些变量在方法执行时被创建，并且在方法执行结束后销毁。
-
操作数栈（Operand Stack）：也称为表达式栈，用于执行各种字节码指令。操作数栈用于存储方法执行过程中的临时数据，例如方法调用时的参数、方法返回时的返回值等。
-
动态链接（Dynamic Linking）：包含了指向运行时常量池（Runtime Constant Pool）中该栈帧所属方法的引用。
-
方法返回地址（Return Address）：指向方法调用后要返回的下一条指令的地址。
-
异常表（Exception Table）：用于存放方法内部的异常处理信息，包括异常处理代码的起始位置、结束位置、处理代码位置等。
这些信息共同组成了栈帧的结构，每个正在执行的方法都会创建一个栈帧，栈帧的创建和销毁与方法的调用和返回密切相关。
2-JVM运行中栈帧中有哪些东西?
JVM（Java虚拟机）在运行时，每个方法调用都会创建一个栈帧（Stack Frame）来存储该方法执行所需的信息。栈帧是虚拟机栈中的元素，是支持方法调用和执行的一种数据结构。一个典型的JVM栈帧通常包含以下组件：
-
局部变量表（Local Variables Table）：
- 存储方法参数和方法内部定义的局部变量。局部变量表的大小在编译时就已经确定，并且每个变量槽（Slot）可以存储32位或更小的变量。对于
long和double类型的变量，由于它们是64位，会占用两个变量槽。变量槽可以重用，当某个变量超出作用域后，其占用的槽可被其他变量使用。
- 存储方法参数和方法内部定义的局部变量。局部变量表的大小在编译时就已经确定，并且每个变量槽（Slot）可以存储32位或更小的变量。对于
-
操作数栈（Operand Stack）：
- 一个后入先出（LIFO）栈，用于存储中间计算结果和操作数。方法执行时的很多指令都要从操作数栈中弹出数据，执行运算后再把结果压回栈中。操作数栈的最大深度也在编译时确定。
-
动态链接（Dynamic Linking）：
- 包含一个指向运行时常量池中该栈帧所属方法的引用。这使得虚拟机可以在运行时解析出方法调用的目标，并支持方法调用过程中的动态绑定。
-
返回地址（Return Address）：
- 保存方法执行完成后需要返回到的地址，即调用该方法的代码的下一条指令的地址。这用于从当前方法返回到调用者方法继续执行。
-
额外的附加信息：
- 可能还会包括一些额外的帧数据，比如异常处理表，用于处理方法内的异常情况；以及对调试信息的支持等。
这些组成部分共同协作，支撑了Java方法的调用与执行过程，确保了程序的正确运行。
3-JVM运行中栈帧，用一个简单真实的案例说明一下具体的数据存放在具体的位置
1-JVM运行中栈帧，用一个简单真实的案例说明一下具体的数据存放在具体的位置
让我们通过一个简单的Java方法调用示例来说明JVM栈帧中数据的具体存放位置。假设我们有以下Java代码：
public class Example {public static void main(String[] args) {int a = 10;int b = 20;int result = add(a, b);System.out.println("Result: " + result);}public static int add(int x, int y) {int sum = x + y;return sum;}
}
在这个例子中，当我们调用add方法时，JVM会为这个方法创建一个新的栈帧并压入Java虚拟机栈。栈帧中的数据存储如下：
-
局部变量表:
x和y分别存放了从main方法传递过来的实际参数值，即10和20。sum是在add方法内部声明的局部变量，用于存放两数之和。在执行加法运算后，它将存储30。
-
操作数栈:
- 在执行
x + y操作时，x的值（10）会被从局部变量表加载到操作数栈，接着是y的值（20）。加法指令会从栈顶弹出这两个值执行加法运算，然后将结果（30）压回操作数栈。 - 加法的结果随后会被压入局部变量表的
sum槽中。
- 在执行
-
动态链接:
- 栈帧中会有一个指向运行时常量池中
add方法引用的指针，用于方法的动态绑定和访问类的静态变量等。
- 栈帧中会有一个指向运行时常量池中
-
返回地址:
- 在
add方法执行完毕后需要返回到main方法继续执行的地方（即打印结果的那行代码），这个地址会被保存在栈帧中。
- 在
简而言之，在调用add方法的瞬间，JVM会为该方法创建一个新的栈帧，其中局部变量表存储了方法参数和局部变量，操作数栈用于计算过程中的临时数据存储，动态链接帮助解析方法调用，而返回地址确保方法执行完毕后能够回到正确的执行点。这就是栈帧在实际运行中的数据存储情况。
2-JVM运行中栈帧，用一个简单真实的案例说明一下具体的数据存放在具体的位置
当一个Java程序执行时，每个方法的执行都对应着一个栈帧在虚拟机栈中的创建和销毁过程。让我们通过一个简单的示例来说明栈帧中具体数据存放的情况。
假设我们有如下的Java代码：
public class Main {public static void main(String[] args) {int a = 10;int b = 20;int result = addNumbers(a, b);System.out.println("Result: " + result);}public static int addNumbers(int x, int y) {int sum = x + y;return sum;}
}
在这段代码中，我们有一个 main 方法和一个 addNumbers 方法。让我们看看它们在JVM运行时如何形成栈帧，并存储数据。
-
main 方法的栈帧：
-
局部变量表：
args数组（Java虚拟机规范要求）。a和b变量，它们的值分别是10和20。result变量，用于存放addNumbers方法的返回值。
-
操作数栈：可能会用于暂存部分表达式计算的中间结果。
-
动态链接：指向
main方法的运行时常量池中的方法引用。 -
方法返回地址：指向
System.out.println语句后的下一条指令地址。 -
异常表：通常为空，因为
main方法没有显式的异常处理代码。
-
-
addNumbers 方法的栈帧：
-
局部变量表：
x和y参数，它们接收main方法传入的a和b的值，分别为10和20。sum变量，存放x + y的结果，即30。
-
操作数栈：这里可能会暂存
x和y的值，以及x + y的计算结果。 -
动态链接：指向
addNumbers方法的运行时常量池中的方法引用。 -
方法返回地址：指向
main方法中result赋值语句的下一条指令地址。 -
异常表：通常为空，因为
addNumbers方法没有显式的异常处理代码。
-
在这个例子中，可以看到每个方法执行时都会创建自己的栈帧，并在栈帧中保存方法参数、局部变量和其他执行时需要的数据。这些栈帧按照调用顺序在虚拟机栈中排列，每个方法执行完成后，其对应的栈帧就会被销毁，释放相应的资源。
这种栈帧的设计和管理方式，使得JVM能够有效地管理方法的调用和返回，同时保证方法之间数据的隔离和安全性。
4-如何理解栈帧中的动态链接
1-如何理解栈帧中的动态链接，给出一个生活中的例子进行类比说明
理解JVM栈帧中的动态链接，可以用图书馆借书的过程来做类比。
想象一下，你在一个大型图书馆想要借阅一本书。这个图书馆就像Java程序中的运行时常量池，里面存放着所有书籍的目录信息（相当于类的方法、字段等符号引用）。当你决定借阅某本书时，这本书的名字就像是一个符号引用，告诉你想要获取的内容。
-
符号引用（Symbolic Reference）：在图书馆，书名就像是一个符号，它是一个抽象的标识，代表了你要找的那本书。在Java中，当你编写代码调用一个方法时，这个方法的名字就是一个符号引用，它在编译时期被放入到类文件的常量池中。
-
动态链接：当你告诉图书管理员你想借的书名后，管理员会根据这个名字去查找具体的书架位置，然后给你这本书的实体。这个过程就像是JVM中的动态链接，它会在运行时将符号引用（比如方法名）转换为可以直接访问的内存地址（直接引用），这样程序就可以执行这个方法了。
-
直接引用（Direct Reference）：拿到书后，你可以直接阅读，不再需要书名这个中间步骤。在JVM中，一旦方法的符号引用被转换成直接引用，JVM就能直接调用方法的实现代码，执行相应操作。
生活中的类比简化了技术细节，但核心思想是一致的：动态链接是将抽象的、编译时期的符号引用转换为具体、可执行的地址或引用的过程，从而使得程序能够在运行时正确地调用方法和访问资源。
2-如何理解栈帧中的动态链接，给出一个生活中的例子进行类比说明
在栈帧中的动态链接可以理解为一个在程序运行时根据需要动态调用其他程序或资源的能力。让我们通过一个生活中的例子来进行类比：
假设你是一名讲解员，正在一家博物馆工作。每个展览厅代表一个方法，展示的展品就是方法内的内容和数据。你的工作是根据参观者的需求解释展品。在这个过程中，你可能需要访问其他展览厅（方法）的信息或引用其他资源（动态链接）。
具体来说：
-
动态链接的概念：
- 当你在解释一个展品时（执行一个方法），可能需要引用到其他展览厅的信息（调用其他方法）。
- 这时，你不需要提前知道每个展览厅的所有细节，而是根据需求动态获取需要的信息（动态链接）。
-
生活中的类比：
- 博物馆导览工作：你作为导览员（程序执行过程），在每个展览厅（方法）中解释展品（执行内容）。
- 引用其他展览厅：有时你会引导参观者去其他展览厅查看相关展品（调用其他方法）。
- 动态获取信息：你并不需要预先了解每个展厅的所有内容，只有当需要时才根据参观者的兴趣和问题来获取（动态链接）。
-
实际应用：
- 当一个方法调用另一个方法时，栈帧中的动态链接指向被调用方法在运行时常量池中的引用。这使得程序能够根据需要在运行时链接并执行相应的代码，而不需要静态编译时就确定所有的调用路径。
通过这个博物馆导览员的类比，可以更直观地理解栈帧中动态链接的作用和实际应用场景，帮助程序在运行时灵活地处理方法之间的调用关系和资源引用。
5-JVM的局部变量在什么时候完成初始化
1-局部变量在什么时候完成初始化
在JVM中，局部变量在方法执行时完成初始化。具体来说，当一个方法被调用时，JVM会为该方法创建一个新的栈帧，其中包含一个局部变量表（Local Variable Table）。局部变量表用于存储方法中定义的局部变量，包括方法参数和方法内部声明的变量。
局部变量的初始化发生在它们第一次被赋值之前。在Java中，局部变量可以在声明时初始化，或者在稍后的代码中进行赋值操作。例如，在方法的开始部分声明的参数和局部变量，如果在声明时没有赋初值，它们会被JVM初始化为默认值（如数值类型为0，对象类型为null）。
初始化完成后，局部变量可以被方法体内的代码访问和使用。在方法执行结束时，对应的栈帧会被销毁，局部变量的作用域也随之结束。
总结来说，JVM的局部变量在方法执行过程中完成初始化，这保证了在方法体内正确访问和操作局部变量的值。
2-局部变量在什么时候完成初始化
在Java虚拟机（JVM）中，局部变量的初始化发生在它们被声明的地方，具体来说：
-
对于基本类型的局部变量：它们不会自动初始化，必须在使用前明确地赋予一个初始值。如果没有初始化就直接使用，编译器会报错。这意味着程序员必须在声明局部变量的同时或在其后的某一行代码中进行显式初始化。
-
对于引用类型的局部变量：同样地，它们也不会自动初始化为
null，使用前也必须进行显式初始化。尝试访问一个未初始化的引用类型局部变量同样会导致编译错误。
与成员变量不同，JVM不会为局部变量提供默认初始化值，因为局部变量存储在栈上，它们的生命周期通常较短且与方法或代码块的执行密切相关。由于局部变量的作用域通常较小，要求显式初始化有助于避免潜在的错误和误解，提高代码的清晰度和安全性。
总结来说，局部变量的初始化是在其被定义的代码块中，由程序员显式执行的，而不是由JVM自动完成。在方法开始执行时，局部变量所在的栈帧被创建，但它们的初始化发生在实际赋值语句执行的时候。
6-jvm的栈帧中还会再生成栈帧吗？
1-jvm的栈帧中还会再生成栈帧吗？
在JVM中，每当一个方法被调用时，都会为该方法创建一个新的栈帧，用于存储方法的局部变量、操作数栈、动态链接、方法返回地址等信息。这意味着在方法执行过程中可能会产生多个栈帧的实例。
具体来说，当一个方法内部调用另一个方法时，JVM会为被调用的方法创建一个新的栈帧，并将其推入虚拟机栈的顶部。这样的过程可以是递归的，即一个方法内部又调用自身或者调用其他方法，从而形成多层次的方法调用栈。
每个栈帧都有自己的生命周期，当方法执行完成或者抛出异常时，对应的栈帧会被销毁，释放栈空间。这种栈帧的动态创建和销毁机制保证了方法调用的嵌套和控制流的正确性。
总结来说，JVM的栈帧在方法调用时会动态生成和销毁，以支持方法调用的嵌套和递归调用。
2-jvm的栈帧中还会再生成栈帧吗？
在Java虚拟机（JVM）中，栈帧（Stack Frame）是Java虚拟机栈（Java Virtual Machine Stack）中的基本单元，用于存储方法调用的状态信息，如局部变量表、操作数栈、动态链接信息、方法返回地址等。当一个线程调用一个方法时，JVM会为这个方法创建一个新的栈帧，并将其压入当前线程的调用栈顶部。因此，从逻辑上看，每次方法调用都会导致一个新的栈帧的生成。
如果在一个方法的执行过程中，该方法又调用了其他方法，则会为这个被调用的方法再次生成一个新的栈帧，压入栈顶。这个过程可以递归进行，也就是说，在一个方法内部调用另一个方法时，会继续生成新的栈帧，层层嵌套，直到方法调用链中的最后一个方法执行完毕。
因此，简而言之，在JVM的栈帧中确实会因为方法的互相调用而再次生成新的栈帧，这是JVM管理方法调用和执行的基础机制。但需要注意的是，所有的这些栈帧都是在同一个线程的虚拟机栈中按调用顺序组织的，而不是在一个栈帧内部再次生成另一个栈帧的概念。
7-jvm的方法内部调用其他方法，但是被调用的方法内部又有多线程，那此时栈内部的栈帧是怎么变化的
1-jvm的方法内部调用其他方法，但是被调用的方法内部又有多线程，那此时栈内部的栈帧是怎么变化的
当一个方法内部调用其他方法，而被调用的方法内部又涉及到多线程的情况时，JVM会为每个线程分配独立的栈帧，以保证线程间的独立性和并发性。下面是描述此过程的简要步骤：
-
方法调用：
- 当一个方法内部调用其他方法时，JVM会为被调用的方法创建新的栈帧，并将其入栈。
- 这个过程会在当前线程的栈上创建新的栈帧，同时维持调用栈的状态。
-
多线程情况：
- 如果被调用的方法内部涉及到多线程（即启动了新的线程），每个线程在执行时都会有自己的栈帧。
- 每个线程的栈帧保存该线程当前的执行状态和方法调用信息，使得每个线程都能独立运行并管理自己的方法调用栈。
-
栈帧变化：
- 在多线程环境下，每个线程的栈帧会随着方法的调用和线程的执行不断变化，包括栈帧的入栈和出栈等操作。
- 当一个线程在执行过程中切换到另一个线程，JVM会保存当前线程的执行状态，并切换到另一个线程对应的栈帧执行。
- 同时，各个线程的栈帧在方法调用过程中会独立管理局部变量、操作数栈、方法返回地址等信息，确保线程之间的隔离和并发执行。
因此，在JVM中，方法内部调用其他方法，而被调用的方法涉及多线程时，每个线程都有自己的栈帧管理方法调用栈，确保了多线程并发执行时的正确性和独立性。
2-jvm的方法内部调用其他方法，但是被调用的方法内部又有多线程，那此时栈内部的栈帧是怎么变化的
当JVM中的一个方法内部调用另一个方法时，会为被调用的方法创建一个新的栈帧并压入当前线程的调用栈。如果在这个被调用的方法内部又启动了新的线程，情况就会有所不同。因为每个线程都有自己独立的栈空间，包括自己的Java虚拟机栈，所以新线程会拥有自己单独的调用栈。
具体来说：
-
原调用线程的栈帧变化：原方法调用新方法时，新方法的栈帧会被添加到当前线程的栈顶。当这个被调用的方法执行完毕后，它的栈帧会从调用栈中弹出，控制权返回到调用者，恢复原方法的执行环境。
-
新线程的栈帧变化：新线程启动后，它会为自己的主线程执行的第一个方法创建栈帧。如果这个新线程内部的方法也调用了其他方法，那么这些方法的栈帧将依次在新线程的调用栈中生成和销毁。新线程的栈帧操作完全独立于原调用线程的栈帧操作。
总结起来，虽然方法内部调用其他方法会导致栈帧的生成和销毁，但是当涉及到多线程时，每个线程都维护着自己独立的调用栈，因此被调用方法内部启动的新线程会有自己独立的栈帧序列，不会直接影响到原调用线程的栈帧结构。新线程和原线程之间的栈帧操作是隔离的。
8-JVM的符号引用转直接引用，那符号引用到底是什么？直接引用到底是什么？
1-符号引用到底是什么？直接引用到底是什么？
在Java虚拟机（JVM）中，类的加载过程包括三个主要阶段：加载、链接和初始化。在链接阶段，又分为验证、准备和解析三个步骤。其中，解析过程就是将符号引用（Symbolic References）转换为直接引用（Direct References）的过程，它是类或接口的动态连接的一部分。
1-符号引用（Symbolic References）
符号引用是编译时期生成的，它包含一些能够唯一性地识别一个类、方法或者字段的信息，但是这些信息并不是具体的内存地址。符号引用可以看作是一种逻辑上的引用，它主要包括三部分：
- 全限定名：类或接口的全限定名，包括包名和类名。
- 描述符：描述字段或方法的类型信息，比如方法的参数类型和返回类型。
- 简单名称：对于方法或字段来说，就是它们的名字。
符号引用的一个重要特点是它不涉及到内存布局，因此在类加载的前期就可以确定下来，不会因为类在内存中的位置改变而改变，使得Java的字节码具有较高的可移植性。
2-直接引用（Direct References）
直接引用可以理解为指向目标实体的直接地址引用，它是在程序运行期间，经过解析操作后获得的。直接引用与物理内存布局有关，是访问目标的直接地址，具体形式取决于目标的性质：
- 对于类或者接口来说，直接引用指的是该类或接口在方法区内的实际地址。
- 对于实例方法来说，直接引用是该方法在内存中的入口地址（直接指向字节码的开始位置）。
- 对于静态方法或类变量来说，直接引用是指向方法区中该方法或变量的地址。
- 对于非静态字段（实例变量）来说，直接引用是对象实例数据的偏移量加上该字段在对象中的偏移量。
直接引用使得JVM可以直接定位到目标实体并进行访问，是执行过程中真正使用的引用。
3-解析过程
解析过程就是JVM将类或接口的符号引用替换为直接引用的过程。这个过程可以发生在类加载的解析阶段，也可以延迟到第一次使用该符号引用时才进行（即动态链接）。解析不仅有助于提高程序性能，也使得Java的动态绑定成为可能。
2-符号引用到底是什么？直接引用到底是什么？
在Java虚拟机（JVM）中，符号引用（Symbolic Reference）和直接引用（Direct Reference）是两个重要的概念，用于描述类和类成员的定位和访问。
-
符号引用（Symbolic Reference）：
- 符号引用是一种用来描述所引用的目标的符号名称，而不指明其在内存中的具体位置。
- 在Java中，符号引用可以是类和接口的全限定名（比如
java.lang.String），字段的名称和描述符（比如int length），方法的名称和描述符（比如void println(String)）等。 - 符号引用是在编译期或运行期间生成的，它们包含了目标实体的名称以及一些额外的元数据信息。
-
直接引用（Direct Reference）：
- 直接引用是指向目标的指针、偏移量或者一个能够直接定位到目标的句柄。
- 直接引用是在虚拟机加载类和解析符号引用的过程中获得的，它能直接指向内存中的数据结构，用于快速访问和执行目标代码。
在JVM的类加载过程中，虚拟机会将符号引用转换为直接引用的过程包括解析符号引用和符号解析缓存。这个过程大大加快了类加载的速度
9-JVM的符号引用转直接引用，哪些是早期绑定，哪些是晚期绑定？
1-哪些是早期绑定，哪些是晚期绑定
在Java虚拟机（JVM）中，绑定指的是将一个方法调用与其实现关联起来的过程。根据绑定发生的时间点不同，可以分为早期绑定（静态绑定）和晚期绑定（动态绑定，也称作运行时绑定）。
1-早期绑定（静态绑定）
早期绑定发生在编译时期，这意味着绑定在程序执行前就已经完成。在这个阶段，Java编译器可以直接确定调用哪个方法，无需等到运行时。以下情况通常采用早期绑定：
- 静态方法：静态方法与类相关联，而非与实例相关，因此在编译时就可以确定调用哪个静态方法。
- 私有方法：私有方法不能被子类重写，因此调用私有方法的绑定也是在编译时完成的。
- final方法：被final修饰的方法不能被子类覆盖，因此调用final方法的绑定同样可以在编译时确定。
- 基本类型的运算符和常量：这类操作的实现是固定的，编译时就能决定。
2-晚期绑定（动态绑定）
晚期绑定则发生在程序运行时，这意味着直到方法被调用的那一瞬间，JVM才能确定要调用的具体方法实现。这主要应用于以下场景：
- 非私有的实例方法：特别是当方法在父类和子类中都有定义（即被重写）时，实际调用哪个方法依赖于对象的实际类型，而非引用类型。这是多态性的体现。
- 接口方法：类似于重写的方法，当通过接口引用调用方法时，实际执行的是实现该接口的类中对应方法的实现。
3-符号引用转直接引用与绑定的关系
符号引用转直接引用的过程主要发生在解析阶段，这可以视为一种形式上的绑定，因为它涉及到了从逻辑引用到实际内存地址的转换。但要注意，解析阶段完成的直接引用获取并不等同于动态绑定的概念。动态绑定特指在运行时根据对象的实际类型来决定调用哪个方法的过程，而解析得到的直接引用可能指向的是虚方法表（vtable）的入口，最终的方法调用仍需通过虚方法表来实现动态绑定。
总结来说，早期绑定主要与静态方法、私有方法、final方法等有关，而晚期绑定主要体现在多态的实例方法调用上。符号引用到直接引用的转换虽然在概念上与绑定过程有关联，但其本身是类加载过程中解析阶段的一部分，服务于动态链接和后期的动态绑定机制。
2-哪些是早期绑定，哪些是晚期绑定
在Java虚拟机中，符号引用和直接引用的转换涉及到早期绑定和晚期绑定的概念：
-
早期绑定（Early Binding）：
- 符号引用属于早期绑定的范畴。符号引用在编译期或者虚拟机加载类的解析阶段生成，它包含了目标实体的符号名称以及描述性信息，但不包含直接指向目标实体的指针或地址。
- 在编译期间，符号引用被确定，但具体的内存地址或数据结构并不被确认。这种静态的绑定方式使得编译器可以进行类型检查和优化，但限制了动态修改的能力。
-
晚期绑定（Late Binding）：
- 直接引用属于晚期绑定的范畴。直接引用是在虚拟机加载类和解析符号引用之后获取的，它指向内存中的数据结构或实际的方法代码。
- 在运行期间，虚拟机通过直接引用能够动态地定位和调用目标实体，实现了动态绑定的特性。例如，通过直接引用可以实现Java语言中的方法重写和多态特性。
因此，符号引用是静态和早期绑定的概念，而直接引用则是动态和晚期绑定的概念。早期绑定通过符号引用在编译期确定方法和字段的引用，而晚期绑定通过直接引用在运行时根据实际情况动态地进行方法调用和字段访问。
10-多线程执行的时候，JVM的操作数栈如何进行变化，用一个简单的例子进行详细说明
1-多线程执行的时候，JVM的操作数栈如何进行变化
在多线程执行时，JVM中的操作数栈（Operand Stack）是每个线程私有的，因此每个线程都有自己独立的操作数栈。操作数栈用于存储方法执行过程中的操作数（即方法执行时的临时数据），例如方法参数、局部变量和中间结果等。
1-示例说明
假设有如下简单的Java方法：
public class Example {public static void main(String[] args) {int a = 10;int b = 20;int result = add(a, b);System.out.println(result);}public static int add(int x, int y) {int sum = x + y;return sum;}
}
2-方法执行过程
-
main方法的操作数栈变化：
- 初始时，main方法的操作数栈为空。
// 初始状态：操作数栈为空- 执行
int a = 10;将常量值10推入操作数栈。
操作数栈：10- 执行
int b = 20;将常量值20推入操作数栈。
操作数栈：10, 20- 执行
add(a, b);方法调用前，需要将方法参数10和20推入操作数栈。
操作数栈：10, 20- 调用
add方法后，将返回值（即sum的值）推入操作数栈。
操作数栈：30- 执行
System.out.println(result);时，将result的值（30）推入操作数栈。
操作数栈：30- 最后执行
return或方法结束后，操作数栈清空。
操作数栈：空 -
add方法的操作数栈变化：
- 进入add方法时，操作数栈为空。
// add方法初始状态：操作数栈为空- 执行
int sum = x + y;将x和y的值相加，结果入栈。
操作数栈：30- 执行
return sum;将sum的值（30）返回给调用方。
操作数栈：30- 方法执行完毕后，操作数栈清空。
操作数栈：空
3-多线程下的操作数栈
在多线程环境下，每个线程都有自己独立的操作数栈。这意味着不同线程执行相同的方法时，它们的操作数栈是互相独立的，互不影响。例如，如果有两个线程同时执行main方法，每个线程都会有自己的操作数栈，其中存储了各自方法执行过程中的临时数据。
总结来说，操作数栈是线程私有的数据结构，用于存储方法执行时的操作数和中间结果。每个线程在执行方法时都会有自己的操作数栈，确保线程之间的数据隔离和独立性。
2-多线程执行的时候，JVM的操作数栈如何进行变化
在多线程编程中，理解Java虚拟机栈的变化以及CPU如何调度线程执行是非常重要的。让我们通过一个简单的多线程示例来详细说明这些概念。
1-示例说明
假设我们有以下Java程序，主线程创建并启动了两个子线程：
public class ThreadExample {public static void main(String[] args) {System.out.println("Main thread started.");// 创建并启动第一个子线程Thread thread1 = new Thread(() -> {System.out.println("Thread 1 started.");methodA();System.out.println("Thread 1 ended.");});thread1.start();// 创建并启动第二个子线程Thread thread2 = new Thread(() -> {System.out.println("Thread 2 started.");methodB();System.out.println("Thread 2 ended.");});thread2.start();System.out.println("Main thread ended.");}public static void methodA() {System.out.println("Method A started.");// 用一个递归调用来模拟方法调用的深度methodA();}public static void methodB() {System.out.println("Method B started.");// 用一个递归调用来模拟方法调用的深度methodB();}
}
2-主线程执行过程
-
主线程开始执行：
主线程开始执行
main方法，它会有自己的虚拟机栈来记录方法调用的状态。Main thread started. -
创建并启动子线程 thread1 和 thread2：
主线程创建并启动了两个新线程
thread1和thread2。每个子线程在启动后会创建自己的虚拟机栈，用于记录线程内部方法的调用和执行状态。Thread 1 started. Thread 2 started. -
主线程继续执行：
主线程继续执行
System.out.println("Main thread ended.");并最终结束。Main thread ended.
3-虚拟机栈的变化
-
主线程的虚拟机栈：
主线程的虚拟机栈记录了
main方法的执行过程，包括方法调用和返回状态。 -
子线程的虚拟机栈：
每个子线程（
thread1和thread2）都有独立的虚拟机栈。例如，thread1在执行时记录了methodA()方法的调用深度，而thread2记录了methodB()方法的调用深度。
4-CPU调度执行
在多线程环境下，CPU通过调度算法决定哪个线程执行，这种调度通常基于操作系统提供的线程调度器。CPU的调度策略可以是抢占式的（Preemptive）或非抢占式的（Non-preemptive），具体取决于操作系统的实现。
-
抢占式调度：操作系统可以随时中断正在执行的线程，并将CPU资源分配给其他线程。这种方式确保了高优先级任务能够及时响应，但需要保证线程安全性。
-
非抢占式调度：CPU执行完一个线程的时间片后，才会考虑是否切换到其他线程。这种方式下，线程会持续执行直到主动释放CPU或者线程阻塞。
5-指令执行和线程调度
CPU执行线程的指令是根据线程的状态和调度算法决定的：
- 就绪状态：线程已经准备好执行，等待CPU分配时间片。
- 运行状态：CPU正在执行线程的指令。
- 阻塞状态：线程等待某些条件满足（如I/O操作完成），不能执行。
在示例中，thread1 和 thread2 同时启动，它们的执行由操作系统的线程调度器决定。由于 methodA() 和 methodB() 都是无限递归调用，这会导致线程不断地占用CPU资源，直到发生栈溢出或者程序被中断。
6-总结
在Java中，主线程执行其他多线程时，每个线程都有自己的虚拟机栈来记录方法调用和执行状态。CPU根据操作系统的调度算法来决定执行哪个线程的指令，这种调度保证了多线程程序的并发性和响应性。理解这些概念有助于编写高效、安全的多线程应用程序。