第五章 虚拟机栈

1、虚拟机栈概述

 虚拟机栈出现的背景

1. 由于跨平台性的设计，Java的指令都是根据栈来设计的。不同平台CPU架构不同，所以不能设计为基于寄存器的【如果设计成基于寄存器的，耦合度高，性能会有所提升，因为可以对具体的CPU架构进行优化，但是跨平台性大大降低】。
2. 优点是跨平台，指令集小，编译器容易实现，缺点是性能下降，实现同样的功能需要更多的指令。

内存中的栈和堆

1. 首先栈是运行时的单位，而堆是存储的单位。
2. 即：栈解决程序的运行问题，即程序如何执行，或者说如何处理数据。堆解决的是数据存储的问题，即数据怎么放，放哪里(栈管运行，堆管存储)

虚拟机栈基本内容

• 虚拟机栈是什么
  • 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;
    }
}

• 虚拟机栈的生命周期

  • 生命周期和线程一致，也就是线程结束了，该虚拟机栈也销毁了

• 虚拟机栈的作用

  • 主管Java程序的运行，它保存方法的局部变量（8 种基本数据类型、对象的引用地址）、部分结果，并参与方法的调用和返回。
  • 局部变量，它是相比于成员变量来说的（或属性）
  • 基本数据类型变量 VS 引用类型变量（类、数组、接口）
• 栈的特点(优点)
  • 栈是一种快速有效的分配存储方式，访问速度仅次于程序计数器。
  • JVM直接对Java栈的操作只有两个：
    • 每个方法执行，伴随着进展(入栈、压栈)
    • 执行结束后的出栈工作
  • 对于栈来说不存在垃圾回收问题，不存在GC，但可能存在OOM

 面试题：开发中遇到的异常有哪些？

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

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

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

演示StackoverflowError(Main方法自己调用自己)，OOM就不演示了，要整体内存不够分配时演示。

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

设置栈的内存大小

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

Sets the thread stack size (in bytes). Append the letter k or K to indicate KB, m or M to indicate MB, and g or G to indicate GB. The default value depends on the platform:

Linux/x64 (64-bit): 1024 KB  Linux默认大小
macOS (64-bit): 1024 KB
Oracle Solaris/x64 (64-bit): 1024 KB
Windows: The default value depends on virtual memory
The following examples set the thread stack size to 1024 KB in different units:
-Xss1m -Xss1024k -Xss1048576

举例

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

在没设置参数之前，输出部分结果是：

11410
11411
Exception in thread "main" java.lang.StackOverflowError
    at sun.nio.cs.UTF_8$Encoder.encodeLoop(UTF_8.java:691)

说明栈在11411这个深度溢出了

设置栈参数之后：

2458
Exception in thread "main" java.lang.StackOverflowError
    at sun.nio.cs.UTF_8.updatePositions(UTF_8.java:77)

2、栈的存储单位

上面对虚拟机栈有了一定的了解，现在我们看一下栈内部的结构。

栈中存储什么？

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

复习：

• OOP的基本概念：类、对象
• 类中基本结构：field(属性、字段、域)、method

栈运行原理

1. JVM直接对Java栈的操作只有两个，就是对栈帧的压栈和出栈，遵循先进后出（后进先出）原则

2. 在一条活动线程中，一个时间点上，只会有一个活动的栈帧。即只有当前正在执行的方法的栈帧（栈顶栈帧）是有效的。这个栈帧被称为当前栈帧（Current Frame），与当前栈帧相对应的方法就是当前方法（Current Method），定义这个方法的类就是当前类（Current Class）

3. 执行引擎运行的所有字节码指令只针对当前栈帧进行操作。

4. 如果在该方法中调用了其他方法，对应的新的栈帧会被创建出来，放在栈的顶端，成为新的当前帧。

1. 不同线程中所包含的栈帧是不允许存在相互引用的，即不可能在一个栈帧之中引用另外一个线程的栈帧。
2. 如果当前方法调用了其他方法，方法返回之际，当前栈帧会传回此方法的执行结果给前一个栈帧，接着，虚拟机会丢弃当前栈帧，使得前一个栈帧重新成为当前栈帧。
3. Java方法有两种返回函数的方式。
   • 一种是正常的函数返回，使用return指令。
   • 另一种是方法执行中出现未捕获处理的异常，以抛出异常的方式结束。
   • 但不管使用哪种方式，都会导致栈帧被弹出。

