【JVM学习笔记05】虚拟机栈

我姓弓长那个张

于 2021-11-17 20:53:16 发布

阅读量875

点赞数

分类专栏： JVM学习笔记文章标签： java 后端 jvm

本文链接：https://blog.csdn.net/zjxbayern/article/details/121387448

版权

JVM学习笔记专栏收录该内容

7 篇文章 0 订阅

订阅专栏

六、虚拟机栈

虚拟机栈描述的是 Java 方法执行的内存模型，方法的执行的同时会创建一个栈帧用于存储方法中的局部变量表、操作数栈、动态链接、方法的出口等信息。每个方法从调用直到执行完成的过程，就对应着一个栈帧在虚拟机栈中入栈到出栈的过程。

栈也叫栈内存，主管Java程序的运行，是在线程创建时创建，它的生命期是跟随线程的生命期，线程结束栈内存也就释放，对于栈来说不存在垃圾回收问题，只要线程一结束该栈就Over，生命周期和线程一致，是线程私有的。

6.1 栈帧

栈中的数据都是以栈帧（Stack Frame）的形式存在，栈帧是一个内存区块，是一个数据集，是一个有关方法(Method)和运行期数据的数据集，以用于存储方法中的局部变量表、操作数栈、动态链接、方法的出口等信息。线程中的正在执行的每个方法都对应着各自的一个栈帧。栈帧的大小主要是由局部变量表和操作数栈决定的。

6.1.1 局部变量表

虚拟机栈就是通常我们说的“栈”，或者说更多情况下指的是虚拟机栈中局部变量表部分。

局部变量表：Local Variables，被称之为局部变量数组或本地变量表。定义为一个数字数组，主要用于存储方法参数和定义在方法体内的局部变量，包括编译期可知的各种Java虚拟机基本数据类型(byte/short/int/long/char/double/float/boolean)、对象引用类型和returnAddress类型（指向一条字节码指令的地址）。【因为这三类数据都可以被写成数值的形式，所以把局部变量表定义为一个数字数组】

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

**局部变量表中的变量只在当前方法调用中有效。**在方法执行时，虚拟机通过使用局部变量表完成参数值到参数变量列表的传递过程。当方法调用结束后，随着方法栈帧的销毁，局部变量表也会随之销毁。

（1）变量槽Slot

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

局部变量表，最基本的存储单元是 Slot（变量槽）。局部变量表中存放编译期可知的各种基本数据类型（8种），引用类型（reference）、returnAddress 类型的变量。

在局部变量表里，32位以内的类型只占用一个 slot（包括 returnAddress 类型），64位的类型（long 和double）占用两个 Slot。
- byte、short、char 在存储前被转换为 int，boolean 也被转换为 int，0表示 false，非0表示 true。
- long 和 double 则占据两个 Slot。
JVM 会为局部变量表中的每一个 Slot 都分配一个访问索引，通过这个索引即可成功访问到局部变量表中指定的局部变量值。
当一个实例方法被调用的时候，它的方法参数和方法体内部定义的局部变量将会按照顺序被复制到局部变量表中的每一个 Slot 上。
如果需要访问局部变量表中一个64bit的局部变量值时，只需要使用**前一个索引（低位索引）**即可。（比如：访问 long 或double 类型变量）。

如果当前帧是由构造方法或者实例方法创建的，那么该对象引用 this 将会存放在 index 为0的 Slot 处，其余的参数按照参数表顺序继续排列。如果当前栈帧是由静态方法创建的，那么该对象的参数将会存放在index为0的Slot处，而不再是this。【如main方法的args】

（2）Slot重复利用

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

（3）静态变量与局部变量

变量的分类：

按数据类型分：基本数据类型、引用数据类型
按类中声明的位置分：成员变量（类变量，实例变量）、局部变量
- 类变量：连接的准备阶段给类变量默认赋零值，初始化阶段给类变量显式赋值，即静态代码块赋值
- 实例变量：随着对象创建，会在堆空间中分配实例变量空间，并进行默认赋值
- 局部变量：在使用前必须进行显式赋值，不然编译不通过。

参数表分配完毕之后，再根据方法体内定义的变量的顺序和作用域分配。

