由于blog各种垃圾评论太多,而且本人审核评论周期较长,所以懒得管理评论了,就把评论功能关闭,有问题可以直接qq骚扰我

JVM—虚拟机栈

JAVA 西门飞冰 273℃
[隐藏]

1.JVM内存结构位置

image-20220927225202917

2.虚拟机栈概述

2.1.Java虚拟机栈是什么

Java虚拟机栈(Java Virtual Machine Stack),早期也叫Java栈。每个线程在创建时都会创建一个虚拟机栈,其内部保存一个个的栈帧(Stack Frame),对应着一次次的Java方法调用,栈是线程私有的

代码说明:

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;
    }
}

 image-20220922224302185

  • 虚拟机栈的生命周期
    • 生命周期和线程一致,也就是线程结束了,该虚拟机栈也销毁了
  • 虚拟机栈的作用
    • 主管Java程序的运行,它保存方法的局部变量(8 种基本数据类型、对象的引用地址)、部分结果,并参与方法的调用和返回。
    • 局部变量,它是相比于成员变量来说的(或属性)
    • 基本数据类型变量 VS 引用类型变量(类、数组、接口)

2.2.内存中的栈与堆

1、首先栈是运行时的单位,而堆是存储的单位。

2、即:栈解决程序的运行问题,即程序如何执行,或者说如何处理数据。堆解决的是数据存储的问题,即数据怎么放,放哪里

image-20220922223716439

2.3.虚拟机栈的特点(优点)

  • 栈是一种快速有效的分配存储方式,访问速度仅次于程序计数器。
  • JVM直接对Java栈的操作只有两个:
    • 每个方法执行,伴随着进栈(入栈、压栈)
    • 执行结束后的出栈工作
  • 对于栈来说不存在垃圾回收问题
    • 栈不需要GC,但是可能存在OOM

2.4.虚拟机栈的常见异常

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

  • 如果采用固定大小的Java虚拟机栈,那每一个线程的Java虚拟机栈容量可以在线程创建的时候独立选定。如果线程请求分配的栈容量超过Java虚拟机栈允许的最大容量,Java虚拟机将会抛出一个StackoverflowError 异常。
  • 如果Java虚拟机栈可以动态扩展,并且在尝试扩展的时候无法申请到足够的内存,或者在创建新的线程时没有足够的内存去创建对应的虚拟机栈,那Java虚拟机将会抛出一个 OutofMemoryError 异常。
//模拟栈中的异常:StackOverflowError
public class StackErrorTest {
    public static void main(String[] args) {
        main(args);
    }
}

2.5.设置栈内存大小

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

以下示例设置不同单位的1024KB线程大小:

-Xss1m
-Xss1024k
-Xss1048576

设置效果演示:

public class StackErrorTest {
    private static int count = 1;
    public static void main(String[] args) {
        System.out.println(count);
        count++;
        main(args);
    }
}

设置参数后:函数调用深度

image-20220918224437270

函数调用深度明显减少,说明参数起作用了

image-20220918224946956

2.6.栈中存储什么?

1、每个线程都有自己的栈,栈中的数据都是以栈帧(Stack Frame)的格式存在

2、在这个线程上正在执行的每个方法都各自对应一个栈帧(Stack Frame)。

3、栈帧是一个内存区块,是一个数据集,维系着方法执行过程中的各种数据信息。

2.7.栈运行原理

  • JVM直接对Java栈的操作只有两个,就是对栈帧的压栈和出栈,遵循先进后出(后进先出)原则
  • 在一条活动线程中,一个时间点上,只会有一个活动的栈帧。即只有当前正在执行的方法的栈帧(栈顶栈帧)是有效的。这个栈帧被称为当前栈帧(Current Frame),与当前栈帧相对应的方法就是当前方法(Current Method),定义这个方法的类就是当前类(Current Class)
  • 执行引擎运行的所有字节码指令只针对当前栈帧进行操作。
  • 如果在该方法中调用了其他方法,对应的新的栈帧会被创建出来,放在栈的顶端,成为新的当前帧。

image-20220922225449020

代码举例:

public class StackFrameTest {
    public static void main(String[] args) {
        StackFrameTest test = new StackFrameTest();
        test.method1();
    }
    private void method1(){
        System.out.println("method1()开始执行……");
        method2();
        System.out.println("method1()执行结束……");
    }
    private int method2(){
        System.out.println("method2()开始执行……");
        int i = 10;
        int m = (int) method3();
        System.out.println("method2()即将结束……");
        return i + m;
    }
    private double method3(){
        System.out.println("method3()开始执行……");
        double j = 20.0;
        System.out.println("method3()即将结束……");
        return j;
    }
}

执行结果:

