当前位置:

首页 > 编程开发 > Java教程 >

八、运行时栈帧结构

回到顶部

1、局部变量表

1.1、局部变量表介绍

局部变量表：Local Variables，也被称之为局部变量数组或本地变量表。

定义为一个数字数组，主要用于存储方法参数和定义在方法体内的局部变量，这些数据类型包括各类基本数据类型、对象引用（reference），以及 returnAddress(返回值) 类型。

由于局部变量表是建立在线程的栈上，是线程的私有数据，因此不存在数据安全问题。

局部变量表所需的容量大小是在编译期确定下来的，并保存在方法的Code属性的maximum local variables数据项中。在方法运行期间是不会改变局部变量表的大小的。

方法嵌套调用的次数由栈的大小决定。一般来说，栈越大，方法嵌套调用次数越多。

　　对一个函数而言，它的参数和局部变量越多，使得局部变量表膨胀，它的栈帧就越大，以满足方法调用所需传递的信息增大的需求。

　　进而函数调用就会占用更多的栈空间，导致其嵌套调用次数就会减少。

局部变量表中的变量只在当前方法调用中有效。

在方法执行时，虚拟机通过使用局部变量表完成参数值到参数变量列表的传递过程。

当方法调用结束后，随着方法栈帧的销毁，局部变量表也会随之销毁。

2.2、关于Slot的理解

参数值的存放总是从局部变量数组索引 0 的位置开始，到数组长度-1的索引结束。

局部变量表，最基本的存储单元是Slot（变量槽）。

局部变量表中存放编译期可知的各种基本数据类型（8种），引用类型（reference），returnAddress类型的变量。

在局部变量表里，32位以内的类型只占用一个slot（包括引用类型、returnAddress类型），64位的类型（long和double）占用两个slot。

byte、short、char 在存储前被转换为int，boolean 也被转换为int，0 表示false，非0 表示true。

JVM会为局部变量表中的每一个Slot都分配一个访问索引，通过这个索引即可成功访问到局部变量表中指定的局部变量值。

当一个实例方法被调用的时候，它的方法参数和方法体内部定义的局部变量将会按照顺序被复制到局部变量表中的每一个slot上。

如果需要访问局部变量表中一个64bit的局部变量值时，只需要使用前一个索引即可。（比如：访问long或double类型变量）。

如果当前帧是由构造方法或者实例方法(非静态方法，static方法无法调用this) 创建的，那么该对象引用this 将会存放在index为0 的slot处，其余的参数按照参数表顺序继续排列。

2.3、Slot的重复使用

栈帧中的局部变量表中的槽位是可以重用的，如果一个局部变量出了其作用域，那么在其作用域之后声明新的局部变量就很有可能会复用过期局部变量的槽位，从而达到节省资源的目的。

1 public void test4() {
2         int a = 0;
3         {
4             int b = 0;
5             b = a + 1;
6         }
7         //变量c使用 之前已经销毁的变量b占据的slot的位置
8         int c = a + 1;
9     }

回到顶部

2、操作数栈(Operand Stack)

2.1、操作数栈的特点

每一个独立的栈帧除了包含局部变量表以外，还包含一个后进先出的操作数栈，也可以称之为表达式栈（Expression Stack）。

操作数栈，在方法执行过程中，根据字节码指令，往栈中写入数据或提取数据，即入栈（push）和出栈（pop）。

某些字节码指令将值压入操作数栈，其余的字节码指令将操作数取出栈。使用它们后再把结果压入栈，比如：执行复制、交换、求和等操作。

2.2、操作数栈的作用

操作数栈，主要用于保存计算过程的中间结果，同时作为计算过程中变量临时的存储空间。

操作数栈就是JVM执行引擎的一个工作区，当一个方法刚开始执行的时候，一个新的栈帧也会随之被创建出来，这个时候方法的操作数栈是空的（这个时候数组是创建好并且是长度固定的，但数组的内容为空）。

每一个操作数栈都会拥有一个明确的栈深度用于存储数值，其所需的最大深度在编译期就定义好了，保存在方法的Code属性中，为maxstack的值。

