【JVM】运行时数据区介绍，程序计数器和虚拟机栈详解

布满荆棘的人生 2021-07-24 21:10 578阅读 0赞

> JVM越来越是Java面试中的`重头戏`，今天来总结一下JVM运行时数据区的相关内容。

### 文章目录 ###

*  JVM运行时数据区
 *   *  JVM运行时数据区内部结构
 *  程序计数器（PC寄存器）
 *   *  程序计数器的介绍
     *  PC寄存器的实践
     *  两个常见的问题
     *   *  使用PC寄存器存储字节码指令地址有什么用?
         *  PC寄存器为什么要设置为线程私有的？
         *  拓展
 *  虚拟机栈
 *   *  内存中的栈和堆
     *  栈的存储单位
     *  栈帧的内部结构
     *  局部变量表
     *   *  \*\*Demo：字节码中方法内部结构剖析\*\*
         *  Demo：关于Slot的理解
     *  操作数栈
     *   *  操作数栈和局部变量表代码追踪
         *  栈顶缓存技术
     *  动态链接
     *  方法的调用:解析和分派
     *  方法返回地址(Return Address)
     *  一些附加信息
     *  栈相关面试题
     *   *  1.举例说明栈溢出的情况(StackOverflowError)
         *  2.调整栈大小，就能保证不出现溢出吗？
         *  3.分配的栈内存越大越好吗？
         *  4.垃圾回收是否会涉及到虚拟机栈？
         *  5.方法中定义的局部变量是否线程安全吗？
     *  本地方法栈
     *   *  对于本地接口的理解
         *  本地方法栈

# JVM运行时数据区 #

## JVM运行时数据区内部结构 ##

![image-20201116234341847][]

JVM内部布局规定了Java在运行过程中内存申请、分配、管理的策略，保证了JVM的高效稳定运行。不同的JVM对于内存的划分方式和管理机制存在着部分差异。

**阿里对于JVM内存区域的划分**

![image-20201116234656400][]

# 程序计数器（PC寄存器） #

## 程序计数器的介绍 ##

JVM中的程序计数寄存器（Program Counter Register）中，Register的命名源于CPU的寄存器，寄存器存储相关的现场信息。CPU只有把数据装载到寄存器才能够运行。

这里，并非是广义上所指的物理寄存器，货物将其翻译为PC计数器（指令计数器）会更加贴切。`JVM中的PC寄存器是对物理PC寄存器的一种抽象模拟`（程序计数器也可以简单的理解为行号指示器）。

我们的JVM本身就是一种软件层面的虚拟机。

**作用：**

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

![image-20201116235703060][]

特点：

*  程序计数器是一片很小的内存空间，也是运行速度最快的存储区域
 *  在JVM规范中，每个线程都有它自己的程序计数器，是线程私有的，声明周期和该线程的生命周期一致。
 *  任何时间，一个线程都只有一个方法正在执行，也就是所谓的`当前方法`。程序计数器会存储当前线程正在执行的Java方法的JVM指令地址。如果正在执行的方法是一个native方法，那么程序计数器则是未指定值（undefind）
 *  它是控制流的指示器，分支、循环、跳转、异常处理、线程恢复等基础功能都需要依赖这个计数器完成
    
     *  可以和集合中的迭代器的想法是类似的，迭代器指示的是当前遍历集合中的某一个元素，而程序计数器指的是当前线程正在执行方法的下一条需要执行的指令。
 *  程序计数器是JVM规范中规定的唯一一个不会发生OOM（OutOfMemoryError）的区域。

我们在研究JVM内存区域的时候，需要关注的点就试GC和OOM

<table> 
 <thead> 
  <tr> 
   <th align="center">区域</th> 
   <th align="center">GC</th> 
   <th align="center">OOM</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">程序计数器</td> 
   <td align="center">没有</td> 
   <td align="center">没有</td> 
  </tr> 
  <tr> 
   <td align="center">堆</td> 
   <td align="center">有</td> 
   <td align="center">有</td> 
  </tr> 
  <tr> 
   <td align="center">栈</td> 
   <td align="center">不考虑GC</td> 
   <td align="center">有</td> 
  </tr> 
  <tr> 
   <td align="center">本地方法栈</td> 
   <td align="center">不考虑GC</td> 
   <td align="center">有</td> 
  </tr> 
  <tr> 
   <td align="center">方法区</td> 
   <td align="center">有</td> 
   <td align="center">有</td> 
  </tr> 
 </tbody> 
