java Stack（虚拟机栈）

你的名字 2023-02-10 05:21 17阅读 0赞

### 文章目录 ###

*   *  1、Java 虚拟机栈的定义
     *   *  1.1、异常
         *  1.2、栈帧（Stack Frame）
     *  2、局部变量表（Local Variable Table）
     *   *  2.1、面试题：基本数据和对象引用存储在栈中 ？
         *  2.2、静态变量与局部变量的对比
         *  2.3、reference（对象实例的引用)
         *  2.4、Slot（ 变量槽 ）
         *   *  2.4.1、Slot 的理解
             *  2.4.2、Slot的复用
         *  2.5、补充说明
     *  3、操作数栈（Operand Stack）
     *   *  3.1、代码追踪
         *  3.2、栈顶缓存技术 （Top-of-StackCashing）
     *  4、动态链接（Dynamic Linking）
     *  5、方法的调用
     *   *  5.1、静态链接、动态链接
         *  5.2、早期绑定、晚期绑定 与 多态
         *  5.3、虚方法 、非虚方法
         *  5.4、方法调用指令
         *  5.5、 \`invokedynamic\` 指令
         *  5.6、方法重写的本质
     *  6、方法返回地址（Return Address）
     *   *  6.1、正常完成出口和异常完成出口的区别：
     *  7、一些附加信息

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hpYW9qaW4yMWNlbg_size_16_color_FFFFFF_t_70]

## 1、Java 虚拟机栈的定义 ##

Java 虚拟机栈（java Virtual Machine Stack），每个线程在创建时都会创建一个虚拟机栈，其内部保存一个个 **栈帧（Stack Frame）**。

*  虚拟机栈，描述的是Java方法执行的内存模型：每个方法执行的同时会创建一个栈帧。
 *  是线程私有的，它的生命周期与线程相同（随线程而生，随线程而灭）
 *  对于我们来说，主要关注的stack栈内存，就是虚拟机栈中局部变量表。

### 1.1、异常 ###

虚拟机栈 不存在GC（垃圾回收）。

*  StackOverflowError  
    如果线程请求的栈深度大于虚拟机所允许的深度，将抛出异常；
 *  OutOfMemoryError  
    如果虚拟机栈可以动态扩展，如果扩展时无法申请到足够的内存，就会抛出异常；  
    　（当前大部分JVM都可以动态扩展，只不过JVM规范也允许固定长度的虚拟机栈）

### 1.2、栈帧（Stack Frame） ###

栈帧（Stack Frame）是用于支持虚拟机进行方法调用和方法执行的数据结构。它是虚拟机栈的栈元素。  
栈帧存储了方法的局部变量表、操作数栈、动态连接和方法返回地址等信息。  
每一个方法从调用开始至执行完成的过程，都对应着一个栈帧在虚拟机里面从入栈到出栈的过程。

**注意：**

在编译程序代码的时候，栈帧中需要多大的局部变量表内存，多深的操作数栈都已经完全确定了。  
因此一个栈帧需要分配多少内存，不会受到程序运行期变量数据的影响，而仅仅取决于具体的虚拟机实现。

![在这里插入图片描述][20200520150544469.png]

栈帧的操作只有两个：压栈（push）和 出栈（ pop）。  
在一个线程中，只有位于栈顶的栈帧才是有效的，称为 `当前栈帧` ，与这个栈帧相关联的方法称为 `当前方法` 。  
执行引擎运行的所有字节码指令都只针对当前栈帧进行操作；  
如果 `当前方法调` 用其他方法，对应的新的栈帧才会被创建出来，放到栈顶，成为新的 `当前栈帧`。

栈帧的内部结构：

*  局部变量表（Local Variable Table）
 *  操作数栈 （Operand Stack）（或者叫表达式栈）
 *  动态链接 （Dynamic Linking） （或指向运行时常量池的方法引用）
 *  方法返回地址（Return Address）
 *  一些附加信息

下面介绍栈帧的各个成员。

## 2、局部变量表（Local Variable Table） ##

局部变量表（Local Variable Table），也叫 局部变量数组，用于存放 方法参数 和 方法体内部的局部变量。

局部变量表存放了编译期可知的8种基本数据类型、对象引用（reference类型，包括String ）和 returnAddress 类型。

局部变量表的 容量大小，在Java编译为Class文件时就确定下来的，并保存在方法的Code 属性的maximnum\_local\_variables 数据项中。 方法运行期间是不会改变局部变量表的大小。

### 2.1、面试题：基本数据和对象引用存储在栈中 ？ ###

> 当然这种说法虽然是正确的，但是很不严谨，只能说这种说法针对的是 **局部变量**。
> 
> 局部变量 存储在局部变量表 中，随着线程而生，线程而灭。并且线程间数据不共享。
> 
> 但是，如果是成员变量，或者定义在方法外对象的引用，它们存储在堆中。
> 
> 因为在堆中，是线程共享数据的，并且栈帧里的命名就已经清楚的划分了界限 : 局部变量表。

### 2.2、静态变量与局部变量的对比 ###

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

我们知道类变量表有两次初始化的机会，**第一次** 是在准备阶段，执行系统初如化，对类变量设置默认值\*\*，另一次\*\* 则是在初始化阶段，赋予变量在代码中定义的初始值。

和类变量不同，局部变量表不存在系统初始化的过程，这就需要在定义局部变量时必须人为的初始化，否则无法使用。

public void test(){ 
    	int i;
    	System.out.println(i);
    }

上面的代码是错误的，会编译报错的，因为没有i没有初始值。

**总结：**

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

### 2.3、reference（对象实例的引用) ###

我的理解是：一个超链接

一般来说，虚拟机都能从引用中直接或者间接的查找到对象的以下两点 ：

a. 在Java堆中的数据存放的起始地址索引。

b. 所属数据类型在方法区中的存储类型。

例如:我们在创建一个Student对象时的数据存储结构 ：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hpYW9qaW4yMWNlbg_size_16_color_FFFFFF_t_70 1]

### 2.4、Slot（ 变量槽 ） ###

局部变量表，最基本的存储单元是Slot （变量槽）。

*  32位以内的类型占用一个slot ：6种基本数据类型、reference、returnAddress 。
 *  64位的类型的占用两个slot ： long 、double 。
    
        虚拟机会以高位对齐方式为其分配两个连续的Slot空间，也就是相当于把一次long和double数据类型读写分割成为两次32位读写。

#### 2.4.1、Slot 的理解 ####

JVM 会为局部变量表中的每一个Slot分配一个访问索引，通过这个索引即可成功访问局部变量表中指定的局部变量值。

当一个实例方法被调用时，它的方法参数和方法体内部定义的局部变量将会按照顺序被复制到局部变量表中的每一个Slot上。

如果需要访问局部变量表中的一个64bit的局部变量时，只需要使用前一个索引即可。（访问long 或 double 类型的变量）

如果当前帧是由构造方法或实例方法创建的，那么该对象引用this将会存放到index为0的slot处，其余的参数按照参数表顺序继续排列。

#### 2.4.2、Slot的复用 ####

为了尽可能节省栈帧空间，局部变量表中的Slot是可以重用的，  
也就是说当PC计数器的指令指已经超出了某个变量的作用域（执行完毕），  
那这个变量对应的Slot就可以交给其他变量使用。

优点 ： 节省栈帧空间。  
缺点 ： 影响到系统的垃圾收集行为。

（如大方法占用较多的Slot，执行完该方法的作用域后没有对Slot赋值或者清空设置null值，垃圾回收器便不能及时的回收该内存。）

### 2.5、补充说明 ###

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

在方法执行时，虚拟机使用局部变量表完成方法的传递。

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

## 3、操作数栈（Operand Stack） ##

每个独立的栈帧中除了包含局部变量表以外，还包含 一个后进先出（Last-In-First-Out）的操作数栈，也叫 表达式栈。

操作数栈，在方法执行过程中，根据字节码指令，往栈中写入数据或提取数据，即入栈（push）/出栈（pop）。

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

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

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

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

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

栈中的任何元素都是可以任意的java数据类型：

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

操作数栈并非采用访问索引的方式来进行数据访问的，而是只能通过标准的入栈（push）和出栈（pop）操作来完成一次数据访问。

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

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

java虚拟机的解析引擎是基于栈的执行引擎，其中的栈就是操作数栈。

### 3.1、代码追踪 ###

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

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

### 3.2、栈顶缓存技术 （Top-of-StackCashing） ###

前面提过，基本栈架构的虚拟机使用的零地址指令更紧凑，但完成一项操作时必须要使用更多的入栈和出栈指令，这就意味着需要更多的指令分派次数和内存读写次数。

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

## 4、动态链接（Dynamic Linking） ##

动态链接（Dynamic Linking） ，也叫指向运行时常量池的方法引用。

每一个栈帧内部都包含 一个指定运行时常量池中该栈帧所属方法的引用。

包含这们引用的目的就是为了支持当前方法的代码能够实现动态链接（Dynamic Linking）。比如：invokeddynamic 指令。

在java源文件被编译为字节码文件时，所有的变量和方法引用都作为符号引用（Symbolic Reference）保存在class文件的常量池里。

比如：描述一个方法调用其他方法时，就是通过常量池中指向方法的符号引用来表示的，那么动态链接的作用就是为了将这些符号引用转换为调用方法的直接引用。

> 为什么需要常量池？
> 
> 常量池的作用，就昌为了提供一些符号和常量，便于指令的识别。

## 5、方法的调用 ##

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

### 5.1、静态链接、动态链接 ###

**静态链接：**

在类加载阶段中的解析阶段，如果被调用的目标方法在编译可知，且运行期保持不变时。 这种情况下将调用方法的符号引用转换为直接引用的过程称为静态链接。

**动态链接：**

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

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

### 5.2、早期绑定、晚期绑定 与 多态 ###

**早期绑定：**

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

**晚期绑定：**

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

类似于java的面向对象的编译语言，尽管语法风格不同，但保持一个共性，就是都技术封装、继承 和 多态 等面向对象的特性。

这类编程语言具备多态特性，那么自我就具备早期绑定和晚期绑定。

### 5.3、虚方法 、非虚方法 ###

**虚方法**

java中任何一个普通的方法都具备虚函数的特征，相当于C++中的虚函数（C++使用 virtual 关键字显示定义）。如果在java中不希望某个方法拥有虚函数的特征时，使用 final 关键字来标记。

**非虚方法：**

如果在方法编译期就确定了具本的调用版本，这个版本在运行时是不可变的。 这样的方法称为 非虚方法。

静态方法、私用方法、final方法、实例构造器、父类方法都是非虚方法。

其他方法称为虚方法。

对类对象的多态性的使用前提： 类的继承、方法的重写

虚方法表什么时候被创建？

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

### 5.4、方法调用指令 ###

**普通调用指令：**

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

<table> 
 <thead> 
  <tr> 
   <th>序号</th> 
   <th align="left">名称</th> 
   <th align="left">说明</th> 
   <th align="left">是否虚方法</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td align="left"><code>invokestatic</code></td> 
   <td align="left">调用静态方法，解析阶段确定唯一方法的版本。</td> 
   <td align="left">非虚方法</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td align="left"><code>invokespecial</code></td> 
   <td align="left">调用<code>&lt;init&gt;</code> 方法、私用及父类方法，解析阶段确定唯一方法版本。</td> 
   <td align="left">非虚方法</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td align="left"><code>invokevirtual</code></td> 
   <td align="left">调用所有虚方法</td> 
   <td align="left">虚方法</td> 
  </tr> 
  <tr> 
   <td>4</td> 
   <td align="left"><code>invokeinterface</code></td> 
   <td align="left">调用接口方法</td> 
   <td align="left">虚方法</td> 
  </tr> 
 </tbody> 
</table>

**动态调用指令：**

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

普通调用指令 固化在虚拟机内部， 方法的调用执行不可人为干预。

而 `invokedynamic` 指令则支持用户确定方法版本。

`invokestatic`和 `invokespecial`指令调用的方法称为非虚方法，其余的（final修改的除外）称为虚方法。

### 5.5、 `invokedynamic` 指令 ###

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

但是 java7 中并没有提供直接生成 `invokedynamic` 指令的方法，需要 借助ASM 这种底层字节码指令工具来产生 `invokedynamic` 指令。

JDK8的 Lambda 表达式的出现，`invokedynamic` 指令的生成，在java中才有了直接的生成方式。

**动态类型的语言 和 静态类型语言的区别？**

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

### 5.6、方法重写的本质 ###

java语言中方法重写的本质：

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

**IllegalAccessError 介绍：**

程序试图访问或修改一个属性或调用一个方法，这个属性或方法，你没有权限访问。

一般的，这个会引起编译器异常。

这个错误如果发生在运行时，就说明一个类发生了不兼容的改变。

package demo3;
    
    interface Friendly { 
    
    	void sayHello();
    	void sayGoodbye();
    }
    
    class Dog { 
    	public void sayHello() { 
    	}
    
    	public String toString() { 
    		return "Dog";
    	}
    }
    
    class Cat implements Friendly { 
    
    	@Override
    	public void sayHello() { 
    	}
    
    	@Override
    	public void sayGoodbye() { 
    	}
    
    	public void eat() { 
    
    	}
    
    	protected void finalize() { 
    
    	}
    }
    
    class CockerSpaniel extends Dog implements Friendly { 
    
    	@Override
    	public void sayGoodbye() { 
    	}
    
    	public void sayHello() { 
    		super.sayHello();
    	}
    }
    
    public class Main { 
    	public static void main(String[] args) { 
    		CockerSpaniel cockerSpaniel=new CockerSpaniel();
    		System.out.println(cockerSpaniel.toString());
    	}
    }

## 6、方法返回地址（Return Address） ##

存放调用方法的PC计数器的值。

一个方法结束，有两种方式：

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

无论通过哪种方式退出，在方法退出后都返回到该方法被调用的位置。

方法正常退出时，调用者的PC计数器的值作为返回地址，即调用方法的指令的下一条指令的地址。

异常退出时，返回地址是要通过异常表来确定，栈帧中一般不会保存这部分信息。

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

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

### 6.1、正常完成出口和异常完成出口的区别： ###

异常完成出口退出的不会给他的上层调用者产生任何的返回值。

## 7、一些附加信息 ##

对程序调试提供支持的信息。

LineNumberTable ： 字节码 与 java 源码行号 的对应关系  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hpYW9qaW4yMWNlbg_size_16_color_FFFFFF_t_70 2]

每个LineNumberTable中的 line\_number\_table部分， 可以看做是一个数组， 数组的每项是一个line\_number\_info ，

每个 line\_number\_info 结构描述了一条字节码和源码行号的对应关系。

*  start\_pc 是这个 line\_number\_info 描述的字节码指令的偏移量，
 *  line\_number 是这个 line\_number\_info 描述的字节码指令对应的源码中的行号。

方法中的每条字节码都对应一个 line\_number\_info ， 这些 line\_number\_info 中的 line\_number 可以指向相同的行号， 因为一行源码可以编译出多条字节码。

LocalVariableTable ： 方法的栈帧中局部变量中的变量名和描述符、源码的对应关系。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hpYW9qaW4yMWNlbg_size_16_color_FFFFFF_t_70 3]

每个 LocalVariableTable 的 local\_variable\_table 部分可以看做是一个数组，

每个数组项是一个叫做 local\_variable\_info 的结构， 该结构描述了某个局部变量的变量名和描述符， 还有和源代码的对应关系。

下面讲解 local\_variable\_info 的各个部分：

1.  start\_pc ，是当前的局部变量的作用域的起始字节码偏移量；
2.  length ，是当前的局部变量的作用域的大小。 也就是从字节码偏移量 start\_pc 到 start\_pc+length 就是当前局部变量的作用域范围；
3.  index ，这个局部变量在栈帧局部变量表中Slot的位置。当这个变量是 64 位类型时，它占用的Slot 为 index and index + 1;
4.  name\_index ，指向常量池中的一个 CONSTANT\_Utf8\_info 型常量的索引， 该 CONSTANT\_Utf8\_info 描述了当前局部变量的变量名；
5.  descriptor\_index ，指向常量池中的一个 CONSTANT\_Utf8\_info 型常量的索引， 该 CONSTANT\_Utf8\_info 描述了当前局部变量的描述符；

由此可知， 方法中的每个局部变量都会对应一个local\_variable\_info 。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hpYW9qaW4yMWNlbg_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200520150443117.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hpYW9qaW4yMWNlbg==,size_16,color_FFFFFF,t_70
[20200520150544469.png]: https://img-blog.csdnimg.cn/20200520150544469.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hpYW9qaW4yMWNlbg_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200520150630156.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hpYW9qaW4yMWNlbg==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hpYW9qaW4yMWNlbg_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20200520150750509.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hpYW9qaW4yMWNlbg==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hpYW9qaW4yMWNlbg_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20200520150812600.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hpYW9qaW4yMWNlbg==,size_16,color_FFFFFF,t_70