05 虚拟机栈

最新推荐文章于 2022-10-07 11:31:33 发布
最新推荐文章于 2022-10-07 11:31:33 发布
阅读量63 收藏
点赞数
文章标签： java 开发语言 后端 jvm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43150129/article/details/122052771
版权

1. 虚拟机栈概述

在这里插入图片描述
https://docs.oracle.com/javase/specs/jvms/se8/html/index.html

1.1 虚拟机栈出现的背景

  • 由于跨平台性的设计，Java的指令都是根据栈来设计的。不同平台CPU架构不同，所以不能设计为基于寄存器的
  • 优点是跨平台、指令集小、编译器容易实现，缺点是性能下降，实现同样的功能需要更多的指令

1.2 内存中的栈与堆

栈是运行时的单位，而堆是存储的单位
即：栈解决程序的运行问题，即程序如何执行，或者说如何处理数据。堆解决的是数据存储问题，即数据怎么放、放在哪。
在这里插入图片描述

1.3 虚拟机栈基本内容

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

}

在这里插入图片描述

1.3.2生命周期

生命周期和线程一致，线程结束了，它的虚拟机栈也就结束了

作用

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

  • 局部变量 vs 成员变量(属性)
  • 基本数据变量 vs 引用类型变量(类、数组、接口)

1.3.3 栈的特点（优点）

  • 栈是一种快速有效的分配存储方式，访问速度仅次于程序计数器
  • JVM直接对Java栈的操作只有两个
    • 每个方法执行，伴随着进栈（入栈、压栈）
    • 执行结束后的出栈工作
  • 对于栈来说不存在垃圾回收问题；但是存在OOM（内存溢出）的情况
    在这里插入图片描述

1.3.4 栈中可能出现的异常

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

  • Java虚拟机规范允许Java栈的大小是动态的或者是固定不变的
    • 如果采用固定大小的Java虚拟机栈，那每一个线程的Java虚拟机栈容量可以在线程创建的时候独立选定，如果线程请求分配的栈容量超过Java虚拟机栈允许的最大容量，Java虚拟机将会抛出一个StackOverFlowError(栈溢出)异常
    • 如果Java虚拟机栈可以动态扩展，并且在尝试扩展的时候无法申请到足够的内存，或者在创建新的线程时没有没有足够的内存去创建对应的虚拟机栈，那Java虚拟机就会抛出一个OutOfMemoryError(内存溢出)异常
      例子：
/**
 * 演示栈中的异常：StackOverflowError
 */
public class StackError {
    public static void main(String[] args) {
        main(args);
    }
}

在这里插入图片描述

1.3.5 设置栈内存大小

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

-Xss1024m // 设置栈内存为 1024MBS
-Xss1024k // 设置栈内存为 1024KB

/**
 * 演示栈中的异常：StackOverflowError
 * 默认情况下：count：11418
 * 设置栈的大小 -Xss256k后 count:2466
 */
public class StackError {
    private static int count = 1;
    public static void main(String[] args) {
        System.out.println(count);
        count++;
        main(args);
    }
}

在这里插入图片描述
在这里插入图片描述

2. 栈的存储单位

2.1 栈中存储什么？

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

2.2 栈运行原理

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

2.3 栈帧的内部结构

每个栈帧中存储着：

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

每个线程各自有自己的栈，每一个栈中又放着很多栈帧。 栈帧的大小主要由局部变量表 和 操作数栈决定的。

在这里插入图片描述

3. 局部变量表

3.1 局部变量表

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

例子

public class LocalVariablesTest {
    private int count = 0;

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

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

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

}

在这里插入图片描述

  • 参数详解
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

3.2 关于Slot的理解

  • 参数值的存放总是从局部变量数组索引 0 的位置开始，到数组长度-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处，其余的参数按照参数表顺序继续排列
    在这里插入图片描述

3.3 Slot的重复利用

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

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

在这里插入图片描述

3.4 静态变量与局部变量的对比

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

补充说明

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

4. 操作数栈