</table>

## PC寄存器的实践 ##

*  为了方便,可以在idea中安装插件jclasslib

![image-20201117002229029][]

![image-20201117002727325][]

## 两个常见的问题 ##

### 使用PC寄存器存储字节码指令地址有什么用? ###

**为什么使用PC寄存器记录当前线程的执行地址?**

因为CPU需要不停的切换各个线程,那么在切换回来之后,就需要知道接着从哪开始继续执行.

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

### PC寄存器为什么要设置为线程私有的？ ###

PC寄存器是记录当前正在执行方法的下一条即将执行的指令的行号，如果是线程之间共享的，那么在CPU切换线程时，PC寄存区所记录的行号就可以被修改，当再次切换回原来的线程时，指示的行号可能不是原来需要执行的下一条指令的行号，这时就发生了错误。因为需要给每个线程都单独的记录当前的地址值。

`为了能够准确记录各个线程正在执行的当前字节码的指令地址,最好的办法就是为每个线程都分配一个PC寄存器`。

### 拓展 ###

在实际上，我们电脑上都有多个CPU，每个CPU有多个核，我们从宏观上我们看到程序好像是并行的执行（真正的同时执行），其实微观上，程序可能是由于CPU的高速的切换，然后在固定的时间片内执行程序，是并发的操作。

# 虚拟机栈 #

由于跨平台的设计,Java的指令是根据栈来设计的。

**为什么说由于跨平台的设计,Java的指令是根据栈来设计的?**

因为Java要实现跨平台的设计（不同平台CPU的架构不同）,因此JVM中的指令是采用零指令的,也就是说只取最上层的指令,因此用栈来实现很契合。

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

## 内存中的栈和堆 ##

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

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

**Java虚拟机栈是什么？**

Java虚拟机栈，早期也叫Java栈。`每个线程`在创建时都会创建一个虚拟机栈，存储的是一个个栈帧，对应着一次次的Java方法调用

*  线程私有

**生命周期**

生命周期和线程一致

**作用**

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

**栈的特点**

*  栈是一种快速有效的分配存储方式，访问速度仅次于程序计数器
 *  JVM直接对虚拟机栈的操作
    
     *  每个方法执行，伴随着进栈（入栈，压栈）
     *  方法执行结束后的出栈
 *  对于栈来说不存在垃圾回收问题
 *  在JVM中，是可能存在OOM问题的。

![image-20201117010639315][]

也就是对于JVM中，我们只操作栈顶的元素（栈帧）。因此是零指令，跨平台。

**栈中可能出现的异常**

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

*  如果采用大小规定的Java虚拟机栈,那每一个Java虚拟机栈容量可以在线程创建的时候独立选定.如果栈线程请求分配的栈的容量大于Java虚拟机栈允许的最大容量,Java虚拟机会抛出`StackOverflowError`
 *  如果Java虚拟机可以动态扩展,并且在尝试扩展的时候无法申请到足够的内存,或者在创建新的线程时没有足够的内存去创建新的虚拟机栈,那么Java虚拟机会抛出一个`OutofMemoryError`

**设置栈的大小**

前面说倒JVM虚拟机栈是允许设置固定大小的。

`可以使用参数 -Xss (size) 选项来设置虚拟机栈的最大栈空间,栈的大小直接决定了函数调用的最大可达深度`

> 注意设置的size默认是以byte(字节为单位的),如果要设置为kb,那么就在size后面加上K或者k,如果要设置为Mb,那么就在size后面加上m或者M,如果要设置为GB,那么就在size后面加上G或者g

在Idea中设置栈的大小

![image-20201117090204899][]

![image-20201117090249700][]

## 栈的存储单位 ##

**栈中存储什么?**

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

**栈运行原理**

