虚拟机栈

1.背景

前面讲过，因为Java虚拟机想要做跨平台的设计，而基于寄存器的结构对不同的CPU是不同的，所以Java的指令都是根据栈来设计的。

1.1优点

跨平台
指令集小
编译器实现比较容易

1.2缺点

性能下降
指令更多

2.内存中栈和堆的介绍

栈：解决程序运行时的问题，即程序如何执行，如何处理数据
堆：解决的是数据存储的问题，即数据怎么放，往哪儿放

2.1举例

下图为广东一道名菜，“佛跳强”的制作方式以及图片，以红色的线为分割，左边我们可以理解为栈区，食材明细可以理解为变量，而做法步骤则理解为操作指令。右边理解为堆区，用来解决存放食材，以及食材怎么放的问题。

3.Java虚拟机栈介绍

3.1概述

Java虚拟机栈（Java Virtual Machine Stack），每个线程在创建的时候，都会创建一个虚拟机栈，内部保存着一个一个的栈帧Stack Frame（栈里存储数据的基本单元），一个栈帧对应着一个Java方法，栈帧里面又包含局部变量表等等。

3.2生命周期

虚拟机栈的生命周期与线程的创建而创建，与线程的消亡而消亡

3.3栈的作用

主管Java程序的运行，它保存方法的局部变量(8种基本数据类型，对象的引用地址（引用数据对象真正的数据是存在堆空间中的）)、部分结果，并参与方法的调用和返回。

局部变量与成员变量的区分
基本数据类型的变量与引用类型的变量（类，数组，接口）

3.4栈帧举例画图

解释：在执行方法A的时候，方法A入栈，方法A中又调用方法B，所以方法B入栈变为当前方法，方法B结束后，出栈，然后方法A变为当前方法，方法A结束后，程序结束。

未命名文件 (4)

3.5虚拟机栈的优点

栈是一种快速有效的分配存储方式，访问速度仅次于程序计数器
JVM对Java栈的操作只有2个
- 每个方法执行，伴随着入栈
- 执行结束后的出栈工作
栈不存在垃圾回收（GC）问题（会OOM哦）

4.虚拟机栈可能会出现的异常

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

4.1栈溢出

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

4.2内存溢出

如果Java虚拟机栈是动态扩展的，如果在尝试扩展的时候无法申请到足够的内存，Java虚拟机将会抛出一个OutOfMemoryError异常。
如果在创建新的线程的时候，没有足够的内存去创建对应的虚拟机栈，Java虚拟机将会抛出一个OutOfMemoryError异常。

4.3举例栈溢出

写一个简单的没有出口的递归方法，会导致栈中出现非常多的栈帧，每个里面都存了很多的局部变量等等，最后导致了StackOverflowError的异常。

public class StackErrorTest {
    public static void main(String[] args) {
        main(args);
    }
}

结果,StackOverflowError

Exception in thread \"main\" java.lang.StackOverflowError
	at test.StackErrorTest.main(StackErrorTest.java:5)
	at test.StackErrorTest.main(StackErrorTest.java:5)
	...

5.设置栈内存参数

-Xss[size][unit]
例：-Xss256k

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

