JVM 03 运行时数据区之虚拟机栈 (Stack)

• 1 虚拟机栈概述
• 2 栈的存储单位
• 3 局部变量表
• 4 操作数栈
• 5 代码追踪
• 6 栈顶缓存技术
• 7 动态链接
• 8 方法的调用:解析与分派
• 9 方法返回地址
• 10 一些附加信息
• 11 栈的相关面试题

1 虚拟机栈概述

由于跨平台性的设计，Java的指令都是根据栈来设计的。不同平台CPU架构不同，所以不能设计为基于寄存器的。

优点是跨平台，指令集小，编译器容易实现，缺点是性能下降，实现同样的功能需要更多的指令。

有不少Java开发人员一提到Java内存结构，就会非常粗粒度地将JVM中的内存区理解为仅有Java堆(heap)和Java栈(stack)?为什么?

不全面。也许堆和栈太重要。

内存中的栈与堆

栈是运行时的单位，而堆是存储的单位。

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

---

虚拟机栈基本内容

● Java虚拟机栈是什么?

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

● 生命周期

生命周期和线程一致。

● 作用

主管Java程序的运行，它保存方法的局部变量（八种基本数据类型、对象的引用地址）、部分结果，并参与方法的调用和返回。
➢ 局部变量 vs 成员变量(或属性)
➢ 基本数据变量 VS 引用类型变量(类、数组、接口)

---

栈的特点(优点)

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

---

面试题: 开发中遇到的异常有哪些?

栈中可能出现的异常
● Java虚拟机规范允许Java栈的大小是动态的或者是固定不变的。
➢ 如果采用固定大小的Java虚拟机栈，那每一个线程的Java虚拟机栈容量可以在线程创建的时候独立选定。如果线程请求分配的栈容量超过Java虚拟机栈允许的最大容量，Java 虚拟机将会抛出一个 StackOverflowError 异常。
➢ 如果Java虛拟机栈可以动态扩展，并且在尝试扩展的时候无法申请到足够的内存，或者在创建新的线程时没有足够的内存去创建对应的虚拟机栈，那Java虚拟机将会抛出一个 OutOfMemoryError 异常。

---

设置栈内存大小

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

IntelliJ IDEA 设置栈大小的方法：点击 Run - Edit Configurations - VM options ，输入 -Xss256K 或 -Xss256k ，设置栈的大小为256k （k、m、g或K、M、G是单位，大小写均可）。

以下运行环境：Java8、macOS。下面的程序输出视运行环境不同（系统不同、JDK版本不同均有影响）而有不同的结果。

StackDeepTest.java

package com.atguigu.java;

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

使用默认设置栈的大小时，程序输出：

deep of calling = 22387
java.lang.StackOverflowError
 at com.atguigu.java.StackDeepTest.recursion(StackDeepTest.java:8)
 at com.atguigu.java.StackDeepTest.recursion(StackDeepTest.java:8)
...

指定栈的大小为256K时，程序输出：

deep of calling = 2712
java.lang.StackOverflowError
 at com.atguigu.java.StackDeepTest.recursion(StackDeepTest.java:8)
 at com.atguigu.java.StackDeepTest.recursion(StackDeepTest.java:8)
...

---

StackErrorTest.java

package com.atguigu.java;

/**
 * 演示栈中的异常:StackOverflowError
 * @author shkstart
 * @create 2020 下午 9:08
 *
 *  默认情况下：count : 11420
 *  设置栈的大小： -Xss256k : count : 2465
 */
public class StackErrorTest {
    private static int count = 1;
    public static void main(String[] args) {
        System.out.println(count);
        count++;
        main(args);
    }

}

---

2 栈的存储单位

栈中存储什么

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

栈运行原理

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

StackFrameTest.java

package com.atguigu.java1;

/**
 * @author shkstart
 * @create 2020 下午 4:11
 * <p>
 * 方法的结束方式分为两种：① 正常结束，以return为代表  ② 方法执行中出现未捕获处理的异常，以抛出异常的方式结束
 */
public class StackFrameTest {
    public static void main(String[] args) {
        try {
            StackFrameTest test = new StackFrameTest();
            test.method1();

        } catch (Exception e) {
            e.printStackTrace();
        }

        System.out.println("main()正常结束");

    }

    public void method1() {
        System.out.println("method1()开始执行...");
        method2();
        System.out.println("method1()执行结束...");
        //        System.out.println(10 / 0);

        //        return ;//可以省略
    }

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

}

反编译StackFrameTest.class