*  JVM直接对java栈的操作只有两个,就是对栈帧的`压栈`和`出栈`,遵循"先进后出/后进先出"原则。
 *  在一条活动线程中，一个时间点上，只会有一个活动的栈帧。即只要当前正在执行的方法的栈帧（栈顶栈帧）是有效的，这个栈帧被称为`当前栈帧`(Current Frame),与当前栈帧相对应的方法就是`当前方法`(Current Method),定义这个方法的类就是`当前类`(Current Class)。
 *  执行引擎运行的所有字节码指令只针对当前栈帧进行操作。
 *  如果在该方法中调用了其他方法,对应的新的栈帧会被创建出来,放在栈的顶端,称为新的当前帧。

![image-20201117091937953][]

*  不同线程中所包含的栈帧是不允许存在相互引用的，即不可能在一个栈帧中引用另一个线程的栈帧。
 *  如果当前方法调用了其他方法，方法返回之际，当前栈帧会传回此方法的执行结果给前一个栈帧，接着虚拟机会丢弃当前栈帧，使得前一个栈帧重新成为当前栈帧。
 *  Java方法有两种返回函数的方式，`一种是正常的函数返回,使用return指令;另一种是抛出异常(这里的抛出异常指的是我们对于异常抛出,但是在当前方法不进行处理),不管使用那种方式,都会导致栈帧被弹出`。

## 栈帧的内部结构 ##

*  `局部变量表`
 *  `操作数栈`（或表达式栈）
 *  动态链接（或指向运行时常量池的引用）
 *  方法返回地址（或方法正常退出或异常退出的定义）
 *  一些附加信息

## 局部变量表 ##

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

### **Demo：字节码中方法内部结构剖析** ###

> 1.  可以使用idea自带的反编译的命令: javap -v LocalVariablesTest.class
> 2.  也可以使用jclasslib插件快捷的剖析内部结构

![image-20201117115628167][]

![image-20201117120123342][]

关于Slot的理解

*  参数值的存放总在局部变量表(局部变量数组)的index0开始,到数组长度-1的索引结束
 *  局部变量表,`最基本的存储单元是Slot(变量槽)`
 *  局部变量表中存放编译期可知的各种基本数据类型(8种),引用数据类型(reference),returnAddress类型的变量
 *  在局部变量表中,32位以内的类型只占用一个Slot(包括returnAddress类型),64位的类型(long和double)占用两个Slot
    
     *  byte、shoot、char在存储前辈转换为int，boolean也被转换为int，0 宝石false，非0 表示true
     *  long和double则占据两个Slot
 *  JVM会为局部变量表中的每一个Slot都分配一个访问索引,通过这个索引就能够访问到局部变量表中指定的局部变量值
 *  如果需要访问的局部变量中的一个64bit的局部变量值是,只需要使用前一个索引即可。
 *  如果当前帧时由构造方法或者实例方法创建的，那么该对象引用his将会存放在index为0 的slot处，其余的参数按照参数表顺序继续排列

### Demo：关于Slot的理解 ###

![image-20201117121442356][]

1.  要注意不同的数据类型占据的Slot的槽位数量不同
2.  栈帧中局部变量表中的槽位是可以重用的，如果一个局部变量过了其作用域，那么在其作用域之后声明的新的局部变量就很有可能会复用过期局部变量的槽位，从而达到节省资源的目的。

![image-20201117122458269][]

**拓展：成员变量和局部变量的区别**

通过上面的学习，我们知道了在局部变量表中存储的是在方法中声明的局部变量。

> 变量的分类:
> 
> 按照数据类型分为:①基本数据类型变量②引用数据类型变量
> 
> 按照在类中声明的位置:①用户变量:类变量,实例变量②局部变量

使用的区别:

>  *  类变量:在linking的prepare阶段,会对类变量默认赋值---->initial阶段会对其显式赋值
>  *  实例变量:随着对象的创建,也会在堆空间中分配实例变量空间,并进行默认赋值
>  *  局部变量:是在方法执行时,会在局部变量表中分配局部变量的空间,并显式赋值

**注意:局部变量在使用之前必须进行显式赋值**

## 操作数栈 ##

操作数栈首先是一个栈的特点，也就是先进后出（后进先出）的特点