栈中的任何一个元素都是可以任意的Java数据类型。
32bit的类型占用一个栈单位深度
64bit的类型占用两个栈单位深度

操作数栈并非采用访问索引的方式来进行数据访问的，而是只能通过标准的入栈和出栈操作来完成一次数据访问。

如果被调用的方法带有返回值的话，其返回值将会被压入当前栈帧的操作数栈中，并更新PC寄存器中下一条需要执行的字节码指令。

操作数栈中元素的数据类型必须与字节码指令的序列严格匹配，这由编译器在编译器期间进行验证，同时在类加载过程中的类检验阶段的数据流分析阶段要再次验证。

另外，我们说Java虚拟机的解释引擎是基于栈的执行引擎，其中的栈指的就是操作数栈。

2.3、代码追踪

1 public void testAddOperation() {
2         //byte、short、char、boolean：都以int型来保存
3         byte i = 15;
4         int j = 8;
5         int k = i + j;
6 }

 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 操作，存入局部变量表中

将操作数栈的两个元素出栈，执行iadd操作
这里的 iadd 操作具体是：执行引擎将字节码指令翻译成机器指令，然后被CPU进行运算，得出结果，重新放入操作数栈中

2.4、栈顶缓存技术(Top Of Stack Cashing)

前面提过，基于栈式架构的虚拟机所使用的零地址指令更加紧凑，但完成一项操作的时候必然需要使用更多的入栈和出栈指令，这同时也就意味着将需要更多的指令分派（instruction dispatch）次数和内存读/写次数。

由于操作数是存储在内存中的，因此频繁地执行内存读/写操作必然会影响执行速度。为了解决这个问题，HotSpot JVM的设计者们提出了栈顶缓存（Tos，Top-of-Stack Cashing）技术。

将栈顶元素全部缓存在物理CPU的寄存器中，以此降低对内存的读/写次数，提升执行引擎的执行效率。

寄存器的主要优点：指令更少，执行速度快。

尽管我们都已经知道HotSpot的执行引擎采用的并非是基于寄存器的架构，但这并不代表HotSpot VM的实现并没有间接利用到寄存器资源。

寄存器是物理CPU中的组成部分之一，它同时也是CPU中非常重要的高速存储资源。一般来说，寄存器的读/写速度非常迅速，甚至可以比内存的读/写速度快上几十倍不止，不过寄存器资源却非常有限，不同平台下的CPU寄存器数量是不同和不规律的。

寄存器主要用于缓存本地机器指令、数值和下一条需要被执行的指令地址等数据。

回到顶部

3、动态链接

动态链接（或指向运行时常量池的方法引用）

每一个栈帧内部都包含一个指向运行时常量池中该栈帧所属方法的引用

包含这个引用的目的就是为了支持当前方法的代码能够实现动态链接（Dynamic Linking），比如：invokedynamic指令。

在Java源文件被编译到字节码文件中时，所有的变量和方法引用都作为符号引用（Symbolic Reference）保存在class文件的常量池里。

比如：描述一个方法调用了另外的其他方法时，就是通过常量池中指向方法的符号引用来表示的，那么动态链接的作用就是为了将这些符号引用转换为调用方法的直接引用。

为什么要用常量池？

因为在不同的方法，都可能调用常量或者方法，所以只需要存储一份即可，然后记录其引用即可，节省了空间
常量池的作用：就是为了提供一些符号和常量，便于指令的识别

回到顶部

4、方法返回地址

存放调用该方法的程序计数器的值。

一个方法的结束，有两种方式：
正常执行完成
出现未处理的异常，非正常退出

无论通过哪种方式退出，在方法退出后都返回到该方法被调用的位置。方法正常退出时，调用者的程序计数器的值作为返回地址，即调用该方法的指令的下一条指令的地址。而通过异常退出的，返回地址是要通过异常表来确定，栈帧中一般不会保存这部分信息。

本质上，方法的退出就是当前栈帧出栈的过程。此时，需要恢复上层方法的局部变量表、操作数栈、将返回值压入调用者栈帧的操作数栈、设置程序计数器值等，让调用者方法继续执行下去。

正常完成出口和异常完成出口的区别在于：通过异常完成出口退出的不会给他的上层调用者产生任何的返回值。

