jvm运行时数据区

运行时数据区概述及线程

内存是非常重要的系统资源，是硬盘和cpu的中间系统及桥梁，承载着操作系统和应用程序的实时运行。jvm内存布局规定了java在运行过程中的内存申请、分配、管理的策略，保证了jvm的高效稳定运行。不同的jvm对于内存的划分方式和管理机制存在着部分差异。结合jvm虚拟机规范，来探讨一下经典的jvm内存布局。

主要是针对hotspot

java虚拟机定义了若干种程序运行期间会使用到的运行时数据区，其中有一些会随着着虚拟机启动而创建（如上图红色区域），随着虚拟机的退出而销毁，另一些则是与线程一一对应的（如上图灰色区域），这些与线程对应的数据区域会随着线程开始和结束而结束和销毁

灰色的为单独线程私有的，红色的为多个线程共享的，即：

• 每个线程独立包括程序计数器、栈、本地栈
• 线程间共享：堆、堆外内存（永久代或元空间）、代码缓存
• 

线程

• 线程是一个程序里的运行单元，jvm允许一个应用有多个线程并行的执行。
• 在hotspot jvm里，每个线程都与操作系统的本地线程直接映射。当一个java线程准备好执行以后，此时一个操作系统的本地线程也同时创建。java线程执行终止后，本地线程也会回收。
• 操作系统负责所有线程的安排调度到任何一个可用的cpu上。一旦本地线程初始化成功，他就会调用java线程中的run()方法。

程序计数器（PC寄存器）

pc Register介绍

jvm中的程序计数寄存器(Program Counter Register)中，Register的命名源于cpu的寄存器，寄存器存储指令相关的现场信息。cpu只有把数据装载到寄存器才能够运行

这里并非是广义上所指的物理寄存器，或许将其翻译为pc计数器会更加贴切（也称为程序钩子），并且不容易引起一些不必要的误会，jvm中的pc寄存器是对物理pc寄存器的一种抽象模拟

作用：

pc寄存器用来存储指向下一条指令的地址，也即将要执行的命令代码。由执行引擎读取下一条指令。

• 它是一块很小的内存空间，几乎可以忽略不记。也是运行速度最快的存储区域
• 在jvm规范中，每个线程都有自己的程序计数器，是线程私有的，生命周期与线程的生命周期保持一致
• 任何时间一个线程都只有一个方法在执行，也就是所谓的当前方法。程序计数器会存储当前线程正在执行的java方法的jvm指令地址：或者如果实在执行native方法，则是未指定值(undefined)
• 它是程序控制流的指示器，分支、循环、跳转、异常处理、线程恢复等基础功能都需要依赖这个计数器来完成
• 字节码解释器工作时就是通过改变计数器的值来选取下一条需要执行的字节码指令
• 它是唯一一个在java虚拟机规范中没有规定任何OutotMemoryError(oom)情况的区域
• pc计数器 不存在gc和oom

举例

public class PcRegister {
     
    public static void main(String[] args) {
     
        int i=10;
        int j=20;
        int k=i+j;
    }
}

对其编译后的字节码文件进行反编译

左边的数字为指令地址（偏移地址）pc寄存器的存储地址

右边则为操作指令

两个常见问题

使用pc寄存器存储字节码指令地址有什么用？

因为cpu需要不停的切换各个线程，这时候切换回来以后，就得知道接着从哪开始继续执行

为什么使用pc寄存器记录当前线程的执行地址呢？

jvm的字节码解释器就需要通过改变pc寄存器的值来明确下一条应该执行什么样的字节码指令

pc寄存器为什么会被设定为线程私有？

我们都知道所谓的多线程在一个特点的时间段内都只会执行其中某一个线程的方法，cpu会不停的做任务切换，这样必然导致经常中断和恢复，如何保证分毫无差呢？为了能够准确记录各个线程正在执行的当前字节码指令地址，最好的办法是自然是为每一个线程都分配一个pc寄存器。这样一来各个线程之间便可以进行独立计算，从而不会出现相互干扰的情况。

由于cpu时间片轮限制，众多线程在并发执行过程中，任何一个确定的时刻，一个处理器或者多核处理器中的一个内核，只会执行某个线程中的一条指令。

这样必然导致经常中断或者恢复，如何保证分毫无差呢？每个线程在创建后，都会产生自己的pc寄存器和栈帧，程序计数器在各个线程间相互不影响

cpu时间片

并行：vs串行

并发：同时进行

虚拟机栈

1.虚拟机栈的概述

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

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

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

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

java虚拟机栈是什么？

java虚拟机栈，早期也叫java栈。每个线程都在创建时会创建一个虚拟机栈，其内部保存着一个个的栈帧(stack frame)，对应着一次次的的java方法的调用

生命周期

生命周期是和线程一致的

作用