方法的结束方式分为两种：1、正常结束，以return为代表；2、方法执行中出现未捕获处理的异常，以抛出异常的方式

栈帧的内部结构

每个栈帧中存储着：

• 局部变量表（Local Variables）

• 操作数栈（Operand Stack）（或表达式栈）

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

• 方法返回地址（Return Address）（或方法正常退出或者异常退出的定义）

• 一些附加信息

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

3、局部变量表

1. 局部变量表也被称之为局部变量数组或本地变量表
2. 定义为一个数字数组，主要用于存储方法参数(形参)和定义在方法体内的局部变量，这些数据类型包括各类基本数据类型、对象引用（reference），以及returnAddress返回值类型(返回值类型)。  --  为什么是数字数组，是因为存储的八种基本数据类型、对象引用都可以用转化成数字存储。
3. 由于局部变量表是建立在线程的栈上，是线程的私有数据，因此不存在数据安全问题
4. 局部变量表所需的容量大小是在编译期确定 下来的，并保存在方法的Code属性的maximum local variables数据项中。在方法运行期间是不会改变局部变量表的大小的(大小确定后不会被更改)。
5. 方法嵌套调用的次数由栈的大小决定。一般来说，栈越大，方法嵌套调用次数越多。
   • 对一个函数而言，它的参数和局部变量越多，使得局部变量表膨胀，它的栈帧就越大，以满足方法调用所需传递的信息增大的需求。
   • 进而函数调用就会占用更多的栈空间，导致其嵌套调用次数就会减少。
6. 局部变量表中的变量只在当前方法调用中有效。
   • 在方法执行时，虚拟机通过使用局部变量表完成参数值到参数变量列表的传递过程。
   • 当方法调用结束后，随着方法栈帧的销毁，局部变量表也会随之销毁。

举例演示：演示字节码解析后内容的含义(可以用javap -v className.class命令，也可以使用jClasslib插件)  --  这里是用static方法进行演示，非静态方法还有一点点小区别。

public static void main(String[] args) {
    LocalVariablesTest test = new LocalVariablesTest();
    int num = 10;
    test.test1();  // 这个是调用test1方法
}

 这里，我对起始PC和长度进行解释。以0和16为例。首先我们要明白，起始PC+长度=16(即字节码长度)。然后0代表的是字节码指令的行号，即0对应new #1，这是args声明的位置。我们通过查字节码和java命令对应表得知，0对应java代码的9行，即LocalVariablesTest test = new LocalVariablesTest()，这一行命令。这是这个变量生效的下一行。也就是说对应的字节码文件的行数，是这个变量声明的行号；对应的java命令，是这个变量声明的下一行(其实下一行才生效，因为上一行是声明嘛)。

关于Slot的理解  --- slot 槽的意思

1. 参数值的存放总是从局部变量数组索引 0 的位置开始，到数组长度-1的索引结束。
2. 局部变量表，最基本的存储单元是Slot（变量槽），局部变量表中存放编译期可知(局部变量表在编译期间就已经确定了)的各种基本数据类型（8种），引用类型（reference），returnAddress类型的变量。
在局部变量表里，32位以内的类型只占用一个slot（包括returnAddress类型），64位的类型占用两个slot（1ong和double）(引用类型和returnAddress都是32位，占一个Slot；long和double是8个字节，8*864个bit位)。
• byte、short、char在储存前辈转换为int，boolean也被转换为int，0表示false，非0表示true
• long和double则占据两个slot
3. JVM会为局部变量表中的每一个Slot都分配一个访问索引，通过这个索引即可成功访问到局部变量表中指定的局部变量值
4. 当一个实例方法被调用的时候，它的方法参数和方法体内部定义的局部变量将会按照顺序(即按照声明顺序排序)被复制到局部变量表中的每一个slot上
5. 如果需要访问局部变量表中一个64bit的局部变量值时，只需要使用前一个索引即可。（比如：访问long或double类型变量）
6. 如果当前帧是由构造方法或者实例方法创建的，那么该对象引用this将会存放在index为0的slot处，其余的参数按照参数表顺序继续排列。（this也相当于一个变量）。其实对于非静态方法和构造方法，他都是有某个对象的引用的，我们也可以在这些方法中使用this(代表当前对象)调用其方法和属性。

 

 面试题：为什么静态方法中不能使用this，而实例方法可以使用this，这个this只的是什么？

 因为对于实例方法，其调用当前方法锁对应的栈帧的局部变量表中有该对象引用this，放在局部变量表的第一个位置(构造方法也有)。而静态方法没有这个引用。因此实例方法可以用this，this指代的是调用该栈帧的当前对象。