我们知道类变量有两次初始化的机会，第一次是在“准备阶段”，执行系统初始化，对类变量设置零值，另一次则是在“初始化”阶段，赋予程序员在代码中定义的初始值。与类变量初始化不同的是，局部变量表不存在系统初始化的过程，这意味着一旦定义了局部变量则必须人为的初始化，否则无法使用。

（4）总结

在栈帧中，与性能调优关系最为密切的部分就是前面提到的局部变量表。在方法执行时，虚拟机使用局部变量表完成方法的传递。局部变量表中的变量也是重要的垃圾回收根节点，只要被局部变量表中直接或间接引用的对象都不会被回收。

6.1.2 操作数栈

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

操作数栈，在方法执行过程中，根据字节码指令，往栈中写入数据或提取数据，即入栈(push)和出栈(pop)。某些字节码指令将值压入操作数栈，其余的字节码指令将操作数取出栈，使用它们后再把结果压入栈。即操作数栈，主要用于保存计算过程的中间结果，同时作为计算过程中变量临时的存储空间。

操作数栈就是 JVM 执行引擎的一个工作区，当一个方法刚开始执行的时候，一个新的栈帧也会随之被创建出来，这个方法的操作数栈是空的。

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

栈中的任何一个元素都可以是任意的 Java 数据类型

32bit的类型占用一个栈单位深度
64bit的类型占用两个栈单位深度

操作数栈并非采用访问索引的方式来进行数据访问的，而是只能通过标准的入栈和出栈操作来完成一次数据访问。**如果被调用的方法带有返回值的话，其返回值将会被压入当前栈帧的操作数栈中，**并更新PC寄存器中下一条需要执行的字节码指令。

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

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

6.1.3 动态链接

动态链接：每一个栈帧内部都包含一个指向运行时常量池中该栈帧所属方法的引用，包含这个引用的目的就是为了支持当前方法的代码能够实现动态链接（Dynamic Linking），即将符号引用转换为调用方法的直接引用。

在 Java 源文件被编译到字节码文件中时，所有的变量和方法引用都作为符号引用（Symbolic Reference）保存在 class 文件的常量池里。比如：描述一个方法调用了另外的其他方法时，就是通过常量池中指向方法的符号引用来表示的：

常量池的优势：

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

6.1.4 方法返回地址

存放调用该方法的 PC 寄存器的值。一个方法的结束，有两种方式：

正常执行完成
出现未处理的异常，非正常退出

无论通过哪种方式退出，在方法退出后都返回到该方法被调用的位置。方法正常退出时，调用者的 PC 计数器的值作为返回地址，即调用该方法的指令的下一条指令的地址。而通过异常退出的，返回地址是要通过异常表来确定，栈帧中一般不会保存这部分信息。本质上，方法的退出就是当前栈帧出栈的过程。此时，需要恢复上层方法的局部变量表、操作数栈、将返回值压入调用者栈帧的操作数栈、设置 PC 寄存器值等，让调用者方法继续执行下去。

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

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

执行引擎遇到任意一个方法返回的字节码指令（return），会将返回值传递给上层的方法调用者，简称正常完成出口；
一个方法在正常调用完成之后，究竟需要使用哪一个返回指令，还需要根据方法返回值的实际数据类型而定。
在字节码指令中，返回指令包含 ireturn（当返回值是 boolean，byte，char，short 和 int 类型时使用），lreturn（Long类型），freturn（Float类型），dreturn（Double类型），areturn（引用类型）。另外还有一个 return 指令声明为 void 的方法，实例初始化方法，类和接口的初始化方法使用。
在方法执行过程中遇到异常（Exception），并且这个异常没有在方法内进行处理，也就是只要在本方法的异常表中没有搜索到匹配的异常处理器，就会导致方法退出，简称**异常完成出口。**方法执行过程中抛出异常时的异常处理，存储在一个异常处理表，方便在发生异常的时候找到处理异常的代码。

6.1.5 附加信息

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

6.2 方法调用

方法调用不同于方法中代码的执行，方法调用阶段唯一的任务就是确定被调用方法的版本，暂时还未涉及方法内部的具体运行过程。在 Class 字节码文件被编译的过程中，一切方法调用都只是符号引用，而不是方法在实际运行时内存布局中的入口地址【即直接引用】，只有在某个类被加载或者甚至到运行期间才能确定目标方法的直接引用。