$ javap StackFrameTest.class
Compiled from "StackFrameTest.java"
public class com.atguigu.java1.StackFrameTest {
  public com.atguigu.java1.StackFrameTest();
  public static void main(java.lang.String[]);
  public void method1();
  public int method2();
  public double method3();
}

$ javap -v StackFrameTest.class
Classfile /Users/yan/Documents/JVMDemo/out/production/chapter05/com/atguigu/java1/StackFrameTest.class
  Last modified 2020年7月5日; size 1373 bytes
  SHA-256 checksum c61db00f51e8ffb48977aa8245b58fb7b3e49f4678d4e147dffdd989f0a43478
  Compiled from "StackFrameTest.java"
public class com.atguigu.java1.StackFrameTest
  minor version: 0
  major version: 52
  flags: (0x0021) ACC_PUBLIC, ACC_SUPER
  this_class: #2                          // com/atguigu/java1/StackFrameTest
  super_class: #20                        // java/lang/Object
  interfaces: 0, fields: 0, methods: 5, attributes: 1
Constant pool:
   #1 = Methodref          #20.#49        // java/lang/Object."<init>":()V
   #2 = Class              #50            // com/atguigu/java1/StackFrameTest
   #3 = Methodref          #2.#49         // com/atguigu/java1/StackFrameTest."<init>":()V
   #4 = Methodref          #2.#51         // com/atguigu/java1/StackFrameTest.method1:()V
   #5 = Class              #52            // java/lang/Exception
   #6 = Methodref          #5.#53         // java/lang/Exception.printStackTrace:()V
   #7 = Fieldref           #54.#55        // java/lang/System.out:Ljava/io/PrintStream;
   #8 = String             #56            // main()正常结束
   #9 = Methodref          #57.#58        // java/io/PrintStream.println:(Ljava/lang/String;)V
  #10 = String             #59            // method1()开始执行...
  #11 = Methodref          #2.#60         // com/atguigu/java1/StackFrameTest.method2:()I
  #12 = String             #61            // method1()执行结束...
  #13 = String             #62            // method2()开始执行...
  #14 = Methodref          #2.#63         // com/atguigu/java1/StackFrameTest.method3:()D
  #15 = String             #64            // method2()即将结束...
  #16 = String             #65            // method3()开始执行...
  #17 = Double             20.0d
  #19 = String             #66            // method3()即将结束...
  #20 = Class              #67            // java/lang/Object
  #21 = Utf8               <init>
  #22 = Utf8               ()V
  #23 = Utf8               Code
  #24 = Utf8               LineNumberTable
  #25 = Utf8               LocalVariableTable
  #26 = Utf8               this
  #27 = Utf8               Lcom/atguigu/java1/StackFrameTest;
  #28 = Utf8               main
  #29 = Utf8               ([Ljava/lang/String;)V
  #30 = Utf8               test
  #31 = Utf8               e
  #32 = Utf8               Ljava/lang/Exception;
  #33 = Utf8               args
  #34 = Utf8               [Ljava/lang/String;
  #35 = Utf8               StackMapTable
  #36 = Class              #52            // java/lang/Exception
  #37 = Utf8               method1
  #38 = Utf8               method2
  #39 = Utf8               ()I
  #40 = Utf8               i
  #41 = Utf8               I
  #42 = Utf8               m
  #43 = Utf8               method3
  #44 = Utf8               ()D
  #45 = Utf8               j
  #46 = Utf8               D
  #47 = Utf8               SourceFile
  #48 = Utf8               StackFrameTest.java
  #49 = NameAndType        #21:#22        // "<init>":()V
  #50 = Utf8               com/atguigu/java1/StackFrameTest
  #51 = NameAndType        #37:#22        // method1:()V
  #52 = Utf8               java/lang/Exception
  #53 = NameAndType        #68:#22        // printStackTrace:()V
  #54 = Class              #69            // java/lang/System
  #55 = NameAndType        #70:#71        // out:Ljava/io/PrintStream;
  #56 = Utf8               main()正常结束
  #57 = Class              #72            // java/io/PrintStream
  #58 = NameAndType        #73:#74        // println:(Ljava/lang/String;)V
  #59 = Utf8               method1()开始执行...
  #60 = NameAndType        #38:#39        // method2:()I
  #61 = Utf8               method1()执行结束...
  #62 = Utf8               method2()开始执行...
  #63 = NameAndType        #43:#44        // method3:()D
  #64 = Utf8               method2()即将结束...
  #65 = Utf8               method3()开始执行...
  #66 = Utf8               method3()即将结束...
  #67 = Utf8               java/lang/Object
  #68 = Utf8               printStackTrace
  #69 = Utf8               java/lang/System
  #70 = Utf8               out
  #71 = Utf8               Ljava/io/PrintStream;
  #72 = Utf8               java/io/PrintStream
  #73 = Utf8               println
  #74 = Utf8               (Ljava/lang/String;)V
{
  public com.atguigu.java1.StackFrameTest();
    descriptor: ()V
    flags: (0x0001) ACC_PUBLIC
    Code:
      stack=1, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: return
      LineNumberTable:
        line 9: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       5     0  this   Lcom/atguigu/java1/StackFrameTest;

  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: (0x0009) ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=2, args_size=1
         0: new           #2                  // class com/atguigu/java1/StackFrameTest
         3: dup
         4: invokespecial #3                  // Method "<init>":()V
         7: astore_1
         8: aload_1
         9: invokevirtual #4                  // Method method1:()V
        12: goto          20
        15: astore_1
        16: aload_1
        17: invokevirtual #6                  // Method java/lang/Exception.printStackTrace:()V
        20: getstatic     #7                  // Field java/lang/System.out:Ljava/io/PrintStream;
        23: ldc           #8                  // String main()正常结束
        25: invokevirtual #9                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
        28: return
      Exception table:
         from    to  target type
             0    12    15   Class java/lang/Exception
      LineNumberTable:
        line 12: 0
        line 13: 8
        line 17: 12
        line 15: 15
        line 16: 16
        line 19: 20
        line 21: 28
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            8       4     1  test   Lcom/atguigu/java1/StackFrameTest;
           16       4     1     e   Ljava/lang/Exception;
            0      29     0  args   [Ljava/lang/String;
      StackMapTable: number_of_entries = 2
        frame_type = 79 /* same_locals_1_stack_item */
          stack = [ class java/lang/Exception ]
        frame_type = 4 /* same */

  public void method1();
    descriptor: ()V
    flags: (0x0001) ACC_PUBLIC
    Code:
      stack=2, locals=1, args_size=1
         0: getstatic     #7                  // Field java/lang/System.out:Ljava/io/PrintStream;
         3: ldc           #10                 // String method1()开始执行...
         5: invokevirtual #9                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
         8: aload_0
         9: invokevirtual #11                 // Method method2:()I
        12: pop
        13: getstatic     #7                  // Field java/lang/System.out:Ljava/io/PrintStream;
        16: ldc           #12                 // String method1()执行结束...
        18: invokevirtual #9                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
        21: return
      LineNumberTable:
        line 24: 0
        line 25: 8
        line 26: 13
        line 30: 21
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      22     0  this   Lcom/atguigu/java1/StackFrameTest;

  public int method2();
    descriptor: ()I
    flags: (0x0001) ACC_PUBLIC
    Code:
      stack=2, locals=3, args_size=1
         0: getstatic     #7                  // Field java/lang/System.out:Ljava/io/PrintStream;
         3: ldc           #13                 // String method2()开始执行...
         5: invokevirtual #9                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
         8: bipush        10
        10: istore_1
        11: aload_0
        12: invokevirtual #14                 // Method method3:()D
        15: d2i
        16: istore_2
        17: getstatic     #7                  // Field java/lang/System.out:Ljava/io/PrintStream;
        20: ldc           #15                 // String method2()即将结束...
        22: invokevirtual #9                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
        25: iload_1
        26: iload_2
        27: iadd
        28: ireturn
      LineNumberTable:
        line 33: 0
        line 34: 8
        line 35: 11
        line 36: 17
        line 37: 25
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      29     0  this   Lcom/atguigu/java1/StackFrameTest;
           11      18     1     i   I
           17      12     2     m   I

  public double method3();
    descriptor: ()D
    flags: (0x0001) ACC_PUBLIC
    Code:
      stack=2, locals=3, args_size=1
         0: getstatic     #7                  // Field java/lang/System.out:Ljava/io/PrintStream;
         3: ldc           #16                 // String method3()开始执行...
         5: invokevirtual #9                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
         8: ldc2_w        #17                 // double 20.0d
        11: dstore_1
        12: getstatic     #7                  // Field java/lang/System.out:Ljava/io/PrintStream;
        15: ldc           #19                 // String method3()即将结束...
        17: invokevirtual #9                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
        20: dload_1
        21: dreturn
      LineNumberTable:
        line 41: 0
        line 42: 8
        line 43: 12
        line 44: 20
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      22     0  this   Lcom/atguigu/java1/StackFrameTest;
           12      10     1     j   D
}
SourceFile: "StackFrameTest.java"

return, ireturn, dreturn 中 i 代表 int， d 代表 double。

◆ 栈帧的内部结构

毎个栈帧中存儲着:

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

---

3 🌿 局部变量表

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

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

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

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

• 方法嵌套调用的次数由栈的大小决定。一般来说，栈越大，方法嵌套调用次数越多。对一个函数而言，它的参数和局部变量越多，使得局部变量表膨胀，它的栈帧就越大，以满足方法调用所需传递的信息增大的需求。进而函数调用就会占用更多的栈空间，导致其嵌套调用次数就会减少。

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

字节码中方法内部结构的剖析

以main方法为例：

public static void main(String[] args) {
    LocalVariablesTest test = new LocalVariablesTest();
    int num = 10;
    test.test1();
}

javap -v 得到的内容，main方法部分：

public static void main(java.lang.String[]);
  descriptor: ([Ljava/lang/String;)V
  flags: (0x0009) ACC_PUBLIC, ACC_STATIC
  Code:
    stack=2, locals=3, args_size=1
       0: new           #1                  // class com/atguigu/java1/LocalVariablesTest
       3: dup
       4: invokespecial #2                  // Method "<init>":()V
       7: astore_1
       8: bipush        10
      10: istore_2
      11: aload_1
      12: invokevirtual #3                  // Method test1:()V
      15: return
    LineNumberTable:
      line 13: 0
      line 14: 8
      line 15: 11
      line 16: 15
    LocalVariableTable:
      Start  Length  Slot  Name   Signature
          0      16     0  args   [Ljava/lang/String;
          8       8     1  test   Lcom/atguigu/java1/LocalVariablesTest;
         11       5     2   num   I

以上信息中：

这些东西	是啥意思？
descriptor: ([Ljava/lang/String;)V	描述符：[表示一维数组，L表示引用类型变量，V表示方法返回值 void
flags: (0x0009) ACC_PUBLIC, ACC_STATIC	Access flags即访问标识 public static
Code:	字节码：
stack=2, locals=3, args_size=1	locals=3表示局部变量表深度为3，stack=2表示操作数栈深度为2
Code: 0到15	字节码指令号
LineNumberTable line 13: 0	行号表 line 13表示java源代码中的行号13: 0表示字节码指令号0
LocalVariableTable：Start Length Slot	局部变量表：Start和Length在一起表示了局部变量的作用范围：字节码指令中从Start开始，长度为Length，Slot为槽的索引

关于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处，其余的参数按照参数表顺序继续排列。

又如 test2 方法：

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

test2方法的局部变量表如下：其中slot index0是对象引用this，slot index3和4是double类型的变量（只需要索引index 3即可访问double类型的变量weight），slot index5是char类型变量。

public java.lang.String test2(java.util.Date, java.lang.String);
  descriptor: (Ljava/util/Date;Ljava/lang/String;)Ljava/lang/String;
  flags: (0x0001) ACC_PUBLIC
  Code:
    stack=2, locals=6, args_size=3
       0: aconst_null
       1: astore_1
       2: ldc           #18                 // String songhongkang

    .......中间省略.........

    LocalVariableTable:
      Start  Length  Slot  Name   Signature
          0      33     0  this   Lcom/atguigu/java1/LocalVariablesTest;
          0      33     1 dateP   Ljava/util/Date;
          0      33     2 name2   Ljava/lang/String;
          9      24     3 weight   D
         14      19     5 gender   C

Slot的重复利用

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

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

下面是 javap -v 得到的test4方法部分的局部变量表 LocalVariableTable:

public void test4();
  descriptor: ()V
  flags: (0x0001) ACC_PUBLIC
  Code:
    stack=2, locals=3, args_size=1
       0: iconst_0
       1: istore_1
       2: iconst_0
       3: istore_2
       4: iload_1
       5: iconst_1
       6: iadd
       7: istore_2
       8: iload_1
       9: iconst_1
      10: iadd
      11: istore_2
      12: return
    LineNumberTable:
      line 53: 0
      line 55: 2
      line 56: 4
      line 59: 8
      line 60: 12
    LocalVariableTable:
      Start  Length  Slot  Name   Signature
          4       4     2     b   I
          0      13     0  this   Lcom/atguigu/java1/LocalVariablesTest;
          2      11     1     a   I
         12       1     2     c   I

从 LocalVariableTable 可以看出，局部变量 b 的作用域范围是4（Start）到8（Start+Length），即test4方法中用 { 和 } 括起来的部分。从9开始，Slot 2这个槽实际就相当于空着了，所以局部变量 c 的作用域范围从12开始，局部变量 c 就重复利用了过期局部变量 b 的槽位。

举例:静态变量与局部变量的对比

● 参数表分配完毕之后，再根据方法体内定义的变量的顺序和作用域分配。
● 我们知道类变量表有两次初始化的机会，第一次是在“准备阶段”，执行系统初始化，对类变量设置零值，另一次则是在“初始化”阶段，赋予程序员在代码中定义的初始值。
● 和类变量初始化不同的是，局部变量表不存在系统初始化的过程，这意味着一旦定义了局部变量则必须人为的初始化，否则无法使用。

/*
    变量的分类：按照数据类型分：
    ① 基本数据类型  ② 引用数据类型
    按照在类中声明的位置分：
    ① 成员变量：在使用前，都经历过默认初始化赋值
      类变量： linking的prepare阶段：给类变量默认赋值  ---> initial阶段：给类变量显式赋值即静态代码块赋值
      实例变量：随着对象的创建，会在堆空间中分配实例变量空间，并进行默认赋值
    ② 局部变量：在使用前，必须要进行显式赋值的！否则，编译不通过
    */
    public void test5Temp(){
        int num;
        //System.out.println(num);//错误信息：变量num未进行初始化
    }

这样的代码是错误的，没有赋值不能够使用。

补充说明

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

---

4 操作数栈

• 每一个独立的栈帧中除了包含局部变量表以外，还包含一个后进先出(Last-In-First-out )的操作数栈，也可以称之为表达式栈(Expression Stack) 。
• **操作数栈，在方法执行过程中，根据字节码指令，往栈中写入数据或提取数据，即入栈(push) /出栈(pop)**。
  • ➢ 某些字节码指令将值压入操作数栈，其余的字节码指令将操作数取出栈。使用它们后再把结果压入栈。
  • ➢ 比如:执行复制、交换、求和等操作
• 操作数栈，主要用于保存计算过程的中间结果，同时作为计算过程中变量临时的存储空间。
• 操作数栈就是JVM执行引擎的一个工作区，当一个方法刚开始执行的时候，一个新的栈帧也会随之被创建出来，这个方法的操作数栈是空的。
• 每一个操作数栈都会拥有一个明确的栈深度用于存储数值，其所需的最大深度在编译期就定义好了，保存在方法的Code属性中（比如stack=2），为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;

       // int m = 800;

    }

javap -v 类名.class

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
    LineNumberTable:
      line 10: 0
      line 11: 3
      line 12: 6
      line 16: 10
    LocalVariableTable:
      Start  Length  Slot  Name   Signature
          0      11     0  this   Lcom/atguigu/java1/OperandStackTest;
          3       8     1     i   B
          6       5     2     j   I
         10       1     3     k   I

分析（是我推测，不知对否，回头再看）：

字节码指令	操作数栈（动作，栈元素 栈底 –> 栈顶）	局部变量表（Slot0123）
0: bipush 15	入栈，15	this,
2: istore_1	出栈，空	this, 15
3: bipush 8	入栈，8	this, 15
5: istore_2	出栈，空	this, 15, 8
6: iload_1	入栈，15	this, 15, 8
7: iload_2	入栈，15, 8	this, 15, 8
8: iadd	出栈(8)，出栈(15)，入栈(23) ，23	this, 15, 8
9: istore_3	出栈，空	this, 15, 8, 23
10: return	无动作，空	this, 15, 8, 23

---

5 代码追踪

---

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;
      //System.out.println(i10);//22
  }

尝试通过分析字节码的方式去理解：

public void add();
  descriptor: ()V
  flags: (0x0001) ACC_PUBLIC
  Code:
    stack=2, locals=11, args_size=1
       0: bipush        10
       2: istore_1
       3: iinc          1, 1
       6: bipush        10
       8: istore_2
       9: iinc          2, 1
      12: bipush        10
      14: istore_3
      15: iload_3
      16: iinc          3, 1
      19: istore        4
      21: bipush        10
      23: istore        5
      25: iinc          5, 1
      28: iload         5
      30: istore        6
      32: bipush        10
      34: istore        7
      36: iload         7
      38: iinc          7, 1
      41: istore        7
      43: bipush        10
      45: istore        8
      47: iinc          8, 1
      50: iload         8
      52: istore        8
      54: bipush        10
      56: istore        9
      58: iload         9
      60: iinc          9, 1
      63: iinc          9, 1
      66: iload         9
      68: iadd
      69: istore        10
      71: return

程序员面试过程中，常见的 i++ 和 ++i 的区别, 放到字节码篇章时再介绍。

---

6 栈顶缓存技术

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

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

---

7 动态链接

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

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

在Java源文件被编译到字节码文件中时，所有的变量和方法引用都作为符号引用(Symbolic Reference) 保存在 class文件的常量池（运行起来以后保存到方法区就是运行时常量池）里。比如:描述一个方法调用了另外的其他方法时，就是通过常量池中指向方法的符号引用来表示的，那么动态链接的作用就是为了将这些符号引用转换为调用方法的直接引用。

为什么需要常量池呢？

常量池的作用，就是为了提供一些符号和常量，便于指令的识别。

---

8 方法的调用:解析与分派

原理、过程

方法的绑定机制

在JVM中，将符号引用转换为调用方法的直接引用与方法的绑定机制相关。

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

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

对应的方法的绑定机制为:早期绑定(Early Binding)和晚期绑定(Late Binding) 。绑定是一个字段、方法或者类在符号引用被替换为直接引用的过程，这仅仅发生一次。

● 早期绑定:
早期绑定就是指被调用的目标方法如果在编译期可知，且运行期保持不变时,即可将这个方法与所属的类型进行绑定，这样一来，由于明确了被调用的目标方法究竟是哪一个，因此也就可以使用静态链接的方式将符号引用转换为直接引用。

● 晚期绑定:
如果被调用的方法在编译期无法被确定下来，只能够在程序运行期根据实际的类型绑定相关的方法，这种绑定方式也就被称之为晚期绑定。

package com.atguigu.java2;

/**
 * 说明早期绑定和晚期绑定的例子
 * @author shkstart
 * @create 2020 上午 11:59
 */
class Animal{

    public void eat(){
        System.out.println("动物进食");
    }
}
interface Huntable{
    void hunt();
}
class Dog extends Animal implements Huntable{
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }

    @Override
    public void hunt() {
        System.out.println("捕食耗子，多管闲事");
    }
}

class Cat extends Animal implements Huntable{

    public Cat(){
        super();//表现为：早期绑定
    }

    public Cat(String name){
        this();//表现为：早期绑定
    }

    @Override
    public void eat() {
        super.eat();//表现为：早期绑定
        System.out.println("猫吃鱼");
    }

    @Override
    public void hunt() {
        System.out.println("捕食耗子，天经地义");
    }
}
public class AnimalTest {
    public void showAnimal(Animal animal){
        animal.eat();//表现为：晚期绑定
    }
    public void showHunt(Huntable h){
        h.hunt();//表现为：晚期绑定
    }
}

随着高级语言的横空出世，类似于Java一样的基于面向对象的编程语言如今越来越多，尽管这类编程语言在语法风格上存在一定的差别，但是它们彼此之间始终保持着一个共性，那就是都支持封装、继承和多态等面向对象特性，既然这一类的编程语言具备多态特性，那么自然也就具备早期绑定和晚期绑定两种绑定方式。

Java中任何一个普通的方法其实都具备虚函数的特征，它们相当于C++语言中的虚函数(C++中则需要使用关键字 virtual 来显式定义)。如果在Java程序中不希望某个方法拥有虚函数的特征时，则可以使用关键字 final 来标记这个方法。

虚方法与非虚方法

非虚方法:

● 如果方法在编译期就确定了具体的调用版木，这个版木在运行时是不可变的。这样的方法称为非虚方法。
● 静态方法、私有方法、final方法、实例构造器、父类方法都是非虚方法。
● 其他方法称为虚方法。

子类对象的多态性的使用前提: ① 类的继承关系 ② 方法的重写.

4种方法调用指令区分非虚方法与虚方法

虚拟机中提供了以下几条方法调用指令:

• 普通调用指令:
  1. invokestatic: 调用静态方法，解析阶段确定唯一方法版本
  2. invokespecial: 调用<init>方法、 私有及父类方法，解析阶段确定唯一方法版本
  3. invokevirtual: 调用所有虚方法
  4. invokeinterface: 调用接口方法
• 动态调用指令:
  1. invokedynamic: 动态解析出需要调用的方法，然后执行

前四条指令固化在虛拟机内部，方法的调用执行不可人为干预，而 invokedynamic 指令则支持由用户确定方法版本。其中 invokestatic 指令和 invokespecial 指令调用的方法称为非虛方法，其余的( final 修饰的除外)称为虚方法。

package com.atguigu.java2;

/**
 * 解析调用中非虚方法、虚方法的测试
 *
 * invokestatic指令和invokespecial指令调用的方法称为非虚方法
 * @author shkstart
 * @create 2020 下午 12:07
 */
class Father {
    public Father() {
        System.out.println("father的构造器");
    }

    public static void showStatic(String str) {
        System.out.println("father " + str);
    }

    public final void showFinal() {
        System.out.println("father show final");
    }

    public void showCommon() {
        System.out.println("father 普通方法");
    }
}

public class Son extends Father {
    public Son() {
        //invokespecial
        super();
    }
    public Son(int age) {
        //invokespecial
        this();
    }
    //不是重写的父类的静态方法，因为静态方法不能被重写！
    public static void showStatic(String str) {
        System.out.println("son " + str);
    }
    private void showPrivate(String str) {
        System.out.println("son private" + str);
    }

    public void show() {
        //invokestatic
        showStatic("atguigu.com");
        //invokestatic
        super.showStatic("good!");
        //invokespecial
        showPrivate("hello!");
        //invokespecial
        super.showCommon();

        //invokevirtual
        showFinal();//因为此方法声明有final，不能被子类重写，所以也认为此方法是非虚方法。
        //虚方法如下：
        //invokevirtual
        showCommon();
        info();

        MethodInterface in = null;
        //invokeinterface
        in.methodA();
    }

    public void info(){

    }

    public void display(Father f){
        f.showCommon();
    }

    public static void main(String[] args) {
        Son so = new Son();
        so.show();
    }
}

interface MethodInterface{
    void methodA();
}

关于 invokedynamic 指令

JVM字节码指令集一直比较稳定，一直到Java7中才增加了一个 invokedynamic 指令，这是Java为了实现「动态类型语言」支持而做的一种改进。

但是在Java7中并没有提供直接生成 invokedynamic 指令的方法，需要借助 ASM 这种底层字节码工具来产生 invokedynamic 指令。直到 Java8 的 Lambda 表达式的出现，invokedynamic 指令的生成，在Java中才有了直接的生成方式。

Java7 中增加的动态语言类型支持的本质是对 Java虚拟机规范的修改，而不是对Java语言规则的修改，这一块相对来讲比较复杂，增加了虚拟机中的方法调用，最直接的受益者就是运行在Java平台的动态语言的编译器。

静态类型语言与动态类型语言：

动态类型语言和静态类型语言两者的区别就在于对类型的检查是在编译期还是在运行期，满足前者就是静态类型语言，反之是动态类型语言。

说的再直白一点就是，静态类型语言是判断变量自身的类型信息；动态类型语言是判断变量值的类型信息，变量没有类型信息，变量值才有类型信息，这是动态语言的一“个重要特征。

比如， 静态类型语言Java；动态类型语言JS，Python。

Java: String info = "atguigu"; //info = atguigu;  
JS: var name = "shkstart"; var name = 10 ;  
Python: info = 130.5

package com.atguigu.java2;

/**
 * 体会invokedynamic指令
 * @author shkstart
 * @create 2020 下午 3:09
 */
@FunctionalInterface
interface Func {
    public boolean func(String str);
}

public class Lambda {
    public void lambda(Func func) {
        return;
    }

    public static void main(String[] args) {
        Lambda lambda = new Lambda();

        Func func = s -> {
            return true;
        };

        lambda.lambda(func);

        lambda.lambda(s -> {
            return true;
        });
    }
}

main方法对应字节码指令如下：

 0 new #2 <com/atguigu/java2/Lambda>
 3 dup
 4 invokespecial #3 <com/atguigu/java2/Lambda.<init>>
 7 astore_1
 8 invokedynamic #4 <func, BootstrapMethods #0>
13 astore_2
14 aload_1
15 aload_2
16 invokevirtual #5 <com/atguigu/java2/Lambda.lambda>
19 aload_1
20 invokedynamic #6 <func, BootstrapMethods #1>
25 invokevirtual #5 <com/atguigu/java2/Lambda.lambda>
28 return

方法重写的本质

Java语言中方法重写的本质:

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

IllegalAccessError介绍: 程序试图访问或修改一个属性或调用一个方法， 这个属性或方法，你没有权限访问。一般的，这个会引起编译器异常。这个错误如果发生在运行时，就说明一个类发生了不兼容的改变。

⚠️：Maven的jar包管理冲突时容易出现这个问题，且不易发现。

虚方法表

从方法重写的本质可以看出来，频繁的查找效率低。

● 在面向对象的编程中，会很频繁的使用到动态分派，如果在每次动态分派的过程中都要重新在类的方法元数据中搜索合适的目标的话就可能影响到执行效率。因此，为了提高性能，JVM采用在类的方法区建立一个虚方法表(virtual method table) (非虚方法不会出现在表中)来实现。使用索引表来代替查找。

● 每个类中都有一个虚方法表，表中存放着各个方法的实际入口。

● 那么虚方法表什么时候被创建?
虚方法表会在类加载的链接阶段被创建并开始初始化，类的变量初始值准备完成之后，JVM会把该类的方法表也初始化完毕。

---

9 方法返回地址

方法返回地址(return address)。

● 存放调用该方法的pc寄存器的值。

一个方法的结束，有两种方式:

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

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

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

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

• ➢ 一个方法在正常调用完成之后究竟需要使用哪一个返回指令还需要根据方法返回值的实际数据类型而定。
• ➢ 在字节码指令中，返回指令包含 ireturn (当返回值是 boolean、 byte、char、 short 和 int 类型时使用)、lreturn （long）、 freturn （float）、 dreturn （double） 以及 areturn （返回引用类型）,另外还有一个 return 指令供声明为 void 的方法、实例初始化方法、类和接口的初始化方法使用。

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

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

Exception table:
from	to	target	type
4	16	19	any
19	21	19	any

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

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

---

10 一些附加信息

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

---

11 虚拟机栈的相关面试题

这一章主要讲了虚拟机栈的内部结构，其中栈帧的结构包含局部变量表、操作数栈、方法返回地址、动态链接和一些附加信息。也提到了方法调用和一些字节码指令。

• ● 举例栈溢出的情况? （StackOverflowError）
  • 通过 -Xss 设置栈的大小：OOM(栈大小动态扩容内存不足时出现)
• ● 调整栈大小，就能保证不出现溢出吗? （不能）
• ● 分配的栈内存越大越好吗? （不是。比如物理机器内存容量有限，会挤占其他进程的内存空间）
• ● 垃圾回收是否会涉及到虚拟机栈? （不会）

  运行时数据区	Error	GC
  程序计数器	❌	❌
  虚拟机栈	✅	❌
  本地方法栈	✅	❌
  堆	✅	✅
  方法区	✅	✅

• ● 方法中定义的局部变量是否线程安全? （具体问题具体分析）

package com.atguigu.java3;

/**
 * 面试题：
 * 方法中定义的局部变量是否线程安全？具体情况具体分析
 *
 *   何为线程安全？
 *      如果只有一个线程才可以操作此数据，则必是线程安全的。
 *      如果有多个线程操作此数据，则此数据是共享数据。如果不考虑同步机制的话，会存在线程安全问题。
 * @author shkstart
 * @create 2020 下午 7:48
 */
public class StringBuilderTest {

    int num = 10;

    //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的操作：是线程不安全的
    public static StringBuilder method3(){
        StringBuilder s1 = new StringBuilder();
        s1.append("a");
        s1.append("b");
        return s1;
    }
    //s1的操作：是线程安全的
    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);

    }

}