method1()开始执行……
method2()开始执行……
method3()开始执行……
method3()即将结束……
method2()即将结束……
method1()执行结束……
  • 不同线程中所包含的栈帧是不允许存在相互引用的,即不可能在一个栈帧之中引用另外一个线程的栈帧。
  • 如果当前方法调用了其他方法,方法返回之际,当前栈帧会传回此方法的执行结果给前一个栈帧,接着,虚拟机会丢弃当前栈帧,使得前一个栈帧重新成为当前栈帧。
  • Java方法有两种返回函数的方式。
    • 一种是正常的函数返回,使用return指令。
    • 另一种是方法执行中出现未捕获处理的异常,以抛出异常的方式结束。
    • 但不管使用哪种方式,都会导致栈帧被弹出。
public class StackFrameTest {
    public static void main(String[] args) {
        StackFrameTest test = new StackFrameTest();
        test.method1();
        System.out.println("main()正常结束");
    }
    private void method1(){
        System.out.println("method1()开始执行……");
        System.out.println("method1()执行结束……");
        System.out.println(10 / 0);
    }
}

执行结果输出:

image-20220918231622751

3.栈桢的内部结构

每个栈帧中存储着:

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

image-20220922225950404

并行每个线程下的栈都是私有的,因此每个线程都有自己各自的栈,并且每个栈里面都有很多栈帧,栈帧的大小主要由局部变量表和操作数栈决定的

image-20220922230326157

4.局部变量表

职责:局部变量表按定义顺序存储两块内容:

  • 存储方法参数
  • 存储方法内的局部变量

局部变量表特点:

  • 由于局部变量表是建立在线程的栈上,是线程的私有数据,因此不存在数据安全问题
  • 编译期间长度已确定,局部变量元数据存储在字节码中
  • 局部变量表是栈帧最主要的存储空间,决定了栈的深度
  • 局部变量表所需的容量大小是在编译期确定下来的,并保存在方法的Code属性的maximum local variables数据项中。在方法运行期间是不会改变局部变量表的大小的。
  • 局部变量表中的变量只在当前方法调用中有效。
    • 在方法执行时,虚拟机通过使用局部变量表完成参数值到参数变量列表的传递过程。
    • 当方法调用结束后,随着方法栈帧的销毁,局部变量表也会随之销毁。

代码说明:

public class LocalVariablesTest {
    public static void main(String[] args) {
        LocalVariablesTest test = new LocalVariablesTest();
        int num = 10;
        String name = "fblinux";
    }
}

image-20220922231153956

看完字节码后,可得结论:局部变量表所需的容量大小是在编译期确定下来的。

4.1.关于Slot变量槽的理解

  • 局部变量表,最基本的存储单元是Slot(变量槽),局部变量表中存放编译期可知的各种基本数据类型(8种),引用类型(reference),returnAddress类型的变量。
  • Slot按类型区分
    • 32位以内类型(int/float/char/…/引用类型)占用1个Slot
    • 64位类型(long/double)占用2个Slot
  • JVM会为局部变量表中的每一个Slot都分配一个访问索引,通过这个索引即可成功访问到局部变量表中指定的局部变量值
  • 当一个实例方法被调用的时候,它的方法参数和方法体内部定义的局部变量将会按照顺序被复制到局部变量表中的每一个slot上
  • 如果当前帧是由构造方法或者实例方法创建的,那么该对象引用this将会存放在index为0的slot处,其余的参数按照参数表顺序继续排列。(this也相当于一个变量)

代码说明:

1、this 存放在 index = 0 的位置:

代码:

public class LocalVariablesTest {
    private int count = 0;
    public void test1(){
        this.count++;
    }
}

局部变量表:this 存放在 index = 0 的位置

image-20220919190541017

2、64位的类型(long和double)占用两个slot

public class LocalVariablesTest {
    public String test2(Date dateP, String name2) {
        dateP = null;
        name2 = "fblinux";
        double weight = 130.5;//占据两个slot
        char gender = '男';
        return dateP + name2;
    }
}

weight 为 double 类型,index 直接从 3 蹦到了 5,说明占用了两个slot

image-20220919190716145

3、static 无法调用 this

public class LocalVariablesTest {
    private int count = 0;

    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);
    }
}

4.2.Slot的重复利用

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

代码:

public class LocalVariablesTest {
    public void test4() {
        int a = 0;
        {
            int b = 0;
            b = a + 1;
        }
        //变量c使用之前已经销毁的变量b占据的slot的位置
        int c = a + 1;
    }
}

局部变量 c 重用了局部变量 b 的 slot 位置

image-20220919191129458

4.3.补充说明

1、在栈帧中,与性能调优关系最为密切的部分就是前面提到的局部变量表。在方法执行时,虚拟机使用局部变量表完成方法的传递。