这里所说的方法调用并不等同于方法执行，这个阶段的唯一目的就是确定被调用方法的版本，还不涉及方法内部的具体运行过程。对于方法的版本，需要解释的就是由于重载与多态的存在，一个符号引用可能对应多个真正的方法，这就是方法的版本。在Java虚拟机中提供了5条方法调用的字节码指令，分别是：

invokestatic：调用静态方法；
invokespecial：调用实例构造器方法、私有方法和父类方法；
invokevirtual：调用所有的虚方法；
invokeinterface：调用接口方法，会在运行时再确定一个实现此接口的对象；
invokedynamic：先在运行时动态解析出调用点限定符所引用的方法，然后再执行该方法，在此之前的4条调用指令，分派逻辑都是固化在Java虚拟机中的，而invokedynamic指令的分派逻辑是由用户所设定的引导方法决定的。

只要能被invokestatic和invokespecial指令调用的方法，都可以在类加载过程中的解析阶段中确定唯一的调用版本，符合这个条件的方法有静态方法、私有方法、实例构造器和父类方法四种，它们在类加载过程中的解析阶段就会将符号引用解析为该方法的直接引用。这些方法可以称为非虚方法（也就是不涉及到多态的方法），与之对应的就是虚方法（也就是涉及到多态的方法）。虚方法需要在运行阶段才能确定目标方法的直接引用。这样，对于方法的调用就分为两种，一种可以在类加载过程中的解析阶段完成，另一种要在运行时完成，叫做分派。

6.2.1 解析—非虚方法

类加载阶段的解析，不光涉及到方法的解析，还会涉及到包、类、字段和动态调用点的解析。此部分仅是涉及到方法的解析。

所有方法调用的目标方法在 Class 文件里面都是一个常量池中的符号引用。在类加载阶的解析阶段，会将常量池中的一部分符号引用转化为直接引用，这种解析能成立的前提是：方法在程序真正运行之前就有一个可确定的调用版本，并且这个方法的调用版本在运行期间不会发生变化。换句话说，调用目标在程序代码写好、编译器在编译的那一刻就已经确定下来了。这类方法调用被称为“解析”。

上述符合“编译器可知，运行期不可变”这个要求的方法，主要有静态方法、私有方法、实例构造器、父类方法和final方法，它们都适合在类加载阶段进行解析，在类加载阶段就可以把符号引用解析为该方法的直接引用。这些方法统称为“非虚方法”。

6.2.2 分派—虚方法

上述方法的解析调用是一个静态的过程，在编译期间就完全确定，在类加载的解析阶段就会把涉及的可以确定的符号引用全部转化为直接引用，不必延迟到运行期间去完成。而另外一种形式叫做“分派”。

Java 具有面向对象的三大特征：封装、继承和多态。本部分的分派调用过程将会揭示多态的底层实现，如“重载”与“重写”在JVM中的实现方式。

（1）静态分派与重载

当一个字节码文件被装载进 JVM 内部时，如果被调用的目标方法在编译期可知，且运行期保持不变时，这种情况下将调用方法的符号引用转换为直接引用的过程称之为静态分派【静态链接】。

package com.wen.demo.test.MyClass;
 
/**
 * 静态分配案例
 * @author wen
 */
public class StaticDispatch {
    public void hello(Human human) {
        System.out.println("呵·人类");
    }
 
    public void hello(WoMan woMan) {
        System.out.println("呵·女人");
    }
 
    public void hello(Man man) {
        System.out.println("呵·男人");
    }
 
    public static void main(String[] args) {
 
        StaticDispatch staticDispatch = new StaticDispatch();
        Human human = new WoMan();
        Human human1 = new Man();
        staticDispatch.hello(human);
        staticDispatch.hello(human1);
    }
}
 
/**
 * 继承关系
 */
abstract class Human {
 
}
 
class Man extends Human {
 
}
 
class WoMan extends Human {
 
}

首先了解两个概念：静态类型、实际类型。

Human human = new WoMan();
Human human1 = new Man();

上面代码中“Human“称为变量的静态类型，而“WoMan”和“Man”我们称为变量的实际类型。静态类型变量和实际类型变量在程序运行过程中都会发生变化，区别是：

静态类型的变化仅仅在使用时才发生，变量本身的静态类型是不会被改变，并且最终静态类型在编译期是可知的。
实际类型的变化是在运行期才知道，编译器在编译程序时并不知道一个对象的具体类型是什么。