4.1 操作数栈介绍

  • 每一个独立的栈帧除了包含局部变量表以外，还包含一个后进先出（Last - In - First -Out）的操作数栈，也可以称之为表达式栈（Expression Stack）
  • 操作数栈，在方法执行过程中，根据字节码指令，往栈中写入数据或提取数据，即入栈（push）和 出栈（pop）
    • 某些字节码指令将值压入操作数栈，其余的字节码指令将操作数取出栈。使用它们后再把结果压入栈。
    • 比如：执行复制、交换、求和等操作
      在这里插入图片描述
  • 操作数栈，主要用于保存计算过程的中间结果，同时作为计算过程中变量临时的存储空间。
  • 操作数栈就是JVM执行引擎的一个工作区，当一个方法刚开始执行的时候，一个新的栈帧也会随之被创建出来，这个时候方法的操作数栈是空的（这个时候数组是创建好并且是长度固定的，但数组的内容为空）
  • 每一个操作数栈都会拥有一个明确的栈深度用于存储数值，其所需的最大深度在编译期就定义好了，保存在方法的Code属性中，为maxstack的值。
  • 栈中的任何一个元素都是可以任意的Java数据类型
    • 32bit的类型占用一个栈单位深度
    • 64bit的类型占用两个栈单位深度
  • 操作数栈并非采用访问索引的方式来进行数据访问的，而是只能通过标准的入栈和出栈操作来完成一次数据访问
  • 如果被调用的方法带有返回值的话，其返回值将会被压入当前栈帧的操作数栈中，并更新PC寄存器中下一条需要执行的字节码指令
  • 操作数栈中元素的数据类型必须与字节码指令的序列严格匹配，这由编译器在编译器期间进行验证，同时在类加载过程中的类检验阶段的数据流分析阶段要再次验证
  • 另外，我们说Java虚拟机的解释引擎是基于栈的执行引擎，其中的栈指的就是操作数栈

5. 代码追踪

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

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

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

bipush：让操作数入栈
istore：操作数出栈，并加入局部变量表
iload：从局部变量表中加载数据

在这里插入图片描述
在这里插入图片描述在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

6. 栈顶缓存技术

  • 前面提过，基于栈式架构的虚拟机所使用的零地址指令更加紧凑，但完成一项操作的时候必然需要使用更多的入栈和出栈指令，这同时也就意味着将需要更多的指令分派（instructiondispatch）次数和内存读/写次数。
  • 由于操作数是存储在内存中的，因此频繁地执行内存读/写操作必然会影响执行速度。为了解决这个问题，HotSpot JVM的设计者们提出了栈顶缓存（Tos，Top-of-Stack Cashing）技术，将栈顶元素全部缓存在物理CPU的寄存器中，以此降低对内存的读/写次数，提升执行引擎的执行效率。
  • 寄存器的主要优点：指令更少，执行速度快

7. 动态链接

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

在这里插入图片描述

  • 每一个栈帧内部都包含一个指向运行时常量池中该栈帧所属方法的引用。包含这个引用的目的就是为了支持当前方法的代码能够实现动态链接（Dynamic Linking），比如：invokedynamic指令
  • 在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++;
    }

}

这里的#7就可以看作是动态链接
在这里插入图片描述在这里插入图片描述

为什么需要常量池呢？

  • 在不同的方法中，可能调用同一个方法或常量，只用在常量池中存储一份，然后记录他们的引用就可以了，节省了空间
  • 常量池的作用，就是为了提供一些符号和常量，便于指令的识别

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

8.1 静态链接和动态链接

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

  • 静态链接：
    当一个字节码文件被装载进JVM内部时，如果被调用的目标方法在编译期确定，且运行期保持不变时，这种情况下将调用方法的符号引用转换为直接引用的过程称之为静态链接
  • 动态链接：
    如果被调用的方法在编译期无法被确定下来，也就是说，只能够在程序运行期将调用的方法的符号转换为直接引用，由于这种引用转换过程具备动态性，因此也被称之为动态链接