---

本地方法栈(Native Method Stack)

Java虛拟机栈用于管理Java方法的调用，而本地方法栈用于管理本地方法的调用。

本地方法栈，也是线程私有的。

允许被实现成固定或者是可动态扩展的内存大小。( 在内存溢出方面是相同的)

• ➢ 如果线程请求分配的栈容量超过本地方法栈允许的最大容量，Java虚拟机将会抛出一个 stackoverflowError 异常。
• ➢ 如果本地方法栈可以动态扩展，并且在尝试扩展的时候无法申请到足够的内存，或者在创建新的线程时没有足够的内存去创建对应的本地方法栈，那么Java虚拟机将会抛出一个 outOfMemoryError 异常。

本地方法是使用C语言实现的。

它的具体做法是Native Method Stack中登记native方法，在Execution Engine 执行时加载本地方法库。

当某个线程调用一个本地方法时，它就进入了一个全新的并且不再受虚拟机限制的世界。它和虚拟机拥有同样的权限。

• ➢ 本地方法可以通过本地方法接口来访问虚拟机内部的运行时数据区。
• ➢ 它甚至可以直接使用本地处理器中的寄存器
• ➢ 直接从本地内存的堆中分配任意数量的内存。

● 并不是所有的JVM都支持本地方法。因为Java虚拟机规范并没有明确要求本地方法栈的使用语言、具体实现方式、数据结构等。如果JVM产品不打算支持native方法，也可以无需实现本地方法栈。

● 在Hotspot JVM中，直接将本地方法栈和虚拟机栈合二为一。