局部变量表代码演示

public void test1() {
    Date date = new Date();
    String name1 = "atguigu.com";
    test2(date, name1);
    System.out.println(date + name1);
}

这个是非静态方法的局部变量表的第一个Slot位置 - this引用

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

对于构造器，也只有一个this。

Slot的重复利用

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

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

这里可以看出局部变量是4个：this、a、b和c。而b在过了作用于后，由c占用其位置。

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

变量的分类：
1、按照数据类型分：① 基本数据类型  ② 引用数据类型
2、按照在类中声明的位置分：
  2-1、成员变量：在使用前，都经历过默认初始化赋值
       2-1-1、类变量: linking的prepare阶段：给类变量默认赋值
              ---> initial阶段：给类变量显式赋值即静态代码块赋值
       2-1-2、实例变量：随着对象的创建，会在堆空间中分配实例变量空间，并进行默认赋值
  2-2、局部变量：在使用前，必须要进行显式赋值的！否则，编译不通过。

public void test() {
    int num;
    System.out.println(num); // Variable 'num' might not have been initialized
}

这个方法写在编译器里面就会飘红，因为对于局部变量，必须手动显示赋值。而对于成员变量不必要显示赋值。而成员变量又分为类变量和实例变量：其赋值过程是有区别的。

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

补充说明：

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

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

4、操作数栈

栈：可以使用数组或链表来实现。JVM的操作数栈就是用数组实现的。

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

2. 操作数栈，在方法执行过程中，根据字节码指令(字节码指令，有一部分是需要往栈中写或出数据的)，往栈中写入数据或提取数据，即入栈（push）和 出栈（pop）

   • 某些字节码指令将值压入操作数栈，其余的字节码指令将操作数取出栈。使用它们后再把结果压入栈

   • 比如：执行复制、交换、求和等操作

对于这个字节码指令，CPU是不认识的，在执行过程中，首先会用到操作数栈，执行引擎会将这个字节码指令翻译成机器指令，然后借助操作数栈执行命令。

1. 操作数栈，主要用于保存计算过程的中间结果，同时作为计算过程中变量临时的存储空间(其实就是存和取数据，然后计算，比如加，然后把加的结果放进去)。

2. 操作数栈就是JVM执行引擎的一个工作区，当一个方法刚开始执行的时候，一个新的栈帧也会随之被创建出来(其内部结构，包括局部变量表才出现)，这时方法的操作数栈是空的(栈是空的，但不代表没有被创建。既然创建了，而数组的大小是确定的，因此我们就要思考这个空的栈的长度是多少)。

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

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

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

5. 操作数栈并非采用访问索引的方式来进行数据访问(虽然他是数组，但是我们是以入栈和出栈的方式访问的)的，而是只能通过标准的入栈和出栈操作来完成一次数据访问。只不过操作数栈是用数组这个结构来实现的而已

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

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

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

 

5、代码追踪

上面我们已经将操作数栈的理论部分讲解完了，但是讲完之后一定是非常蒙的，因此这里再在代码层面进行讲解。

Java代码

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

    // int m = 800;
}

对应的字节码指令

 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

一步一步看：

1、首先执行第一条语句，PC寄存器指向的是0，也就是指令地址为0，然后使用bipush让操作数15入操作数栈。(最开始局部变量表和操作数栈的大小都是确定的，但都是空的)。  --  其实这里我有一个以为，这个局部变量表的第一个位置不是this吗？其实你或许注意到了，我们其实没有管this这个位置。

• 解释为什么局部变量表索引从 1 开始，因为该方法为实例方法，局部变量表索引为 0 的位置存放的是 this

 2、执行完后，PC寄存器往下移，指向下一行代码，下一行代码就是将操作数栈的元素存储到局部变量表1的位置（istore_1），我们可以看到局部变量表的已经增加了一个元素。并且操作数栈为空了(这里的istore_1中的1是指索引为1的位置)

 3、后PC下移，指向的是下一行。让操作数8也入栈，同时执行store操作，存入局部变量表中

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