8.2 方法的绑定机制

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

  • 早期绑定：
    早期绑定就是指被调用的目标方法如果在编译期可知，且运行期保持不变时，即可将这个方法与所属的类型进行绑定，这样一来，由于明确了被调用的目标方法究竟是哪一个，因此也就可以使用静态链接的方式将符号引用转换为直接引用。
  • 晚期绑定：
    如果被调用的方法在编译期无法被确定下来，只能够在程序运行期根据实际的类型绑定相关的方法，这种绑定方式也就被称之为晚期绑定
  • 随着高级语言的横空出世，类似于Java一样的基于面向对象的编程语言如今越来越多，尽管这类编程语言在语法风格上存在一定的差别，但是它们彼此之间始终保持着一个共性，那就是都支持封装、继承和多态等面向对象特性，既然这一类的编程语言具备多态特性，那么自然也就具备早期绑定和晚期绑定两种绑定方式
  • Java中任何一个普通的方法其实都具备虚函数的特征，它们相当于C++语言中的虚函数（C++中则需要使用关键字virtual来显式定义）。如果在Java程序中不希望某个方法拥有虚函数的特征时，则可以使用关键字final来标记这个方法

例子

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(); //表现为：晚期绑定
    }
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

8.3 虚方法和非虚方法

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

子类对象的多态性的使用前提

  1. 类的继承关系
  2. 方法的重写

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

  • 普通调用指令：
    invokestatic：调用静态方法，解析阶段确定唯一方法版本
    invokespecial：调用方法、私有及父类方法，解析阶段确定唯一方法版本
    invokevirtual：调用所有虚方法
    invokeinterface：调用接口方法
  • 动态调用指令：
    invokedynamic：动态解析出需要调用的方法，然后执行
  • 区别
    前四条指令固化在虚拟机内部，方法的调用执行不可人为干预。而invokedynamic指令则支持由用户确定方法版本。其中invokestatic指令和invokespecial指令调用的方法称为非虚方法，其余的（final修饰的除外）称为虚方法。
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("baidu.com");

        //invokestatic 非虚方法
        super.showStatic("good!");

        //invokespecial 非虚方法
        showPrivate("hello!");
        
        //invokevirtual
        //因为此方法声明有final，不能被子类重写，所以也认为此方法是非虚方法。
        showFinal();

        //invokespecial 非虚方法
        // 使用了super显示调用父类的showfinal方法
        super.showFinal();

        //invokevirtual 虚方法
        //有可能son会重写father的showCommon()方法
        showCommon();
        
        //invokevirtual 虚方法
      	//有可能被子类重写，所以是虚方法
        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();
    }
}

8.4 关于invokedynamic指令

  • JVM字节码指令集一直比较稳定，一直到Java7中才增加了一个invokedynamic指令，这是Java为了实现【动态类型语言】支持而做的一种改进
  • 但是在Java7中并没有提供直接生成invokedynamic指令的方法，需要借助ASM这种底层字节码工具来产生invokedynamic指令。直到Java8的 Lambda表达式 的出现，invokedynamic指令的生成，在Java中才有了直接的生成方式。
  • Java7中增加的动态语言类型支持的本质是对Java虚拟机规范的修改，而不是对Java语言规则的修改，这一块相对来讲比较复杂，增加了虚拟机中的方法调用，最直接的受益者就是运行在Java平台的动态语言的编译器。

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

  • 动态类型语言和静态类型语言两者的区别就在于对类型的检查是在编译期还是在运行期，满足前者就是静态类型语言，反之是动态类型语言
  • 说的再直白一点就是，静态类型语言是判断变量自身的类型信息；动态类型语言是判断变量值的类型信息，变量没有类型信息，变量值才有类型信息，这是动态语言的一个重要特征
@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;
        });
    }
}

在这里插入图片描述

8.5 方法重写的本质

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

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

IllegalAccessError介绍

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

8.6 虚方法表

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

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

虚方法表会在类加载的链接阶段被创建并开始初始化，类的变量初始值准备完成之后，JVM会把该类的虚方法表也初始化完毕。
在这里插入图片描述