在上述代码中，main()方法两次调用了 sayHello() 方法，在方法接收者已经确定是对象“staticDispatch”的前提下，使用哪个方法的重载版本就完全取决于传入参数的数量与数据类型。代码中定义了两个静态类型相同，而实际类型不同的变量（man与woman），编译器在重载时会通过参数的静态类型来作为判定使用哪个重载方法的依据，而不是使用实际类型作为判定依据。由于静态类型在编译期可知，所以在编译阶段，编译器就根据参数的静态类型决定了使用哪个重载版本。

所有依赖静态类型来决定方法执行版本的分派动作，都称为静态分派。

注意一：变量的静态类型发生变化的情况

可通过 强制类型转换 改变变量的静态类型：

Human man = new Man(); 

// 强制类型转换
// 此时man的静态类型从 Human 变为 Man
test.sayHello((Man)man); 
// 所以会调用sayHello()中参数为Man guy的方法，即sayHello(Man guy)

注意二：静态分派的优先级匹配问题

静态分派发生在编译阶段，因此确定静态分派的动作实际上不是有虚拟机来完成的。需要注意虚拟机虽然能确定出方法的重载版本，但在很多情况下这个重载版本并不是“唯一”的，往往只能确定一个“相对更合适的”版本。产生这种现象的原因是字面量天生的模糊性，它不需要定义，所以字面量就没有显式的静态类型，它的静态类型只能通过语言、语法的规则去理解和推断。

public class Overload {  

    private static void sayHello(char arg){  
        System.out.println("hello char");  
    }  

    private static void sayHello(Object arg){  
        System.out.println("hello Object");  
    }  

    private static void sayHello(int arg){  
        System.out.println("hello int");  
    }  

    private static void sayHello(long arg){  
        System.out.println("hello long");  
    }  

    // 测试代码
    public static void main(String[] args) {  
		// 参数类型为字面量，没有显式的静态类型
        sayHello('a');  
    }  

}  

// 运行结果
// hello char

上述代码的运行流程：

因为‘a’是一个char类型数据（即静态类型是char），所以会选择参数类型为char的重载方法；
若注释掉sayHello(char arg)方法，那么会输出 hello int；因为‘a’除了可代表字符，还可代表数字97。因此当没有最合适的sayHello(char arg)方式进行重载时，会选择第二合适的方法重载，即sayHello(int arg)。以此类推。

优先级顺序为：char>int>long>float>double>Character>Serializable>Object>...

因此，当程序中没有显示指定静态类型时，程序会根据静态类型的优先级从而选择优先的静态类型进行方法分配。

（2）动态分派与重写

如果被调用的方法在编译期无法被确定下来，也就是说，只能够在程序运行期将调用的方法的符号转换为直接引用，由于这种引用转换过程具备动态性，因此也被称之为动态分派【动态链接】。

public class DynamicDispatch {
    static abstract class Human{
        protected abstract void sayHello();
    }
    static class Man extends Human{
        public void sayHello(){
            System.out.println("Hello gentleman");
        }
    }
    static class Woman extends Human{
        public void sayHello(){
            System.out.println("Hello lady");
        }
    }
    public static void main(String[] args) {
        Human man=new Man();
        Human woman=new Woman();
        man.sayHello();
        woman.sayHello();
        man=new Woman();
        man.sayHello();
    }
}

显然这不是根据静态类型决定的，因为两个对象的静态类型都是Human。但是调用的结果却不同，这是因为这两个对象的实际类型不同。所以，Java虚拟机是通过实际类型来判断要调用方法的版本的。

解析一下上述代码的字节码指令：

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           #2                  // class temp/DynamicDispatch$Man
         3: dup
         4: invokespecial #3                  // Method temp/DynamicDispatch$Man."<init>":()V
         7: astore_1
         8: new           #4                  // class temp/DynamicDispatch$Woman
        11: dup
        12: invokespecial #5                  // Method temp/DynamicDispatch$Woman."<init>":()V
        15: astore_2
        16: aload_1
        17: invokevirtual #6                  // Method temp/DynamicDispatch$Human.sayHello:()V
        20: aload_2
        21: invokevirtual #6                  // Method temp/DynamicDispatch$Human.sayHello:()V
        24: new           #4                  // class temp/DynamicDispatch$Woman
        27: dup
        28: invokespecial #5                  // Method temp/DynamicDispatch$Woman."<init>":()V
        31: astore_1
        32: aload_1
        33: invokevirtual #6                  // Method temp/DynamicDispatch$Human.sayHello:()V
        36: return