*  每一个栈帧除了有一个局部变量表以外，还有一个`后进先出`的操作数栈,也称为表达式栈
 *  `操作数栈,在方法执行的过程中,往栈中写入数据或提取数据,即入栈(push)或出栈(pop)`
    
     *  某些字节码指令将值压入操作数栈,另外一些操作指令将操作数取出操作后再压入栈内
     *  比如执行复制、交换、求和等操作。
 *  操作数栈，`主要用于保存计算过程中的中间结果,同时作为计算过程中变量的临时存储空间`
 *  操作数栈是JVM执行引擎的一个工作区域，当一个方法刚开始执行的时候，一个新的栈帧就被创建出来，`这个方法的操作数栈的空的`
 *  每一个操作数栈都有一个明确的栈深度用于存储数值,其所需的最大深度在编译期就确定了，存储在Code属性中，为max——stack的值，并且该值在方法执行时不能修改。
 *  栈中的数据结构可以是Java中任意的数据类型
    
     *  32bit的类型占用一个栈的深度
     *  64bit的类型占用两个栈的深度
 *  操作数栈虽然是用数组的方式实现的，但是不能采用索引随机访问的方式，而只能采用标准的入栈和出栈操作来完成数据访问。

### 操作数栈和局部变量表代码追踪 ###

![image-20201117145515915][]

### 栈顶缓存技术 ###

前面有提到：因为JVM采用的是栈的方式来实现指令的操作，但是伴随而来的就是完成同一个操作需要的指令更多，需要频繁的入栈和出栈。而入栈和出栈是消耗性能的。

栈顶缓存技术的思想就是：将出栈的所有操作数都缓存在CPU的寄存器中，这样避免了多次的出栈和入栈的性能消耗，这个技术可能在未来能够实现。

## 动态链接 ##

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

**理解为什么要有动态链接来指向地址,而不是直接存对象?**

1.  因为栈的内存是有限的,如果要在栈中直接存入大量的对象,那么对于栈空间的消耗是比较大的。
2.  栈是线程私有的，而很多对象和一些常量是需要线程之间共享的。如果在栈中直接存储那么就不能达到线程共享的目的。

![image-20201117151416180][]

## 方法的调用:解析和分派 ##

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

*  静态链接

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

*  动态链接

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

对应着静态链接和动态链接就有早期绑定和晚期绑定。

*  早期绑定指的是在编译期就能确定且无法更改
 *  晚期绑定指的是在运行时才能确定

对应着,也就有虚方法和非虚方法

**方法的调用：虚方法和非虚方法**

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

普通调用指令：

*  invokestatic:调用静态方法,解析阶段确定唯一方法版本
 *  invokespecial:调用< init >方法、私有及父类方法，解析阶段确定唯一版本
    
     *  注意这里调用要显式的调用，比如调用父类的方法：super.myMethod();
 *  invokevirtual:调用所有虚方法
 *  invokeinterface:调用接口方法

动态调用指令:

*  invokedynamic:动态解析出需要调用的方法,然后执行

## 方法返回地址(Return Address) ##

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

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

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

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

1.  执行引擎遇到任意一个方法返回的字节码指令（return），会有返回值传递给上层的方法调用者，简称`正常完成出口`。
    
     *  一个方法在正常调用完成之后究竟需要使用哪一个返回指令还需要根据方法返回值的实际数据类型而定。
     *  在字节码指令中，返回指令包含ireturn（当返回值是boolean、byte、char、short和int类型时使用）、lreturn、freturn、deturn以及areturn，另外还有一个return指令供声明为void的方法、实例初始化方法、类和接口的初始化方法使用。
2.  在方法执行的过程中遇到了异常（Expection），并且这个异常没有在方法内进行处理，也就是只要在本方法的异常表中没有搜索到匹配的异常处理器，就会导致方法退出。简称`异常完成出口`

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

## 一些附加信息 ##

![image-20201118193249334][]

栈帧中还允许携带与Java虚拟机实现相关的一些附加信息，例如：对程序调试提供支持的信息。（不一定有，可能有也可能没有）。

## 栈相关面试题 ##

### 1.举例说明栈溢出的情况(StackOverflowError) ###