举例1

如果子类中重写了父类的方法，那么调用的时候，就会直接在该类的虚方法表中查找
在这里插入图片描述

举例2

public class VirtualMethodTable {

}

interface Friendly {
    void sayHello();
    void sayGoodbye();
}
class Dog {
    public void sayHello() {
    }
    @Override
    public String toString() {
        return "Dog";
    }
}

class Cat implements Friendly {
    public void eat() {
    }
    public void sayHello() {
    }
    public void sayGoodbye() {
    }
    protected void finalize() {
    }
    public String toString() {
        return "Cat";
    }
}

class CockerSpaniel extends Dog implements Friendly {
    public void sayHello() {
        super.sayHello();
    }
    public void sayGoodbye() {
    }
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

9. 方法返回地址

  • 存放该方法pc寄存器的值
  • 一个方法的结束，有两种方式：
    • 正常执行完成
    • 出现未处理的异常，非正常退出
  • 无论通过哪种方式退出，在方法退出后都返回到该方法被调用的位置。方法正常退出时，调用者的pc计数器的值作为返回地址，即调用该方法的指令的下一条指令的地址。而通过异常退出的，返回地址是要通过异常表来确定，栈帧中一般不会保存这部分信息。

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

  1. 执行引擎遇到任意一个方法返回的字节码指令（return），会有返回值传递给上层的方法调用者，简称正常完成出口
    • 一个方法在正常调用完成之后，究竟需要使用哪一个返回指令，还需要根据方法返回值的实际数据类型而定
    • 在字节码指令中，返回指令包含ireturn(当返回值是boolean、byte、char、short和int类型时使用)，ireturn(Long类型)、freturn(Float类型)、dreturn (Double类型)、areturn(引用类型)、return(返回值类型为void的方法、构造器、类、静态代码块和接口的初始化方法)
  2. 在方法执行过程中遇到异常（Exception），并且这个异常没有在方法内进行处理，也就是只要在本方法的异常表中没有搜索到匹配的异常处理器，就会导致方法退出，简称异常完成出口

方法执行过程中，抛出异常时的异常处理，存储在一个异常处理表，方便在发生异常的时候找到处理异常的代码
在这里插入图片描述

总结

  • 本质上，方法的退出就是当前栈帧出栈的过程。此时，需要恢复上层方法的局部变量表、操作数栈、将返回值压入调用者栈帧的操作数栈、设置PC寄存器值等，让调用者方法继续执行下去
  • 正常完成出口和异常完成出口的区别在于：通过异常完成出口退出的不会给他的上层调用者产生任何的返回值

方法返回地址理解
假设A方法中调用B方法

首先，A方法在调用B的方法的字节码的地方，PC就记录了当前栈帧字节码的执行的位置，调用B方法的时候，构造B栈帧的时候，将B栈帧的返回地址赋值为A的字节码执行的位置，以便返回继续调用，然后将参数存储到对应的B方法的局部变量表中，设置B方法为当前栈帧，并将设置pc设置为要调用的方法的第一条指令的操作码，从该方法的第一条指令继续执行，执行完毕（正常返回或者异常返回），都会回到方法被调用的位置，B栈帧pop出栈，A栈帧恢复到当前栈帧，PC恢复到原来的A的字节码执行位置继续往下执行。

10. 一些附加信息

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

11. 栈的相关面试题

举例栈溢出的情况？（StackOverflowError）

  • 通过-Xss设置栈的大小；
  • 当栈的大小固定，栈帧很多，超过了栈的大小就会出现StackOverflowError(递归很容易出现)；当栈的大小可变，整个内存空间不足，栈去扩容的时候容易出现内存溢出(OutOfMemoryError)

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

不能，可能会晚点溢出，只要超过了栈的大小还是会溢出

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

不是

垃圾回收是否会涉及到虚拟机栈？

不会的

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

具体问题具体分析

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