0~15行是准备阶段，是为了建立man和woman的内存空间，调用man和woman的类实例构造器，然后将这两个实例的引用放在局部变量表中的第一和第二的位置。

接下来的16~21是方法调用的关键。16、20两句分别把刚才创建的两个对象的引用压入栈顶，这两个对象是将要执行的sayHello方法的所有者，称为接收者；17和21两句诗方法调用指令，这两条指令在这里看来都是一样的，指令都是invokevirtual，参数也都是一样的，但这两条指令最终执行的结果却不同。原因就在invokevirtual指令的多态查找过程上。invokevirtual指令的运行时解析过程大致分为以下几个步骤：

找到操作数栈顶的第一个元素所指向的对象的实际类型，记为C；
如果在类型C中找到与常量中的描述符和简单名称一样的方法，则进行访问权限校验，如果通过则返回这个方法的直接引用，查找过程结束；如果不通过，返回java.lang.IllegalAccessError异常；
否则，按照继承关系从下到上依次对C的各个父类进行搜索和验证；
如果还没有找到合适的方法，抛出java.lang.AbstractMethodError异常。

由于invokevirtual指令执行的第一步就是在运行期间确定接收者的实际类型，所以两次调用中的invokevirtual指令把常量池中的类方法符号引用解析到了不同的直接引用上，并根据方法接收者的实际类型来选择方法版本，这个过程就是Java语言中方法重写的本质。这种在运行期根据实际类型确定方法执行版本的分派过程叫做动态分派。多态性的根源在于虚方法调用指令invokevirtual的执行逻辑。

6.3 虚拟机栈异常

Java虚拟机规范允许Java栈的大小是动态的或者是固定不变的。

6.3.1 StackOverflowError（SOF）

如果采用固定大小的Java虚拟机栈，那每一个线程的Java虚拟机栈容量可以在线程创建的时候独立选定。如果线程请求分配的栈容量超过Java虚拟机栈允许的最大容量，Java虚拟机将抛出一个栈溢出错误StackOverFlowError

/**
 * 演示栈中的错误：StackOverflowError
 */
public class StackErrorTest {
    public static void main(String[] args) {
        main(args);		// 循环调用或递归都可能会产生StackOverflowError异常
    }
}

解决办法：我们可以使用参数-Xss来设置线程的最大栈空间，栈的大小直接决定了函数调用的最大可达深度。

在这里插入图片描述

6.3.2 OutOfMemoryError（OOM）

如果Java虚拟机栈可以动态拓展【HotSpot不支持动态扩展，所以只能抛出SOF】，并且在尝试拓展的时候无法申请到足够的内存，或者在创建新的线程时没有足够的内存去创建对应的虚拟机栈，那Java虚拟机将会抛出一个 OutOfMemoryError异常。

6.4 运行原理

JVM直接对Java栈的操作只有两个，就是对栈帧的压栈和出栈，遵循先进后出(FILO)的和原则：

在一条活动线程中，一个时间点上，只会有一个活动的栈帧。即只有当前正在执行的方法的栈帧(栈顶栈帧)是有效的，这个栈帧被称为当前栈帧(Current Frame)，与当前栈帧对应的方法就是当前方法(Current Frame)
执行引擎运行的所有字节码指令只针对当前栈帧进行操作
如果在该方法中调用了其他方法，对应的新的栈帧会被创建出来，放在栈的顶端，成为新的当前栈帧
不同线程中所包含的栈帧是不允许相互引用的，即不可能在另一个栈帧中引用另外一个线程的栈帧
如果当前方法调用了其他方法，方法返回之际，当前栈帧会传回此方法的执行结果给前一个栈帧，接着，虚拟机会丢弃当前栈帧，使得前一个栈帧重新成为当前栈帧
Java方法有两种返回函数的方式，一种是正常的函数返回，使用return指令；另外一种是抛出异常，不管使用哪种方式，都会导致栈帧被弹出

在这里插入图片描述