主管java程序的运行，它保存方法的局部变量、部分结果，并参与方法的调用和返回。

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

上述作用中的局部变量，要是基本数据类型就是种基本数据类型，要是引用数据类型就是引用对象的地址。

栈的特点(优点)

• 栈是一种快速有效的分配存储方式，访问速度仅次于程序计数器
• jvm直接对java栈的操作只有两个，每个方法执行，伴随着进栈，执行结束后的出栈工作
• 对于栈来说不存在垃圾回收问题
• 栈存在oom 不存在gc

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

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

• 如果采用固定大小的java虚拟机栈，那每一个线程的java虚拟机栈容量可以在线程创建的时候独立选定，如果线程请求分配的栈容量超过java虚拟机栈所允许的最大容量，java虚拟机就会抛出一个StackOverflowError的异常
• 如果java虚拟机栈可以动态扩展，并且在尝试扩展的时候无法申请到足够的内存，或者在创建新的线程的时候没有足够的内存去创建对应的虚拟机栈，那java虚拟机将会抛出一个outofmermoryerror的异常

设置栈内存的大小

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

简单的递归测试的代码如下

package com.cxf;

/**
 * 默认情况下count最大11414
 * 设置-Xss256k
 * 设置完后的count最大未2466
 *
 */
public class StackErrorTest {
     
    private static int count=1;

    public static void main(String[] args) {
     
        System.out.println(count);
        count++;
        main(args);
    }
}

2.栈的存储单位

• 每个线程都有自己的栈，栈中的数据都已栈帧(Stack Frame)的格式存在
• 在这个线程上正在执行的每个方法都各自对应一个栈帧
• 栈帧就是一个内存区块，是一个数据集，维系着方法执行过程中的各种数据信息
• jvm直接对java栈的操作只有两个，就是对栈帧的压栈和出栈，遵循先进后出、后进先出的原则
• 在一条活动线程中，一个时间点上，只会有一个活动的栈帧、即只有当前正在执行方法的栈帧（栈顶栈帧）是有效的，这个栈帧被称为当前栈帧(current frame)，与当前栈帧对应的方法就是当前方法（current method），定义这个方法的类就是当前类(current class)
• 执行引擎运行的所有字节码指令只对当前栈帧进行操作
• 如果在该方法中调用了其他方法，对应的新的栈帧就会被创建出来，放在栈的顶端，成为新的当前帧
  

简单的测试代码理解

package com.cxf;

public class StackFrameTest {
     
    public static void main(String[] args) {
     
        method1();
    }
    public static void method1(){
     
        System.out.println("method1 begin");
        method2();
        System.out.println("method1 over");
    }
    public static  void method2(){
     
        System.out.println("method2 begin");
        method3();
        System.out.println("method2 over");
    }
    public static void method3(){
     
        System.out.println("method3 begin");
        System.out.println("method3 over");
    }
}

首先调用方法1执行过程中调用方法2创建新的栈帧，且该栈帧为当前栈帧进行执行，同理执行方法3，在程序计数器的配合下，逐次出栈完成整个方法的执行

• 不同线程中所包含的栈帧是不允许存在相互引用的，即不可能在一个栈帧之中引用另外一个线程的栈帧
• 如果当前方法调用了其他方法，方法返回之际，当前栈帧会传回此方法的执行结果给前一个栈帧，接着，虚拟机会丢弃当前的栈帧，使得前一个栈帧为当前栈帧
• java方法有两种返回函数的方法，一种是正常的函数返回，使用return指令；另外一种是抛出异常（没有处理的异常），不管是使用哪种方式，都会导致栈帧被弹出

同样使用的是上述的代码

首先来看第一种正常返回

用反编译的过的代码来看 节选的method3的 不管我们是否代码中存在返回值与否最后都会有return

另外一种抛出没有处理的异常会按照栈帧的处理顺序，传回前一个栈，对于此代码来说，如果一直到main方法该异常都未被处理，主程序会因为该异常而挂掉

package com.cxf;

public class StackFrameTest {
    public static void main(String[] args) {
        method1();
        System.out.println("main 方法执行结束");
    }
    public static void method1(){
        System.out.println("method1 begin");
        method2();
        System.out.println("method1 over");
        System.out.println(10/0);
    }
    public static  void method2(){
        System.out.println("method2 begin");
        method3();
        System.out.println("method2 over");
    }
    public static void method3(){
        System.out.println("method3 begin");
        System.out.println("method3 over");
    }
}

但如果在主程序中处理了 或者之前处理了就能正常运行结束

    try {
        method1();
    } catch (Exception e) {
        e.printStackTrace();
    }
    System.out.println("main 方法执行结束");
}

复习

• oop的基本概念：类、对象
• 类中的基本结构：filed（属性、字段、域）、method

栈帧的内部结构

每个栈帧的中存储着