5、iload_1：取出局部变量表中索引为1的数据入操作数栈。iload_2：去除局部变量表中索引为2的数据入栈

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

7、最后就是return结束了(没有返回值)

这里的bipush、iload和iadd都涉及到操作数栈。这个istore是保存到局部变量表。

小问题：

关于类型转换的说明

• 因为 8 可以存放在 byte 类型中，所以压入操作数栈的类型为 byte ，而不是 int ，所以执行的字节码指令为 bipush 8
• 但是存储在局部变量的时候，会转成 int 类型的变量：istore_4

• m改成800之后，byte存储不了，就成了short型，sipush 800

如果被调用的方法带有返回值，返回值入操作数栈

  public int getSum(){
        int m = 10;
        int n = 20;
        int k = m + n;
        return k;
    }

    public void testGetSum(){
        //获取上一个栈桢返回的结果，并保存在操作数栈中
        int i = getSum();
        int j = 10;
    }

getSum() 方法字节码指令：最后带着个 ireturn

testGetSum() 方法字节码指令：一上来就加载 getSum() 方法的返回值()

6、栈顶缓存技术

栈顶缓存技术：Top Of Stack Cashing

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

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

3. 寄存器的主要优点：指令更少，执行速度快，但是指令集（也就是指令种类）很多

7、动态链接

(大部分)字节码指令，他们在执行的时候，都需要常量池的访问。

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

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

}

字节码翻译

Classfile /F:/IDEAWorkSpaceSourceCode/JVMDemo/out/production/chapter05/com/atguigu/java1/DynamicLinkingTest.class
  Last modified 2020-11-10; size 712 bytes
  MD5 checksum e56913c945f897c7ee6c0a608629bca8
  Compiled from "DynamicLinkingTest.java"