> 该题讨论的是栈溢出,栈溢出导致的原因就是:一般情况下,栈是用数组实现的,那么在编译时期就确定了大小,那么就可能出现栈溢出的问题,导致的原因可能有:无限的递归调用（无线的递归调用会创建大量的栈帧，从而撑爆栈内存）。

**追问：当发生栈溢出时，我们怎么解决？**

1.  检查程序的逻辑，是否有无限递归，或者死循环。
2.  也可以使用-Xss size来设置栈的大小。

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

> 不能保证。
> 
> 调整栈空间的大小，能让栈空间中能存储更多的栈帧，但是还是不能保证不出现栈溢出，因为栈帧的数量可能是不确定的，可能是无限递归调用或者死循环。
> 
> 调整栈空间的大小，只能保证出现OOM的时间变晚一点。

### 3.分配的栈内存越大越好吗？ ###

> 不是。JVM中栈的内存越大意味着java程序中单个线程的内存过大，这样会影响整个java程序的程序并发数。

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

> 垃圾回收不能回收站的内存空间。
> 
> 为什么不使用垃圾回收来回收虚拟机栈的内存，因为我们虚拟机栈是一个栈结构，在该结构中的数据都被认为是正在使用的数据，当一个方法调用结束时，那么就会自动回收。不需要垃圾回收线程的额外监控。

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

> 不一定是安全的。
> 
> 栈中的局部变量表中存储的数据可能有两种，基本数据类型和引用数据类型。对于基本数据类型而言，如果是该方法是单线程操作它，那么就是线程安全的。如果是多线程操作也可能不安全。如果是引用数据类型，因为引用数据类型存储的是一个地址的引用，而该地址的引用可能同时被多个线程所操作，因此也是线程不安全的。
> 
> 特别要注意在`方法参数列表中的局部变量、返回值中的局部变量`是可能发生局部变量的引用逃逸。

**撸代码**

//线程不安全
    public staic StringBuilder method1(){ 
        //注意这里使用的一个本身线程就不安全的字符串,如果使用线程安全的字符串,那么在本身对于方法的操作都加了锁,都会是线程安全的
        StringBuilder str = new StringBuilder();
        str.append("1");
        str.append("2");
        return str;
    }

*  本身方法中操作的字符串不是一个线程安全的字符串
 *  返回的不是字符串本身(也就是该字符串的地址引用)，因此是可能造成线程不安全问题的

//线程安全
    public staic String method1(){ 
        //注意这里使用的一个本身线程就不安全的字符串,如果使用线程安全的字符串,那么在本身对于方法的操作都加了锁,都会是线程安全的
        StringBuilder str = new StringBuilder();
        str.append("1");
        str.append("2");
        return str.toString();
    }

*  本身方法中操作的字符串不是一个线程安全的字符串
 *  但是返回的是该字符串本身,而不是改字符串的地址引用
 *  返回的是str的toString()方法，在toString()方法中其实是new了一个新的String，返回的这个新的String对象是线程安全的。String用final修饰，也就是其不可改变，改变就会生成新的String。

注意甄别这两个方法。

总结一下：

在方法中

*  如果一个局部变量是产生在内部，并在内部消亡的，那么它就是线程安全的。
 *  如果一个局部变量不产生在内部或者不是在内部消亡的，那么它就不是线程安全的。

## 本地方法栈 ##

再看一眼整体的结构图：

![image-20201118202524267][]

### 对于本地接口的理解 ###

**本地方法：**

> 简单来讲,一个`Native Method就是一个Java调用非Java代码的接口`。一个Native Method是这样一个Java方法：该方法的实现是由非Java语言实现，比如C。
> 
> 本地接口的作用是融合不同的编程语言为Java所用，它的初衷是融合C/C++语言。

有本地方法栈和本地方法的原因：

1.  与Java环境之外交互
    
     *  Java语言诞生之初,希望能C/C++有更多交互,让更多人使用
     *  发展后期,希望你和其他语言交互。更健壮
2.  与操作系统交互
    
     *  和操作系统的交互,操作系统多用C/C++语言编写的,使用本地方法就能实现Java和操作系统的交互。
3.  Sun‘s java
    
     *  Sun的解释器是用C实现的,这使得它能喝普通的C一样与外部交互。