2、局部变量表中的变量也是重要的垃圾回收根节点,只要被局部变量表中直接或间接引用的对象都不会被回收。

5.操作数栈

字节码指令在执行过程中的中间计算过程存储在操作数栈

5.1.操作数栈的特点

1、每一个独立的栈帧除了包含局部变量表以外,还包含一个后进先出(Last – In – First -Out)的 操作数栈,也可以称之为表达式栈(Expression Stack)

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

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

5.2.操作数栈的作用

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

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

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

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

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

5、操作数栈并非采用访问索引的方式来进行数据访问的,而是只能通过标准的入栈和出栈操作来完成一次数据访问。只不过操作数栈是用数组这个结构来实现的而已

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

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

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

5.3.代码追踪栈的执行

public void testAddOperation() {
    byte i = 15;
    int j = 8;
    int k = i + j;
}

获取字节码文件

……省略部分内容……
 public void testAddOperation();
    descriptor: ()V
    flags: (0x0001) ACC_PUBLIC
    Code:
      stack=2, locals=4, args_size=1
         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
……省略部分内容……

byte、short、char、boolean 内部都是使用int型来进行保存的

从上面的代码我们可以知道,我们都是通过bipush对操作数 15 和 8进行入栈操作

同时使用的是 iadd方法进行相加操作,i -> 代表的就是 int,也就是int类型的加法操作

执行流程如下所示:

首先执行第一条语句,PC寄存器指向的是0,也就是指令地址为0,然后使用bipush让操作数15入栈。

image-20220927224912941

执行完后,让PC + 1,指向下一行代码,下一行代码就是将操作数栈的元素存储到局部变量表1的位置,我们可以看到局部变量表的已经增加了一个元素

image-20220927224930029

为什么局部变量表不是从0开始的呢?

其实局部变量表也是从0开始的,但是因为0号位置存储的是this指针,所以说就直接省略了~

然后PC+1,指向的是下一行。让操作数8也入栈,同时执行store操作,存入局部变量表中

image-20220927225003592

然后从局部变量表中,依次将数据放在操作数栈中

image-20220927225019772

然后将操作数栈中的两个元素执行相加操作,并存储在局部变量表3的位置

image-20220927225038443

最后PC寄存器的位置指向10,也就是return方法,则直接退出方法

5.4.栈顶缓存技术

栈顶缓存技术:Top Of Stack Cashing

1、前面提过,基于栈式架构的虚拟机所使用的零地址指令更加紧凑,但完成一项操作的时候必然需要使用更多的入栈和出栈指令,这同时也就意味着将需要更多的指令分派(instruction dispatch)次数(也就是你会发现指令很多)和导致内存读/写次数多,效率不高。

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

3、寄存器的主要优点:指令更少,执行速度快,但是指令集(也就是指令种类)很多

6.动态链接

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

1、每一个栈帧内部都包含一个指向运行时常量池中该栈帧所属方法的引用。包含这个引用的目的就是为了支持当前方法的代码能够实现动态链接(Dynamic Linking),比如:invokedynamic指令

2、在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++;
    }
}

字节码指令:

  Last modified 2022年9月19日; size 700 bytes
  SHA-256 checksum b8eb53ae5e288ee972cd881fca57ab265565d5c1b4df4e5093bbd1edd781b408
  Compiled from "DynamicLinkingTest.java"
public class com.fblinux.DynamicLinkingTest
  minor version: 0
  major version: 52
  flags: (0x0021) ACC_PUBLIC, ACC_SUPER
  this_class: #8                          // com/fblinux/DynamicLinkingTest
  super_class: #2                         // java/lang/Object
  interfaces: 0, fields: 1, methods: 3, attributes: 1