public class com.atguigu.java1.DynamicLinkingTest
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Methodref          #9.#23         // java/lang/Object."<init>":()V
   #2 = Fieldref           #8.#24         // com/atguigu/java1/DynamicLinkingTest.num:I
   #3 = Fieldref           #25.#26        // java/lang/System.out:Ljava/io/PrintStream;
   #4 = String             #27            // methodA()....
   #5 = Methodref          #28.#29        // java/io/PrintStream.println:(Ljava/lang/String;)V
   #6 = String             #30            // methodB()....
   #7 = Methodref          #8.#31         // com/atguigu/java1/DynamicLinkingTest.methodA:()V
   #8 = Class              #32            // com/atguigu/java1/DynamicLinkingTest
   #9 = Class              #33            // java/lang/Object
  #10 = Utf8               num
  #11 = Utf8               I
  #12 = Utf8               <init>
  #13 = Utf8               ()V
  #14 = Utf8               Code
  #15 = Utf8               LineNumberTable
  #16 = Utf8               LocalVariableTable
  #17 = Utf8               this
  #18 = Utf8               Lcom/atguigu/java1/DynamicLinkingTest;
  #19 = Utf8               methodA
  #20 = Utf8               methodB
  #21 = Utf8               SourceFile
  #22 = Utf8               DynamicLinkingTest.java
  #23 = NameAndType        #12:#13        // "<init>":()V
  #24 = NameAndType        #10:#11        // num:I
  #25 = Class              #34            // java/lang/System
  #26 = NameAndType        #35:#36        // out:Ljava/io/PrintStream;
  #27 = Utf8               methodA()....
  #28 = Class              #37            // java/io/PrintStream
  #29 = NameAndType        #38:#39        // println:(Ljava/lang/String;)V
  #30 = Utf8               methodB()....
  #31 = NameAndType        #19:#13        // methodA:()V
  #32 = Utf8               com/atguigu/java1/DynamicLinkingTest
  #33 = Utf8               java/lang/Object
  #34 = Utf8               java/lang/System
  #35 = Utf8               out
  #36 = Utf8               Ljava/io/PrintStream;
  #37 = Utf8               java/io/PrintStream
  #38 = Utf8               println
  #39 = Utf8               (Ljava/lang/String;)V
{
  int num;
    descriptor: I
    flags:

  public com.atguigu.java1.DynamicLinkingTest();
    descriptor: ()V
    flags: 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      #2                  // Field num:I
        10: return
      LineNumberTable:
        line 7: 0
        line 9: 4
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      11     0  this   Lcom/atguigu/java1/DynamicLinkingTest;

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

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

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

2、往上面翻，找到常量池的定义：#7 = Methodref #8.#31

• 先找 #8 ：
  • #8 = Class #32 ：去找 #32
  • #32 = Utf8 com/atguigu/java1/DynamicLinkingTest
  • 结论：通过 #8 我们找到了 DynamicLinkingTest 这个类
• 再来找 #31：
  • #31 = NameAndType #19:#13 ：去找 #19 和 #13
  • #19 = Utf8 methodA ：方法名为 methodA
  • #13 = Utf8 ()V ：方法没有形参，返回值为 void

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

4、在上面，其实还有很多符号引用，比如 Object、System、PrintStream 等等

 对于上图：动态链接(指向运行时常量池的方法引用)为什么要应用常量池的东西呢：其作用是将字节码中的符号引用转变为直接引用。为什么要引用呢？为什么不直接放在字节码文件里面呢？其实很好理解。比如methodA调用methodB，那么你不能把methodB的字节码文件放到methodA里面。这样A就太庞大了。比如我们写论文，参考文献的写法，你总不能把整个参考文献拿过来吧。

为什么需要常量池呢？

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

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

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

public class OperandStackTest
{
    int num;
    public void methodA() {
        System.out.println(num);
    }
    public void methodB() {
        System.out.println(num);
    }
}

比如这个代码：两个方法都调用了num，你就不需要存储num两份。

8、方法的调用：解析与分派

 上面讲了局部变量表、操作数栈和指向运行时常量池的方法引用。下面在讲方法返回地址和一些附加信息前先讲一下方法的调用。这个是剩下的信息中的重头戏，翻到方法返回地址和一些附加信息比较简单。我们天天都是在方法的调用，讲这个是希望我们对方法的调用有更深的理解。

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

• 静态链接：

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

• 动态链接：

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

早期绑定与晚期绑定

静态链接与动态链接针对的是方法。早期绑定和晚期绑定范围更广。早期绑定涵盖了静态链接，晚期绑定涵盖了动态链接。

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

• 早期绑定

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

• 晚期绑定

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

package com.atguigu.java2;

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();//表现为：晚期绑定   ---  这个Animal是父类，我们不能确定是调用的哪个方法
    }

    public void showHunt(Huntable h) {
        h.hunt();//表现为：晚期绑定   --- 这个接口我们也不能确定调用的是哪个方法
    }
}

{
  public com.atguigu.java2.AnimalTest();
    descriptor: ()V
    flags: 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 54: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       5     0  this   Lcom/atguigu/java2/AnimalTest;

  public void showAnimal(com.atguigu.java2.Animal);
    descriptor: (Lcom/atguigu/java2/Animal;)V
    flags: ACC_PUBLIC
    Code:
      stack=1, locals=2, args_size=2
         0: aload_1
         1: invokevirtual #2                  // Method com/atguigu/java2/Animal.eat:()V
         4: return
      LineNumberTable:
        line 56: 0
        line 57: 4
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       5     0  this   Lcom/atguigu/java2/AnimalTest;
            0       5     1 animal   Lcom/atguigu/java2/Animal;

  public void showHunt(com.atguigu.java2.Huntable);
    descriptor: (Lcom/atguigu/java2/Huntable;)V
    flags: ACC_PUBLIC
    Code:
      stack=1, locals=2, args_size=2
         0: aload_1
         1: invokeinterface #3,  1            // InterfaceMethod com/atguigu/java2/Huntable.hunt:()V
         6: return
      LineNumberTable:
        line 60: 0
        line 61: 6
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       7     0  this   Lcom/atguigu/java2/AnimalTest;
            0       7     1     h   Lcom/atguigu/java2/Huntable;
}
SourceFile: "AnimalTest.java"

 invokevirtual 体现为晚期绑定

invokeinterface 也体现为晚期绑定

invokespecial 体现为早期绑定

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