public class StackDeepTest{ 
    private static int count=0; 
    public static void recursion(){
        count++; 
        recursion(); 
    }
    public static void main(String args[]){
        try{
            recursion();
        } catch (Throwable e){
            System.out.println(\"deep of calling=\"+count); 
            e.printstackTrace();
        }
    }
}

6.栈的存储单位

每个线程都有自己的栈，栈中的数据都是以栈帧（Stack Frame）格式的存在
在这个线程上正在执行的每个方法都各自对应一个栈帧。
栈帧是一个内存区块，是一个数据集，维系着方法执行过程中的各种数据的信息。

6.1栈运行原理

JVM对Java虚拟机的操作只有2个，一个是对栈帧的压栈（入栈），另一个是出栈
一个线程的某一个时间点上，只会有一个活动的栈帧，即是当前栈帧（current Frame），对应的也就是当前正在执行的方法，此方法称为当前方法，定义这个方法的类，就是当前类（current class）。
执行引擎运行的所有字节码指令都是只针对当前栈帧进行解释执行
如果a方法中调用了b方法，则b方法对应的栈帧会被创建出来，放在Java虚拟机栈的顶端，成为当前栈帧。
不同线程中所包含的栈帧是不允许存在互相引用的，线程私有的
如果当前方法调用了其他方法，方法返回之际，当前栈帧会传回此方法的执行结果给前一个栈帧，接着虚拟机会丢弃当前栈帧，使得前一个栈帧重新成为当前栈帧
Java方法有两种返回函数的方式，一种是使用return指令（无返回值的return指令可以忽略，虚拟机会帮我们加上），另一种是抛出异常。

6.2举例DEBUG过程，演示栈帧（IDEA）

我们写下面一段程序，有3个方法，互相调用

public class StackFramesTest {
    public static void main(String[] args) {
        StackFramesTest.method1();
    }
    public static void method1(){
        System.out.println(\"\");
        method2();
    }
    public static void method2(){
        System.out.println(\"\");
        method3();
    }
    public static void method3(){
        System.out.println(\"\");
    }
}

使用IDEA，在method3中打一个断点，进行DEBUG,查看IDEA中显示的Frames的情况，method3为当前栈帧，可以看到方法的调用关系。

当我们结束method3，回到method2 的时候，mehtod3的栈帧就会被丢弃，method2成为当前方法，对应着当前栈帧。

6.3栈帧的内部结构

每个栈帧中存储着

局部变量表(Local Variables)
操作数栈(Operand Stack)(或表达式栈)
动态链接（Dynamic Linking）（或指向运行时常量池的方法引用）
方法返回地址（Return Address）（或方法正常退出或者异常退出的定义）
一些附加信息

并行每个线程下的栈都是私有的，因此每个线程都有自己各自的栈，并且每个栈里面都有很多栈帧，栈帧的大小主要是由局部变量表（主要是变量的声明等等）和操作数栈(主要是代码的复杂程度)来决定的。

7.局部变量表（Local Variables）

7.1介绍

局部变量表也被称为局部变量数组或本地变量表

定义为一个数字数组，主要用于存储方法参数和定义在方法体内的局部变量，这些数据类型包括各类基本数据类型，对象引用（reference），以及returnAddress类型.
由于局部变量表是方法内部的，是建立在线程的栈上，是线程私有的数据，因此不存在数据安全问题。
局部变量表所需要数组长度的大小是在编译期间就确定下来了，并且保存在方法的Code属性的maximum local variables数据项中，方法运行期间是不会改变局部变量表的数组大小的。
方法嵌套的深度由栈的大小决定，这个就比较简单了
局部变量表的变量只在当前方法中有效，在方法执行时，虚拟机通过使用局部变量表完成参数值到参数变量列表的传递过程。当方法调用结束后，随着方法栈帧的销毁，局部变量表也会随之销毁。

7.2字节码中方法内部结构刨析

举例

对这段代码，先编译为class文件，再对class文件使用javap反编译字节码指令

public class LocalVariables {
    public static void main(String[] args) {
        int i = 10;
        LocalVariables localVariables = new LocalVariables();
        System.out.println(i);
    }
}

7.3slot介绍

Slot是局部变量表的基本存储单元
局部变量表中存放编译期可知的各种基本数据类型，引用数据类型（reference），retrunAddress类型的变量。
在局部变量表里，32位以内的类型只占用一个Slot(引用数据类型，returnAddress类型，byte、short、char在存储前被转换为int，boolean也被转换为int，0表示false，非0表示true)，64位的类型（long和double）占据两个Slot
JVM会给局部变量表里的每个Slot都分配一个索引，通过此索引即可成功访问到局部变量表中指定的局部变量值
当一个实例方法被调用的时候，它的方法参数和该方法内部定义的局部变量将会按照变量声明的顺序，被复制到局部变量表的每一个Slot上。
如果需要访问局部变量表中一个64bit的局部变量时候，只需要使用前一个索引即可
如果当前帧是由构造方法或者是实例方法创建的，那么此对象的引用(this)，将会存放在index位0的Slot处，剩下的按照顺序继续排列。这也就是为什么在非静态方法里可以使用this.xx这样使用。

7.4Slot的重复利用

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

public class SlotTest {
    public void test4() {
        int a = 0;
        {
            int b = 0;
            b = a + 1;
        }
        int c = a + 1;
    }
    //这段代码编译后的局部变量表的长度就会是3，因为c会复用b的槽位
}

7.6变量的分类复习

按照数据类型分类

基本数据类型
引用数据类型

按照在类中声明的位置分类

成员变量：在使用前，都经历过初始化复制。
- 类变量（静态变量）：Linking的prepare阶段，给变量默认复制。inital...阶段，为变量显示赋值
- 实例变量：跟随着对象的创建，会在堆空间中分配实例的变量空间，并进行默认赋值
局部变量：在使用前必须要进行显示赋值

public void test(){
    int i;
    System. out. println(i);//这行代码会编译的时候就报错
}

7.7补充说明（调优）

在栈帧中，与性能调优关系最密切的部分就是局部变量表。

在方法执行的时候，虚拟机使用局部变量表完成方法的传递。
局部变量表中的变量也是最重要的垃圾回收根节点，只要被局部变量表中直接引用或者间接引用的对象，都不会被回收。

8.操作数栈（Operand Stack）

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

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

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

操作数栈，主要用于保存计算过程的中间结果，同时作为计算过程中变量临时的存储空间
操作数栈就是JVM执行引擎的一个工作区，当一个方法刚开始执行的时候，一个新的栈帧也会随之被创建出来，一创建出来的时候，这个方法的操作数栈，包括局部变量表等都是空的。
Java代码在编译后，每一个操作数栈都有明确的栈深度用于存储数据，操作数栈的最大深度，局部变量表数组的长度，均是在编译期间就定义好了，保存在方法的Code属性中。
栈中的任何一个元素都可以是任意的Java数据类型
- 32位的类型占用一个栈单位深度
- 64位的类型占用两个栈单位深度
操作数栈并非采用访问索引的方式来访问数据，而是只能通过标准的入栈(push)和出栈(pop)操作来完成一次数据的访问。
如果被调用的方法带有返回值的话，其返回值将会被压入当前栈帧的操作数栈中，并更新PC寄存器中下一条需要执行的字节码指令。
操作数栈中元素的数据类型必须与字节码指令的序列严格匹配，这由编译器在编译器期间进行验证，同时在类加载过程中的类检验阶段的数据流分析阶段要再次验证。
另外，我们说Java虚拟机的解释引擎是基于栈的执行引擎，其中的栈指的就是操作数栈。

8.1代码追踪

public class OperandStack {
    public static void main(String[] args) {
        byte i = 15;
        int j =8;
        int k = i + j;
    }
}

使用javap 命令反编译class文件：javap -v 类名.class

 public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=4, args_size=1     
         0: bipush        15             //往操作数栈中存入byte类型的15，存为int类型
         2: istore_1                     //从操作数栈中取出int类型的15放入局部变量表为1的位置
         3: bipush        8              //8入栈
         5: istore_2                     //出栈一个，放入局部变量表2的位置
         6: iload_1                      //加载局部变量表1的位置，并入栈
         7: iload_2                      //加载局部变量表2的位置，入栈
         8: iadd                         //取出栈中的数字求和，然后再将结果入栈
         9: istore_3                     //出栈一个，放入局部变量表3的位置
        10: return                       //无返回值，结束                
 //局部变量表
  LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      11     0  args   [Ljava/lang/String;
            3       8     1     i   B
            6       5     2     j   I
           10       1     3     k   I

8.2栈顶缓存技术

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

由于操作数是存储在内存中的，因此频繁地执行内存读/写操作必然会影响执行速度。为了解决这个问题，HotSpot JVM的设计者们提出了栈顶缓存（Tos，Top-of-Stack Cashing）技术，将栈顶元素全部缓存在物理CPU的寄存器中，以此降低对内存的读/写次数，提升执行引擎的执行效率。

来源：https://www.cnblogs.com/fypblogs/p/15982363.html
本站部分图文来源于网络，如有侵权请联系删除。

JVM上篇：虚拟机栈