• 局部变量表(local variables)
• 操作数栈(operand stack)(或表达式栈)
• 动态链接(dynamic linking)(或指向运行时常量池的方法引用)
• 方法返回值地址(return adress)（或方法正常退出或者异常退出的定义）
• 一些附加信息

3.局部变量表

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

关于solt槽的理解

• 参数值的存放总是在局部变量数组的index0开始，到数组长度-1的索引结束
• 局部表量表，最基本的存储单元是slot（变量槽）
• 局部变量表存放编译初期可知的各种基本数据类型、对象引用(reference)，以及returnadress类型
• 在局部变量表里，32位以内的类型只占用一个slot（包括returnadress类型），64位类型的（long和double）占用两个槽
  • byte、short、char在存储前被转换为int，boolean也被转换为int，0表示false，非0表示为true
  • long和double则占用两个槽
• jvm会为局部变量表中的每一个slot都分配一个访问索引，通过这个索引即可成功访问到局部变量表中指定的局部变量值
• 当一个实例方法被调用的时候，它的方法参数和方法体内部定义的局部变量将会按顺序被复制到局部变量表中的每一个slot上
• 如果需要访问局部变量表中的一个64bit的局部变量值时，只需使用前一个索引即可
• 如果当前帧是由构造方法或者实例方法创建的，那么该对象引用this将会存放在index为0的slot处，其余的参数按照参数顺序继续排列

package com.cxf;

public class test {
     
    private static  int cxf=20010113;
    public static void main(String[] args) {
     
        int m=0;
        test test = new test();
        int dec = test.dec(m);
        System.out.println(dec);
        //当前方法的局部变量表中是没有this的
        System.out.println(this.cxf);
    }

    public test() {
     
    }

    public int dec(int m){
     
        m=m-1;
        return m;
    }
}

slot的重复利用

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

package com.cxf;

public class SlotTest {
     
    private static int cxf=20010113;

    public static void main(String[] args) {
     

    }
    public void method(){
     
        int a=0;
        {
     
            int b=0;
            b=a+b;
        }
        int c=123;
    }
}

因为存在变量槽的重复利用，所以局部变量表的最大槽数为3而不是4

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

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

变量的分类：按照数据类型分为

1.基本数据类型 2.引用数据类型

按照在类中的声明位置分为

1.成员变量：在使用前，都经过默认的初始化

• 类变量：linging的parpre阶段：给类变量赋默认值，inital阶段，给类变量显示赋值即静态代码块赋值
• 实例变量：随着对象的创建，会在堆空间分配实例变量空间，并进行默认赋值

2.局部变量：在使用前必须进行显示赋值，否则编译不通过！！！

public void test(){
     
    int m;
    System.out.println(m);//错误，局部变量使用前必须初始化
}

补充说明

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

4.操作数栈

• 每一个独立的栈帧中除了包含局部变量表以外，还包含一个后进先出的操作数栈，也可以称为表达式栈

• 操作数栈，在方法执行过程中，根据字节码指令，往栈中写入数据或者提取数据，即入栈或者出栈

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

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

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

• 操作数栈就是jvm执行引擎的一个工作区，当一个方法刚开始执行的时候，一个新的栈帧也会被相应的创建出来，这个方法的操作数栈是空的

• 每一个操作数栈都会拥有一个明确的栈深度用于存储数值，其所需求的最大深度在编译器就定义好了，保存在方法的code属性中，为max_stack的值

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

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

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

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

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

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

5.代码追踪

代码如下

package com.cxf;

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

对于下边这段代码来说

package com.cxf;

public class test2 {
    public void testadd(){
        byte i=15;
        int j=8;
        int k=i+j;
    }
    public int getSum(){
        int m=10;
        int n=20;
        int k =m+n;
        return k;
    }
    public void testGetSum(){
    //获取上一个栈帧返回的结果，并保存在操作数栈中
        int i=getSum();
        int j=10;
    }
}

一上来先就load_0

6.栈顶缓存技术

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

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

7.动态链接

补充：

• 每一个栈帧的内部都包含一个指向运行时常量池中该栈帧所属方法的引用。包含这个引用的目的就是为了支持当前方法的代码能够实现动态链接（dynamic linking）比如invokedynamic指令
• 在java源文件被编译到字节码文件中时，所有的变量和方法引用都作为符号引用(symbolic reference)保存在class文件的常量池里。比如描述一个方法调用了另外的其他方法时，就是通过常量池中指向方法的符号来表示的，那么动态链接的作用就是为了将这些符号引用转换为调用方法的直接引用

#num即为符号引用

运行时常量池就是上上图中的内容

为什么需要常量池呢

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

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

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

静态链接

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

动态链接

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

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

早期绑定

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

晚期绑定

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

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

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

虚方法和非虚方法

非虚方法：

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

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