2. Java中任何一个普通的方法其实都具备虚函数的特征(虚函数的特征：只有在运行期才能确定下来)，它们相当于C++语言中的虚函数（C++中则需要使用关键字virtual来显式定义）。如果在Java程序中不希望某个方法拥有虚函数的特征时，则可以使用关键字final来标记这个方法(不能重写，即只有一个，在编译期就确定了)。

虚方法和非虚方法

1. 如果方法在编译期就确定了具体的调用版本，这个版本在运行时是不可变的。这样的方法称为非虚方法。
2. 静态方法、私有方法、final方法、实例构造器、父类方法都是非虚方法(既然是虚方法，在编译器就确定了版本，因此你确定时，也可以根据是否涉及方法的重写来判断)。
3. 其他方法称为虚方法。

子类对象的多态性的使用前提：1、类的继承关系；2、方法的重写。静态方法、私有方法和final方法、构造器都是不能被重写的。对于最后一个父类方法，这个怎么理解呢？父类有一个方法A，子类也有个方法A，然后子类方法A调用父类方法A，此时非常确定调用的就是父类的方法A，因此也是非虚方法。

虚拟机中调用方法的指令

• 普通指令：

1. invokestatic：调用静态方法，解析阶段确定唯一方法版本  -- 非虚方法
2. invokespecial：调用<init>方法、私有及父类方法，解析阶段确定唯一方法版本  -- 非虚方法
3. invokevirtual：调用所有虚方法  -- 虚方法 但要除final
4. invokeinterface：调用接口方法  -- 虚方法 但要除final

• 动态调用指令

invokedynamic：动态解析出需要调用的方法，然后执行

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

举例：

package com.atguigu.java2;

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  -- 非虚方法，编译器就能确定
        Father.showStatic("good!");
        //invokespecial  -- 非虚方法，编译器就能确定
        showPrivate("hello!");
        //invokespecial  -- 非虚方法，编译器就能确定
        super.showCommon();

        //invokevirtual  virtural看似是虚，其实还是非虚方法
        showFinal();//因为此方法声明有final，不能被子类重写，所以也认为此方法是非虚方法。
        //invokespecial  这个就是显式的调用了  这就更是非虚方法了
        super.showFinal();
        //虚方法如下：

        /*
        invokevirtual  你没有显示的加super.，编译器认为你可能调用子类的showCommon(即使son子类没有重写，也          会认为)，所以编译期间确定不下来，就是虚方法。
        */
        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指令

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

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

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

动态类型语言和静态类型语言

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

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

Java语言其实是静态类型语言，只是有了这个invokedynamic指令后，才可以称为动态类型语言，这说明java语言也是在不断的迭代更新。

Java：String info = "mogu blog"; (Java是静态类型语言的，会先编译就进行类型检查) ，会检查后面你写的这个东西是不是String类型，如果不是，编译器就报错；JS：var name = "shkstart"; var name = 10; （运行时才进行检查）。

举例：invokedynamic

package com.atguigu.java2;

/*
* 体会invokedynamic指令
* */
@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;
        });
    }
}

Java中方法重写的本质

方法重写才出现了虚方法，虚方法的本质是方法重写

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

上面这个过程称为动态分派

IllegalAccessError介绍：

1. 程序试图访问或修改一个属性或调用一个方法，这个属性或方法，你没有权限访问。一般的，这个会引起编译器异常。这个错误如果发生在运行时，就说明一个类发生了不兼容的改变。
2. 比如，你把应该有的jar包放从工程中拿走了，或者Maven中存在jar包冲突

虚方法表

1. 在面向对象的编程中，会很频繁的使用到动态分派，如果在每次动态分派的过程中都要重新在类的方法元数据中搜索合适的目标的话就可能影响到执行效率。因此，为了提高性能，JVM采用在类的方法区建立一个虚方法表（virtual method table）来实现，非虚方法不会出现在表中。使用索引表来代替查找。【上面动态分派的过程，我们可以看到如果子类找不到，还要从下往上找其父类，非常耗时】--- 即上面的4步，是确定虚方法具体调用哪一个的过程  非常好使。    --- 对于非虚方法，不需要表，因为非常确定调用的是哪一个。非虚方法有：静态方法、私有方法、final方法、实例构造器、父类方法

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

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

例子1：