Constant pool:
   #1 = Methodref          #2.#3          // java/lang/Object."<init>":()V
   #2 = Class              #4             // java/lang/Object
   #3 = NameAndType        #5:#6          // "<init>":()V
   #4 = Utf8               java/lang/Object
   #5 = Utf8               <init>
   #6 = Utf8               ()V
   #7 = Fieldref           #8.#9          // com/fblinux/DynamicLinkingTest.num:I
   #8 = Class              #10            // com/fblinux/DynamicLinkingTest
   #9 = NameAndType        #11:#12        // num:I
  #10 = Utf8               com/fblinux/DynamicLinkingTest
  #11 = Utf8               num
  #12 = Utf8               I
  #13 = Fieldref           #14.#15        // java/lang/System.out:Ljava/io/PrintStream;
  #14 = Class              #16            // java/lang/System
  #15 = NameAndType        #17:#18        // out:Ljava/io/PrintStream;
  #16 = Utf8               java/lang/System
  #17 = Utf8               out
  #18 = Utf8               Ljava/io/PrintStream;
  #19 = String             #20            // methodA()....
  #20 = Utf8               methodA()....
  #21 = Methodref          #22.#23        // java/io/PrintStream.println:(Ljava/lang/String;)V
  #22 = Class              #24            // java/io/PrintStream
  #23 = NameAndType        #25:#26        // println:(Ljava/lang/String;)V
  #24 = Utf8               java/io/PrintStream
  #25 = Utf8               println
  #26 = Utf8               (Ljava/lang/String;)V
  #27 = String             #28            // methodB()....
  #28 = Utf8               methodB()....
  #29 = Methodref          #8.#30         // com/fblinux/DynamicLinkingTest.methodA:()V
  #30 = NameAndType        #31:#6         // methodA:()V
  #31 = Utf8               methodA
  #32 = Utf8               Code
  #33 = Utf8               LineNumberTable
  #34 = Utf8               LocalVariableTable
  #35 = Utf8               this
  #36 = Utf8               Lcom/fblinux/DynamicLinkingTest;
  #37 = Utf8               methodB
  #38 = Utf8               SourceFile
  #39 = Utf8               DynamicLinkingTest.java
{
  int num;
    descriptor: I
    flags: (0x0000)

  public com.fblinux.DynamicLinkingTest();
    descriptor: ()V
    flags: (0x0001) ACC_PUBLIC
    Code:
      stack=2, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: aload_0
         5: bipush        10
         7: putfield      #7                  // Field num:I
        10: return
      LineNumberTable:
        line 3: 0
        line 5: 4
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      11     0  this   Lcom/fblinux/DynamicLinkingTest;

  public void methodA();
    descriptor: ()V
    flags: (0x0001) ACC_PUBLIC
    Code:
      stack=2, locals=1, args_size=1
         0: getstatic     #13                 // Field java/lang/System.out:Ljava/io/PrintStream;
         3: ldc           #19                 // String methodA()....
         5: invokevirtual #21                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
         8: return
      LineNumberTable:
        line 8: 0
        line 9: 8
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       9     0  this   Lcom/fblinux/DynamicLinkingTest;

  public void methodB();
    descriptor: ()V
    flags: (0x0001) ACC_PUBLIC
    Code:
      stack=3, locals=1, args_size=1
         0: getstatic     #13                 // Field java/lang/System.out:Ljava/io/PrintStream;
         3: ldc           #27                 // String methodB()....
         5: invokevirtual #21                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
         8: aload_0
         9: invokevirtual #29                 // Method methodA:()V
        12: aload_0
        13: dup
        14: getfield      #7                  // Field num:I
        17: iconst_1
        18: iadd
        19: putfield      #7                  // Field num:I
        22: return
      LineNumberTable:
        line 12: 0
        line 14: 8
        line 16: 12
        line 17: 22
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      23     0  this   Lcom/fblinux/DynamicLinkingTest;
}

1、在字节码指令中,methodB() 方法中通过 invokevirtual #29 指令调用了方法 A ,那么 #29 是个啥呢?

2、往上面翻,找到常量池的定义:#29 = Methodref #8.#30

  • 先找 #8 :
    • #8 = Class #10 :去找 #10
    • #10 = Utf8 com/fblinux/DynamicLinkingTest
    • 结论:通过 #8 我们找到了 DynamicLinkingTest 这个类
  • 再来找 #30:
    • #30 = NameAndType #31:#6 :去找 #31 和 #6
    • #31 = Utf8 methodA :方法名为 methodA
    • #6 = Utf8 ()V :方法没有形参,返回值为 void

3、结论:通过 #29 我们就能找到需要调用的 methodA() 方法,并进行调用

为什么要用常量池呢?

1、因为在不同的方法,都可能调用常量或者方法,所以只需要存储一份即可,然后记录其引用即可,节省了空间。

2、常量池的作用:就是为了提供一些符号和常量,便于指令的识别

7.方法返回地址

1、存放调用该方法的pc寄存器的值。一个方法的结束,有两种方式:

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

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

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

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

方法退出的两种方式

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

正常退出:

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

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

3、在字节码指令中,返回指令包含:

  • ireturn:当返回值是boolean,byte,char,short和int类型时使用
  • lreturn:Long类型
  • freturn:Float类型
  • dreturn:Double类型
  • areturn:引用类型
  • return:返回值类型为void的方法、实例初始化方法、类和接口的初始化方法

异常退出:

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

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

image-20220920180021416

异常处理表:

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

8.一些附加信息

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

转载请注明:西门飞冰的博客 » JVM—虚拟机栈

喜欢 (1)or分享 (0)