    //s1的声明方式是线程安全的，因为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之后，将s1作为返回值返回，这样可能被其他线程所调用，所以存在线程不安全的问题
    public static StringBuilder method3(){
        StringBuilder s1 = new StringBuilder();
        s1.append("a");
        s1.append("b");
        return s1;
    }

    //s1的操作：是线程安全的，因为String是线程安全的
    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);
    }
}
取名字超纠结
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
05 虚拟机栈.pptx
06-26
本文记录 2020 JVM 第 5 章 虚拟机栈相关知识，包括虚拟机栈的基本知识，栈的内部结构等。 该 PPT 为重绘版本。
【JVM笔记】操作数栈与栈顶缓存技术
lijibai_的博客
07-24 301
每一个操作数栈都会拥有一个明确的栈深度用于存储数值，其所需的最大深度在编译期就定义好了，保存在方法的Code属性中，为max_stack的值。操作数栈中元素的数据类型必须与字节码指令的序列严格匹配，这由编译器在编译期间进行验证，同时在类加载过程中的类检验阶段的数据流分析阶段要再次验证。操作数栈，在方法执行过程中，根据字节码指令，往栈中写入数据或提取数据，即入栈（push）/出栈（pop）操作数栈就是JVM执行引擎的一个工作区，当一个方法刚开始执行的时候，一个新的栈帧也会随之被创建出来，.........
JVM操作数栈之栈顶缓存(看不懂捶我)
yangxiaofei_java的博客
08-01 1682
前言 语雀地址：https://www.yuque.com/yangxiaofei-vquku/wmp1zm/mggrlr 基于栈式的架构的虚拟机所使用的零地址指令更加紧凑，单完成一项操作的时候必然需要使用更多的入栈和出栈指令，虚拟机栈也是存在于内存中，这就意味着将需要更多的指令分派次数和内存读/写次数，频繁的执行内存读/写操作必然会影响执行速度，为了解决这一问题HotSpot JVM的设计者们提出了栈顶缓存（Top-of-Stack-Caching）技术，将栈顶元素（或栈顶周边）元素缓存到物理CUP的
JVM ：运行时数据区-虚拟机栈
谷咕咕
08-09 272
优点：跨平台，指令集小，编译器容易实现缺点：性能下降实现同样的工能需要更多的指令集栈是运行时的单位，而堆是存储的单元每个线程在创建是辉创建一个虚拟机栈，其内部保存的一个个栈帧队里着一次次的java方法的调用。生命周期：与线程一致。主管java程序的运行，他保持方法的局部变量，部分结果，并参与方法的调用和返回。快，仅次于pc寄存器，无gc，可能oom。只能进出栈两个操作。栈的异常stackoverflowerror 死循环线程请求分配栈容量超过java虚拟机栈的最大容量。...
JVM_栈详解一
chuige2013的博客
10-07 1431
注意事项：不同线程中所包含的栈帧是不允许存在相互引用的，即不可能在一个栈帧之中引用另外一个线程的栈帧如果当前方法调用了其他方法，方法返回之际，当前栈帧会传回此方法的执行结果给前一个栈帧，接着，虚拟机会丢弃当前栈帧，使得前一个栈帧重新成为当前栈帧。使用索引表来代替查找。方法嵌套调用的次数由栈的大小决定。Java7中增加的动态语言类型支持的本质是对Java虚拟机规范的修改，而不是对Java语言规则的修改，这一块相对来讲比较复杂，增加了虚拟机中的方法调用，最直接的受益者就是运行在Java平台的动态语言的编译器。
7. JVM虚拟机栈
weixin_45267102的博客
09-15 236
Java虚拟机栈（Java Virtual Machine Stack），早期也叫Java栈。每个线程在创建时都会创建一个虚拟机栈，其内部保存一个个的栈帧（Stack Frame），对应着一次次的Java方法调用。 Java虚拟机栈是线程私有的，生命周期和线程一致，也就是线程结束了，该虚拟机栈也销毁了。
Java内存模型中的虚拟机栈原理分析
08-25
Java内存模型中的虚拟机栈原理分析 Java内存模型中的虚拟机栈是Java虚拟机在执行Java程序时所管理的内存区域之一。虚拟机栈是Java方法执行的内存模型，主要用于存储Java方法执行的相关信息。 虚拟机栈的结构可以...
详解java中jvm虚拟机栈的作用
08-25
详解 Java 中 JVM 虚拟机栈的作用 JVM 虚拟机栈是 Java 虚拟机（JVM）中的一部分，负责管理 Java 程序的执行。虚拟机栈由一个个栈帧组成，每个栈帧包含局部变量表、操作数栈、动态连接和方法出口四部分。 局部变量...
05_虚拟机栈.pptx
05-21
虚拟机栈
【JVM】虚拟机栈的五脏六腑
12-21
【JVM】虚拟机栈是Java程序执行过程中的重要组成部分，它主要负责管理方法的调用和执行。每个线程都有自己的虚拟机栈，每当线程执行一个方法时，都会在虚拟机栈中创建一个栈帧，这个栈帧是存储方法执行状态的数据...
理解JVM(2) 栈内存，方法区，堆内存
gwt0425的博客
09-18 625
堆，方法区，栈的关系分配最大堆内存-Xmx32mclass SimpleHeap(val id: Int){ fun show() = println("My id is $id") }fun main(args: Array<String>) { val s1 = SimpleHeap(1) val s2 = SimpleHeap(2) s1.show() s
深入理解Java虚拟机栈的栈帧
热门推荐
没头脑遇到不高兴
08-25 1万+
本节将会介绍一下Java虚拟机栈中的栈帧，会对栈帧的组成部分（局部变量表、操作数栈、动态链接、方法出口）分别进行介绍，最后还会通过javap命令反解析编译后的.class文件，进行分析方法执行时的局部变量表、操作数栈等。 目录 Java虚拟机栈概述 局部变量表 操作数栈 动态连接 方法的返回地址 结合javap命令理解栈帧 Java虚拟机栈概述 Java虚拟机栈（Java Vir...
Hotspot 字节码执行与栈顶缓存实现 源码解析
菜鸟进阶之路
11-16 1986
目录 一、Interpreter::entry_for_method 二、MethodKind 三、AbstractInterpreter::_entry_table 四、AbstractInterpreterGenerator::generate_method_entry 五、InterpreterGenerator::generate_normal_entry 六、Interpre...
JVM第五篇(直接内存)
保持热爱，持续学习
11-10 761
直接内存 Direct Memory： 直接内存，并不属于JVM中的内存结构，直接内存，不由JVM进行管理。直接内存是属于系统内存。 直接内存 常见于 NIO 操作时，用于数据缓冲区 分配回收成本较高，但读写性能高 不受 JVM 内存回收管理 在进行NIO操作，可以使用直接内存来作数据缓冲区，来提高读写效率。 下图是使用堆内存用于数据缓冲区的情况： 由于Java不能对系统内存直接进行操作，所以数据线先从磁盘文件读到系统内存中，再由系统内存，读入到Java堆内存中，效率比较低。 下图是使用了直接内存作为
对Java虚拟机栈深度的理解
赵树祥的博客
02-13 3548
在读“深入理解Java虚拟机”一书时看到这个概念：在Java虚拟机规范中，对这个区域规定了两种异常状况：如果线程请求的栈深度大于虚拟机所允许的深度，将抛出StackOverflowError异常；如果虚拟机栈可以动态扩展（当前大部分的Java虚拟机都可动态扩展，只不过Java虚拟机规范中也允许固定长度的虚拟机栈），如果扩展时无法申请到足够的内存，就会抛出OutOfMemoryError异常。 理解...
本地方法栈 虚拟机栈
最新发布
10-05
本地方法栈和虚拟机栈是Java虚拟机中两个不同的栈区域。本地方法栈用于执行本地方法（也称为Native方法），而虚拟机栈用于执行Java方法（即字节码）。 本地方法栈的具体实现是由虚拟机自由决定的，有些虚拟机将本地...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值