如图所示：如果类中重写了方法，那么调用的时候，就会直接在该类的虚方法表中查找

这里Father继承自Object，并重写了hardChoice(QQ)和hardChoice(_360)方法。而Son继承自Father，其它方法来自Object，而也有自己的从写的两个方法。

1、比如说son在调用toString的时候，Son没有重写过，Son的父类Father也没有重写过，那就直接调用Object类的toString。那么就直接在虚方法表里指明toString直接指向Object类。

2、下次Son对象再调用toString就直接去找Object，不用先找Son-->再找Father-->最后才到Object的这样的一个过程。

9、方法返回地址

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. 方法执行过程中，抛出异常时的异常处理，存储在一个异常处理表，方便在发生异常的时候找到处理异常的代码

这是一张异常表，后面讲到字节码指令时，还会讲到

异常处理表：

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

比如19 21 19 any，意思是如果19-21行出现任何异常，则跳转到19行进行处理。

10、一些附加信息

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

11、栈的相关面试题

 举例栈溢出的情况？(StackOverflowError)

SOF（StackOverflowError），栈大小分为固定的，和动态变化。如果是固定的就可能出现StackOverflowError。如果是动态变化的，内存不足时就可能出现OOM。可以通过-Xss设置栈的大小。

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

不能保证不溢出，只能保证SOF出现的几率小

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

不是，一定程度上降低了SOF的概率(固定栈的大小)，但是会挤占其它的线程空间，因为整个虚拟机的内存空间是有限的

垃圾回收是否会设计到虚拟机栈？

不会

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

具体问题具体分析

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

 这里我们要理解这道题。按道理局部变量表是虚拟机栈里面的栈帧里面的内容，一个线程对应一个栈帧，因此，可以说一个局部变量表也是对应一个线程的。那怎么会有线程不安全的情况呢？对于局部变量表上的内容，这个变量肯定是方法中的形参，或局部变量。如果这个变量是形参，则是从外边传过来的，这个传过来的变量，如果不是其它局部变量表的内容的话，比如是实例变量，就可能会被其它线程操作；还有如果这个变量作为方法返回值返回了，那么返回出去后可能会被其它线程操作(应该是个地址要赋值给其它吧？)，然后也可能会被操作。

具体是否有线程安全，看下面的4中情况，其中形参和作为返回值是可能会不安全的。

/**
 * 面试题：
 * 方法中定义的局部变量是否线程安全？具体情况具体分析
 *
 *   何为线程安全？
 *      如果只有一个线程才可以操作此数据，则必是线程安全的。
 *      如果有多个线程操作此数据，则此数据是共享数据。如果不考虑同步机制的话，会存在线程安全问题。
 */
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的操作：是线程安全的（s1自己消亡了，最后返回的只是s1.toString的一个新对象）
    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);

    }

}

{publiccom.atguigu.java2.AnimalTest(); descriptor:()V flags: ACC_PUBLIC Code: stack=1, locals=1, args_size=10: aload_0 1: invokespecial #1// Method java/lang/Object."<init>":()V4:returnLineNumberTable: line 54:0LocalVariableTable:StartLengthSlotNameSignature050thisLcom/atguigu/java2/AnimalTest;publicvoidshowAnimal(com.atguigu.java2.Animal); descriptor:(Lcom/atguigu/java2/Animal;)V flags: ACC_PUBLIC Code: stack=1, locals=2, args_size=20: aload_1 1: invokevirtual #2// Method com/atguigu/java2/Animal.eat:()V4:returnLineNumberTable: line 56:0 line 57:4LocalVariableTable:StartLengthSlotNameSignature050thisLcom/atguigu/java2/AnimalTest;051 animal Lcom/atguigu/java2/Animal;publicvoidshowHunt(com.atguigu.java2.Huntable); descriptor:(Lcom/atguigu/java2/Huntable;)V flags: ACC_PUBLIC Code: stack=1, locals=2, args_size=20: aload_1 1: invokeinterface #3,1// InterfaceMethod com/atguigu/java2/Huntable.hunt:()V6:returnLineNumberTable: line 60:0 line 61:6LocalVariableTable:StartLengthSlotNameSignature070thisLcom/atguigu/java2/AnimalTest;071 h Lcom/atguigu/java2/Huntable;}SourceFile:"AnimalTest.java"