Java虚拟机栈
一、虚拟机栈概述
1.1 虚拟机栈出现的背景
- 由于跨平台的设计，
Java指令都是根据栈来设计的。不同的CPU架构不同，所以不能设计为基于寄存器的。 优点是跨平台，指令集小，编译器器容易实现；缺点是性能下降，实现同样的功能需要更多指令。
1.2 内存中的栈和堆
有不少开发人员一提到Java内存结构，就会非常粗粒度的将JVM中的内存区理解为仅有Java堆（heap）和Java栈（stack）。为什么？
栈是运行时的单位，而堆是存储的单位。- 栈解决程序的运行问题，即程序如何执行，或者说如何处理数据
- 堆解决的是数据存储的问题，即数据怎么放，放在哪儿。
1.3 虚拟机栈的基本内容
Java虚拟机栈是什么？
Java虚拟机栈（Java Virtual Macine Stack），早期也叫Java栈。每个线程在创建时都会创建一个虚拟机栈，其内部保存一个个栈帧（Stack Frame），对应着一次次的Java方法调用。
- 是线程私有的
生命周期
生命周期和线程一致。
作用
主管Java程序的运行，它保存方法的局部变量（8 种基本数据类型、对象的引用地址）、部分结果，并参与方法的调用和返回。
1.3.1 虚拟机栈的特点
- 栈是一种快速有效的分配存储方式，访问速度仅次于程序计数器。
- JVM直接对Java栈的操作只有两个：
- 每个方法执行，伴随着进栈（入栈，压栈）
- 执行结束后的出栈工作
- 对于栈来说不存在垃圾回收问题
- GC ；OOM
举例：
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;
}
}
1.3.2 虚拟机栈的异常
面试题：栈中可能出现的异常
- Java 虚拟机规范允许**
Java栈的大小是动态的或者是固定不变的**。- 如果采用固定大小的Java虚拟机栈，那每一个线程的Java虚拟机栈容量可以在线程创建的时候独立选定。
- 如果线程请求分配的栈容量超过Java虚拟机栈允许的最大容量，Java虚拟机将会抛出一个StackoverflowError 异常。简称：栈溢出。
- 如果Java虚拟机栈可以动态扩展，并且在尝试扩展的时候无法申请到足够的内存，或者在创建新的线程时没有足够的内存去创建对应的虚拟机栈，那Java虚拟机将会抛出一个 OutOfMemoryError 异常。
栈异常演示
public class StackError {
public static void main(String[] args) {
main(args);
}
}
1.3.3 设置栈内存大小
我们可以使用-Xss选项来设置线程的最大栈空间，栈的大小直接决定了函数调用的最大可达深度。
-Xss 1024m //栈内存为1024MB
-Xss 1024k //栈内存为1024MB
二、栈的存储单位
2.1 栈中存储什么？
- 每个线程都有自己的栈，栈中的数据都是以**
栈帧（Stack Frame）的格式存在**。 - 在这个线程上正在执行的每个方法都各自对应一个栈帧（Stack Frame）。
- 栈帧是一个内存区块，是一个数据集，维系着方法执行过程中的各种数据信息。
2.2 栈运行原理
- 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()执行结束...
三、局部变量表（Local variables）
3.1 局部变量表介绍
- 局部变量表也被称为局部变量数组或本地变量表。
- **
定义为一个数字数组，主要用于存储方法参数和定义在方法体内的局部变量**，这些数据类型包括各种基本数据类型、对象引用（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 void test1() {
Date date = new Date();
String name1 = "baidu.com";
String info = test2(date, name1);
System.out.println(date + name1);
}
public String test2(Date dateP, String name2) {
dateP = null;
name2 = "xiexu";
double weight = 185.5;//占据两个slot
char gender = '男';
return dateP + name2;
}
}
反编译后，可得结论：
- 在编译期间，局部变量的个数、每个局部变量的大小都已经被记录下来
- 所以局部变量表所需的容量大小是在编译期确定下来的
- 利用 JClassLib 也可以查看局部变量的个数
JClassLib 参数详解
3.2 关于Slot的理解
- 参数值的存放总是在局部变量表数组的index0开始，到数组长度-1的索引结束。
- 局部变量表，
最基本的存储单元是Slot（变量槽） - 局部变量表中存放编译期可知的各种基本数据类型（8种），引用类型（renference），renturnAddress类型的变量。
- 在局部变量表中，
32位以内的类型只占一个Slot（包括returnAddress类型），64位的类型（long和double）占用两个Slot。- byte、short、char在存储前被转换为int，boolean也被转换为int，0表示false，非0表示true。
- long和double则占据两个Slot
- JVM会为局部变量表中的每一个Slot分配一个访问索引，通过这个索引即可成功访问到局部变量表中指定的局部变量值。
- 当一个实例方法被调用时，它的方法参数的方法体内部定义的局部变量将会
按照顺序被复制到局部变量表中每一个Slot上。 如果需要访问局部变量表中一个64位的局部变量值时，只需要使用前一个索引即可。（比如：访问long或者double类型变量）- 如果当前帧是由构造方法或者实例方法创建的，那么
该对象引用的this将会放在index为0的Slot处，其余的参数按照参数表继续排列。
在构造器以及实例方法中，对象引用this 都会存放在索引为0的位置
//构造器
public LocalVariablesTest() {
this.count = 1;
}
//实例方法
public void test1() {
Date date = new Date();
String name1 = "baidu.com";
test2(date, name1);
System.out.println(date + name1);
}
64位的类型（long和double）占用两个slot
public String test2(Date dateP, String name2) {
dateP = null;
name2 = "xiexu";
double weight = 185.5; //占据两个slot
char gender = '男';
return dateP + name2;
}
可以看到，weight为double类型，索引从3直接跳到5，说明double占据两个slot
static方法无法调用this
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的重复利用
栈帧中的局部变量表中的槽位是可以重用的，如果一个局部变量出了其作用域，那么在其作用域之后声明新的局部变量就很有可能会复用过期局部变量的槽位，从而达到节省资源的目的。
public void test4() {
int a = 0;
{
int b = 0;
b = a + 1;
}
//变量c使用 之前已经销毁的变量b占据的slot的位置
int c = a + 1;
}
可以看到，局部变量c 重用了 局部变量b 的slot位置
3.4 静态变量和局部变量
四、操作数栈
4.1 操作数栈的特点
- 每一个独立的栈帧中除了包含局部变量表以外，还包还一个
后进先出的操作数栈（Last-In-First-Out）操作数栈，也可以称之为表达式栈（Expression Stack）。 - 操作数栈，在方法执行是过程中，根据字节码指令，往栈中写入数据或提取数据，即入栈（push）和出栈（pop）。
- 某些字节码指令将值压入操作数栈，其余字节码指令将操作数取出栈。使用他们后再把结果压入栈。
- 比如：执行赋值、交换、求和等操作
4.2 操作数栈的作用
- 操作数栈，
主要用于保存计算过程的中间结果，同时作为计算过程中变量的临时存储空间。 - 操作数栈就是JVM执行引擎的一个工作区，当一个方法刚开始执行的时候，一个新的栈帧也会随之被创建出来，这个方法的操作数栈是空的。
- 每一个操作数栈都会拥有一个明确的栈深度用于存储数值，其所需的最大深度在编译器就定义好了，保存在方法的Code属性中，为max_stack的值。
- 栈中的任何一个元素都可以是任意的Java数据类型。
- 32bit的类型占用一个栈的单位深度
- 64bit的类型占用两个栈的单位深度
- 操作数栈并非采用访问索引的方式来进行数据访问的，而是只能通过标准的入栈（push）和出栈（pop）来完成一次访问。
如果被调用的方法带有返回值的话，其返回值将会被压入当前栈帧的操作数栈中，并更新PC寄存器中下一条需要执行的字节码指令。- 操作数栈中的元素类型必须与字节码指令的序列严格匹配，则由编译器在编译期间进行验证，同时在类加载过程中的类检验阶段的数据分析阶段要再次验证。
- 另外，我们说
Java虚拟机的解释执行是基于栈的执行引擎，其中的栈指的就是操作数栈。
五、代码追踪
public void testAddOperation() {
//byte、short、char、boolean：都以int型来保存
byte i = 15;
int j = 8;
int k = 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寄存器指向的是0，也就是指令地址为0，然后使用bipush让操作数15入操作数栈。
- 执行完后，让PC寄存器 + 1，指向下一行代码，下一行代码就是将操作数栈的元素存储到局部变量表索引1的位置，我们可以看到局部变量表的已经增加了一个元素
解释为什么局部变量表索引从 1 开始，因为该方法为实例方法，局部变量表索引为 0 的位置存放的是 this
- 然后PC寄存器+1，指向的是下一行。让操作数8也入栈，同时执行 istore 操作，存入局部变量表中
- 然后从局部变量表中，依次将数据取出放在操作数栈中，等待执行 add 操作
- 将操作数栈的两个元素出栈，执行iadd操作 这里的 iadd
操作具体是：执行引擎将字节码指令翻译成机器指令，然后被CPU进行运算，得出结果，重新放入操作数栈中
关于 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;
}
面试题：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;
}
反编译后的字节码指令
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）。比如invokdynamic指令。
- 在Java源文件被编译到字节码文件中时，所有的变量和方法引用都作为符号引用（Symbolic Reference）保存在class文件的常量池里
- 比如：描述一个方法调用了另外的其他方法时，就是通过常量池中指向方法的符号引用来表示的，那么动态链接的作用就是为了将这些符号引用转换为调用方法的直接引用
在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: ()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 12: 0
line 13: 8
line 14: 12
line 15: 22
LocalVariableTable:
Start Length Slot Name Signature
0 23 0 this Lcn/sxt/java1/DynamicLinkingTest;
- 往上面翻，找到常量池的定义：
#7 = Methodref #8.#31- 先找
#8：#8 = Class #32：去找#32#32 = Utf8 cn/sxt/java1/DynamicLinkingTest- 结论：通过
#8我们找到了DynamicLinkingTest这个类
- 再来找
#31：#31 = NameAndType #19:#13：去找#19和#13#19 = Utf8 methodA：方法名为methodA- #13 = Utf8 ()V ：方法没有形参，返回值为 void
- 先找
- 结论：通过
#7我们就能找到需要调用的methodA( ) 方法，并进行调用
Constant pool:
#1 = Methodref #9.#23 // java/lang/Object."<init>":()V
#2 = Fieldref #8.#24 // cn/sxt/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/sxt/java1/DynamicLinkingTest.methodA:()V
#8 = Class #32 // cn/sxt/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/sxt/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/sxt/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
为什么要用常量池呢？
- 因为在不同的方法，都可能调用常量或者方法，所以只需要存储一份即可，然后记录其引用即可，节省了空间
- 常量池的作用：就是为了提供一些符号和常量，便于指令的识别
八、方法的调用：解析和分派
在这里插入图片描述
九、方法返回地址
十、一些附加信息
- 栈帧中还允许携带与Java虚拟机实现相关的一些附加信息。
- 例如，对程序调试提供支持的信息。
十一、栈的相关面试题
11.1 举例栈溢出的情况？（StackOverflowError）
- 通过
-Xss设置栈的大小 - 递归很容易出现溢出
11.2 调整栈大小，就能保证不出现溢出么？
- 不能
11.3 分配的栈内存越大越好么？
- 不是，一定时间内降低了栈溢出的概率，但是会挤占其它的线程空间，因为整个虚拟机的内存空间是有限的
11.4 分配的栈内存越大越好么？
- 不涉及
11.5 分配的栈内存越大越好么？
何为线程安全？
- 如果只有一个线程才可以操作此数据，则必是线程安全的。
- 如果有多个线程操作此数据，则此数据是共享数据。如果不考虑同步机制的话，会存在线程安全问题。
具体问题具体分析：
- 如果对象是在内部产生，并在内部消亡，没有返回到外部，那么它就是线程安全的，反之则是线程不安全的。
/**
* 面试题：
* 方法中定义的局部变量是否线程安全？具体情况具体分析
*
* 何为线程安全？
* 如果只有一个线程才可以操作此数据，则必是线程安全的。
* 如果有多个线程操作此数据，则此数据是共享数据。如果不考虑同步机制的话，会存在线程安全问题。
*/
public class StringBuilderTest {
//s1的声明方式是线程安全的，因为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的操作：是线程安全的，因为String是线程安全的
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();
new Thread(() -> {
s.append("a");
s.append("b");
}).start();
method2(s);
}
}
710
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