• 普通调用指令

  1.invokestatic:调用静态方法，解析阶段确定唯一方法版本

  2.invokespecial：调用方法、私有及父类方法，解析阶段确定唯一方法版本

  3.invokevirtual：调用所有虚方法

  ​ 4.调用接口方法

  ​ 动态调用指令

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

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

  测试代码如下

  package com.cxf.xiaobinggan;
  
  
  
  class Father{
         
      public Father(){
         
          System.out.println("father 的构造器");
      }
      public static void showStrstatic(String str){
         
          System.out.println("father"+str);
      }
      public final  void showFinal(){
         
          System.out.println("father show final");
      }
      public void showCommon(){
         
          System.out.println("father show common");
      }
  }
  public class Son extends  Father {
         
      public Son(){
         
          // invokespecial
          super();
      }
      public Son(int age){
         
          // invokespecial
          this();
      }
      public static void showStrstatic(String str){
         
          System.out.println("son"+str);
      }
      private void showStrPrivate(String str){
         
          System.out.println("son show private"+str);
      }
      public void show(){
         
          //invokestatic
          showStrstatic("cxf");
          // invokestatic
          super.showStrstatic("cxf");
          // invokespecial
          showStrPrivate("feifei");
          //  invokespecial
          super.showCommon();
          //invokevirtual,父类定义的final方法是无法被子类重写的，同样的为非虚方法
          showFinal();
          //invokevirtual
          info();
          MethodInterface a=null;
          // invokeinterface
          a.methoda();
  
      }
      public void info(){
         
  
      }
  }
  interface  MethodInterface{
         
      void methoda();
  }
  

• jvm字节码指令一直比较稳定，一直到java7才增加了一个invokedynamic指令，这是java为了实现动态类型语言支持而作的一种改进

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

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

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

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

说的再直白一点，静态语言就是判断变量自身的类型信息

动态类型语言是判断变量值的类型信息，变量没有类型信息，变量值才有类型信息，这是动态语言的一个重要特征

方法的调用：方法重写的本质

java语言中方法重写的本质

1.找到操作数栈顶的第一个元素所执行的实际类型，记作c

2.如果在类型c中找到与常量中的描述符合简单名称都相符的方法，则进行访问权限校验，如果通过则返回这个方法的直接引用，查找过程结束，如果不通过，则返回java.lang.IllegalAccessError异常

3.否则，按照继承关系从下往上依次对c的各个父类进行第2步的搜索和验证过程

4.如果始终没有找到合适的方法，则抛java.lang.abstractMethodError异常

IllegalAccessError介绍

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

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

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

• 那么虚方法表什么时候被创建

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

cockerspaniel重写了父类的sayhello方法同时也是接口方法的实现，定义了自己的方法saygoodbye，没有重写tostring方法所以虚方法表如上图所示

9.方法返回地址

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

• 一个方法结束有两种方式

  正常执行完成

  出现未处理的异常，非正常退出

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

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

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

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

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

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

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

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

10.一些附加信息

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

11栈的相关面试题

• 举例栈溢出的情况（stackoverflowerror）

通过-xss设置栈的大小：动态大小，整个内存空间不足oom

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

不能保证的，只是会线延迟栈溢出的出现

• 分配的栈内存越大越好嘛

不是，虽然会延迟stackoverflowerror的出现，但单个线程的内存空间过大，硬件的内存的大小是固定的，可能会影响线程总数

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

不会的

程序计数器不存在oom和gc

本地方法栈 存在oom 不存在gc

虚拟机栈存在oom 不存在gc

堆和方法区 oom和gc都存在

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

具体问题具体分析，代码如下

package com.cxf.xiaobinggan;

public class StringBuilderTest {
     
    //s1的声明方式是线程安全的
    public static void method1(){
     
        //stringbuilder是线程不安全的，要用stringbuffer就没有意义了
        /**
         * 线程安全问题
         * 如果只有一个线程去操作数据的话，线程当然是安全的
         * 但是如果多个线程去操作同个数据，且没有同步机制的话，就会存在线程安全问题
         */
        StringBuilder s1 = new StringBuilder();
        s1.append("a");
        s1.append("b");
        //...

    }
    //sb的操作过程是线程不安全的，可能被多个线程所调用
    public static void method2(StringBuilder sb){
     
        sb.append("a");
        sb.append("b");
        //...
    }
    //对s1的操作有可能存在线程不安全的问题，return 出去可能被其他线程共享
    public static  StringBuilder method3(){
     
        StringBuilder s1 = new StringBuilder();
        s1.append("a");
        s1.append("b");
        return  s1;

    }
    //内部生内部死 stringbuilder是线程安全的
    public static  String method4(){
     
        StringBuilder s1 = new StringBuilder();
        s1.append("a");
        s1.append("b");
        return  s1.toString();

    }
}