方法退出的两种方式：

1、当一个方法开始执行后，只有两种方式可以退出这个方法：

　　执行引擎遇到任意一个方法返回的字节码指令（return），会有返回值传递给上层的方法调用者，简称正常完成出口。

　　一个方法在正常调用完成之后，究竟需要使用哪一个返回指令，还需要根据方法返回值的实际数据类型而定。

　　在字节码指令中，返回指令包含：
　　ireturn：当返回值是boolean，byte，char，short和int类型时使用
　　lreturn：Long类型
　　freturn：Float类型
　　dreturn：Double类型
　　areturn：引用类型
　　return：返回值类型为void的方法、构造器、类和接口的初始化方法

2、在方法执行过程中遇到异常（Exception），并且这个异常没有在方法内进行处理，也就是只要在本方法的异常表中没有搜索到匹配的异常处理器，就会导致方法退出，简称异常完成出口。

　　方法执行过程中，抛出异常时的异常处理，存储在一个异常处理表，方便在发生异常的时候找到处理异常的代码。

异常处理表

反编译字节码文件，可得到 Exception table
from ：字节码指令起始地址
to ：字节码指令结束地址
target ：出现异常跳转至地址为 11 的指令执行
type ：捕获异常的类型

回到顶部

5、一些附加信息

栈帧中还允许携带与Java虚拟机实现相关的一些附加信息。例如：对程序调试提供支持的信息。

回到顶部

6、栈的相关面试题

举例栈溢出的情况？（StackOverflowError）

　　通过 -Xss 设置栈的大小

　　递归很容易出现栈溢出

调整栈大小，就能保证不出现溢出么？

　　不能保证不出现溢出，只能让栈溢出出现的时间晚一点，不可能不出现。

分配的栈内存越大越好么？

　　不是，一定时间内降低了栈溢出的概率，但是会挤占其它的线程空间，因为整个虚拟机的内存空间是有限的

垃圾回收是否涉及到虚拟机栈？

　　不涉及

方法中定义的局部变量是否线程安全？

　　何为线程安全？

如果只有一个线程才可以操作此数据，则必是线程安全的。
如果有多个线程操作此数据，则此数据是共享数据。如果不考虑同步机制的话，会存在线程安全问题。

　　具体问题具体分析：

　　如果对象是在内部产生，并在内部消亡，没有返回到外部，那么它就是线程安全的，反之则是线程不安全的。

 1 /**
 2  * 面试题：
 3  * 方法中定义的局部变量是否线程安全？具体情况具体分析
 4  *
 5  *   何为线程安全？
 6  *      如果只有一个线程才可以操作此数据，则必是线程安全的。
 7  *      如果有多个线程操作此数据，则此数据是共享数据。如果不考虑同步机制的话，会存在线程安全问题。
 8  */
 9 public class StringBuilderTest {
10 
11     //s1的声明方式是线程安全的，因为s1只在方法内部操作，属于局部变量
12     public static void method1(){
13         //StringBuilder:线程不安全
14         StringBuilder s1 = new StringBuilder();
15         s1.append("a");
16         s1.append("b");
17         //...
18     }
19 
20     //sBuilder通过参数传递方法内，存在线程不安全的问题
21     public static void method2(StringBuilder sBuilder){
22         sBuilder.append("a");
23         sBuilder.append("b");
24         //...
25     }
26 
27     //操作s1之后，将s1作为返回值返回，这样可能被其他线程所调用，所以存在线程不安全的问题
28     public static StringBuilder method3(){
29         StringBuilder s1 = new StringBuilder();
30         s1.append("a");
31         s1.append("b");
32         return s1;
33     }
34 
35     //s1的操作：是线程安全的，因为String是线程安全的
36     public static String method4(){
37         StringBuilder s1 = new StringBuilder();
38         s1.append("a");
39         s1.append("b");
40         return s1.toString();
41     }
42 
43     public static void main(String[] args) {
44         StringBuilder s = new StringBuilder();
45 
46         new Thread(() -> {
47             s.append("a");
48             s.append("b");
49         }).start();
50 
51         method2(s);
52     }
53 }