### 本地方法栈 ###

`Java虚拟机栈是管理Java方法的调用,而本地方法栈用来管理本地方法的调用`。

*  本地方法栈也是线程私有的。
 *  允许被实现成固定或者是可动态扩展的内存大小（在内存溢出方面是相同的）
    
     *  如果线程请求分配的栈容量大于本地方法栈的最大容量，俺么就会抛出StackOverflowError异常。
     *  如果本地方法栈可以动态扩展，并且在尝试扩展的时候无法申请到足够的空间或者在创建新的线程时没有足够的空间，那么就会抛出OutOfMemoryError异常。
 *  本地方法是用C语言实现的。
 *  它的具体做法是在Native Method Stack中登记native方法,在Execution Engine执行时加载本地方法库。
 *  `当某个线程调用一个本地方法时,它就进入了一个全新的并且不再受虚拟机限制的空间.它和虚拟机拥有同样的权限`
    
     *  本地方法可以通过本地方法接口来`访问虚拟机内部的运行时数据区`
     *  它甚至可以使用本地处理器中的寄存器
     *  直接从本地内存中的堆中分配任意的内存  
        Java方法的调用,而本地方法栈用来管理本地方法的调用\`。
 *  本地方法栈也是线程私有的。
 *  允许被实现成固定或者是可动态扩展的内存大小（在内存溢出方面是相同的）
    
     *  如果线程请求分配的栈容量大于本地方法栈的最大容量，俺么就会抛出StackOverflowError异常。
     *  如果本地方法栈可以动态扩展，并且在尝试扩展的时候无法申请到足够的空间或者在创建新的线程时没有足够的空间，那么就会抛出OutOfMemoryError异常。
 *  本地方法是用C语言实现的。
 *  它的具体做法是在Native Method Stack中登记native方法,在Execution Engine执行时加载本地方法库。
 *  `当某个线程调用一个本地方法时,它就进入了一个全新的并且不再受虚拟机限制的空间.它和虚拟机拥有同样的权限`
    
     *  本地方法可以通过本地方法接口来`访问虚拟机内部的运行时数据区`
     *  它甚至可以使用本地处理器中的寄存器
     *  直接从本地内存中的堆中分配任意的内存
 *  HotSpot虚拟机中将虚拟机栈和本地方法栈合二为一。

[image-20201116234341847]: /images/20210724/40933da15dd04d9e92e79a1106bc4e32.png
[image-20201116234656400]: /images/20210724/45e15da5af3044f3aa42c7b125e15f63.png
[image-20201116235703060]: /images/20210724/31194dc3a1424a5781f8b550e3ac732f.png
[image-20201117002229029]: /images/20210724/b6ef26d99938476cb49ef359398b5d4a.png
[image-20201117002727325]: /images/20210724/139aa6c6375345d8aa43eb50ae333321.png
[image-20201117010639315]: /images/20210724/cab5c385680e4952a69da42c23361e9f.png
[image-20201117090204899]: /images/20210724/f7325f3e57144c63a289efe7a92f916b.png
[image-20201117090249700]: /images/20210724/4f39a48525b940db9c725de2db6a7cdc.png
[image-20201117091937953]: /images/20210724/0a164e7e9c0d42dd8808e978787236b2.png
[image-20201117115628167]: /images/20210724/7cf44627efba4f1cb6e137e5fd2bfb7d.png
[image-20201117120123342]: /images/20210724/0f8dc4bd28294d2ca7db253d79d5f36e.png
[image-20201117121442356]: /images/20210724/6bb79d96f79b432a9335d9930bcceeb2.png
[image-20201117122458269]: /images/20210724/2fb31603352c4a41a9f4be8592229575.png
[image-20201117145515915]: /images/20210724/9f77fdbac0cc4c3b9c2dd23ac2919cf9.png
[image-20201117151416180]: /images/20210724/c48ce46087314d74ae0da119098e88c8.png
[image-20201118193249334]: /images/20210724/c5588eee279443d7b797de0ed5b7a3fc.png
[image-20201118202524267]: /images/20210724/f228c842096f4c9c9cbd99953c498051.png