运行时数据区（程序计数器、虚拟机栈、本地方法栈）
2021/5/1 22:27:25
本文主要是介绍运行时数据区（程序计数器、虚拟机栈、本地方法栈），对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！
运行时数据区概述
内存是非常重要的系统资源，是硬盘和CPU的中间仓库及桥梁，承载着操作系统和应用程序的实时运行。JVM内存布局规定了Java在运行过程中内存申请、分配、管理的策略，保证了JVM的高效稳定运行。不同的JVM对于内存的划分方式和管理机制存在着部分差异。结合JVM虚拟机规范，来探讨一下经典的JVM内存布局。
Java虚拟机定义了若干种程序运行期间会使用到的运行时数据区，其中有一些会随着虚拟机（虚拟机是一个进程）启动而创建，随着虚拟机退出而销毁。另外一些则是与线程一一对应的，这些与线程对应的数据区域会随着线程开始和结束而创建和销毁。
下图灰色的为单独线程私有的，红色的为多个线程共享的。即:每个线程:独立包括程序计数器、栈、本地栈。
线程间共享:堆、堆外内存（永久代或元空间、代码缓存)
如果一个虚拟机进程里面有5组线程，那么这5组线程共享方法区和堆，有5份程序计数器，虚拟机栈，本地方法栈
下图的元数据区对应JDK8以后，在JDK8之前元数据区对应的是老年代
优化的重点是堆空间，也包括方法区，95%的垃圾回收集中在堆区，5%集中在方法区，方法区在jdk8以后换成了元空间，使用的是本地内存（内存溢出的频率比较低）
一个JVM实例对应一个Runtime实例，Runtime的对象相当于运行时数据区
JVM中的线程说明
线程是一个程序里的运行单元。JVM允许一个应用有多个线程并行的执行。
在Hotspot JVM里，每个线程都与操作系统的本地线程直接映射。当一个Java线程准备好执行以后，此时一个操作系统的本地线程也同时创建。Java线程执行终止后，本地线程也会回收。
操作系统负责所有线程的安排调度到任何一个可用的CPU上。一旦本地线程初始化成功，它就会调用Java线程中的run ()方法。
程序计数器（PC寄存器）
JVM中的PC寄存器是对物理PC寄存器的一种抽象模拟
PC寄存器用来存储指向下一条指令的地址,也即将要执行的指令代码。由执行引擎读取下一条指令。
它是一块很小的内存空间，几乎可以忽略不记。也是运行速度最快的存储区域。
在JVM规范中，每个线程都有它自己的程序计数器，是线程私有的，生命周期与线程的生命周期保持一致。
任何时间一个线程都只有一个方法在执行，也就是所谓的当前方法。程序计数器会存储当前线程正在执行的Java方法的JVM指令地址;或者，如果是在执行native方法，则是未指定值（undefned) 。
它是程序控制流的指示器，分支、循环、跳转、异常处理、线程恢复等基础功能都需要依赖这个计数器来完成。
字节码解释器工作时就是通过改变这个计数器的值来选取下一条需要执行的字节码指令。
它是唯一一个在Java虚拟机规范中没有规定任何OutOtMemoryError情况的区域。
栈和PC寄存器没有垃圾回收，堆和方法区有垃圾回收。栈、堆、方法区都有可能溢出，PC寄存器不会发生OOM
PC寄存器可以看做是游标或者集合的迭代器
一个栈帧对应一个方法，PC寄存器相当于行号标识，记录了下一条指令的地址，执行引擎根据地址取下一条指令，执行完之后再去PC寄存器取下一条指令的地址执行
PC寄存器使用举例
/**
* Created by 此生辽阔 on 2021/4/29 16:25
*/
public class registerTest {
public static void main(String[] args) {
int i=10;
int j=20;
int k=i+j;
String s="abc";
System.out.println(i);
System.out.println(k);
}
}
public static void main(java.lang.String[]);
descriptor: ([Ljava/lang/String;)V
flags: ACC_PUBLIC, ACC_STATIC
Code:
stack=2, locals=5, args_size=1
0: bipush 10
2: istore_1
3: bipush 20
5: istore_2
6: iload_1
7: iload_2
8: iadd
9: istore_3
10: ldc #2 // String abc
12: astore 4
14: getstatic #3 // Field java/lang/System.out:Ljava/io/PrintStream;
17: iload_1
18: invokevirtual #4 // Method java/io/PrintStream.println:(I)V
21: getstatic #3 // Field java/lang/System.out:Ljava/io/PrintStream;
24: iload_3
25: invokevirtual #4 // Method java/io/PrintStream.println:(I)V
28: return
PC寄存器用来存储指向下一条指令的地址,也即将要执行的指令代码。由执行引擎读取下一条指令。
两个常见的问题
使用PC寄存器存储字节码指令地址有什么用呢?为什么使用PC寄存器记录当前线程的执行地址呢?
因为CPU需要不停的切换各个线程，这时候切换回来以后，就得知道接着从哪开始继续执行。
JVM的字节码解释器就需要通过改变PC寄存器的值来明确下一条应该执行什么样的字节码指令。
PC寄存器为什么线程私有？
我们都知道所谓的多线程在一个特定的时间段内只会执行其中某一个线程的方法，CPU会不停地做任务切换，这样必然导致经常中断或恢复，如何保证分毫无差呢?为了能够准确地记录各个线程正在执行的当前字节码指令地址，最好的办法自然是为每一个线程都分配一个PC寄存器，这样一来各个线程之间便可以进行独立计算，从而不会出现相互干扰的情况。
由于CPU时间片轮限制，众多线程在并发执行过程中，任何一个确定的时刻，一个处理器或者多核处理器中的一个内核，只会执行某个线程中的一条指令。
这样必然导致经常中断或恢复，如何保证分毫无差呢？每个线程在创建后，都会产生自己的程序计数器和栈帧，程序计数器在各个线程之间互不影响。
CPU时间片
CPU时间片即CPU分配给各个程序的时间，每个线程被分配一个时间段，称作它的时间片。
在宏观上:我们可以同时打开多个应用程序，每个程序并行不悖，同时运行。
但在微观上:由于只有一个CPU，一次只能处理程序要求的一部分，如何处理公平，一种方法就是引入时间片，每个程序轮流执行。
串行：一个时间点只有一个线程执行
并行：一个时间点有多个线程执行
并发：一个核快速切换几个线程，依次执行，看着像是并行，其实是并发
虚拟机栈
虚拟机栈的主要特点
由于跨平台性的设计，Java的指令都是根据栈来设计的。不同平台CPU架构不同，所以不能设计为基于寄存器的。
优点是跨平台，指令集小，编译器容易实现，缺点是性能下降，实现同样的功能需要更多的指令。
栈是运行时的单位，而堆是存储的单位。
即:栈解决程序的运行问题，即程序如何执行，或者说如何处理数据。堆解决的是数据存储的问题，即数据怎么放、放在哪。
主体的数据都在堆中放，对象放在堆中，方法内的基本类型的局部变量放在栈中，如果是引用类型的局部变量的话，栈只是放对象的引用，真正的对象要放在堆中
栈中的食材可以理解成变量，变量通过相应的字节码指令操作，即局部变量表和操作数栈，堆空间真正存储这些食材（数据）
JAVA虚拟机栈是什么？
Java虚拟机栈(Java virtual Machine stack)，早期也叫Java伐。每个线程在创建时都会创建一个虚拟机栈，其内部保存一个个的栈帧(stack Frame），对应着一次次的Java方法调用。是线程私有的
生命周期和线程一致。
作用:主管Java程序的运行，它保存方法的局部变量、部分结果，并参与方法的调用和返回。
栈是一种快速有效的分配存储方式，访问速度仅次于程序计数器。程序计数器只存储指令的地址，所以速度快
JVM直接对Java栈的操作只有两个:
①每个方法执行，伴随着进栈(入栈、压栈)执行结束后的出栈工作
②对于栈来说不存在垃圾回收问题
虚拟机栈的常见异常与如何设置栈的大小
Java 虚拟机规范允许Java栈的大小是动态的或者是固定不变的。
如果采用固定大小的Java虚拟机栈，那每一个线程的Java虚拟机栈容量可以在线程创建的时候独立选定。如果线程请求分配的栈容量超过Java虚拟机栈允许的最大容量，Java虚拟机将会抛出一个StackOverflowError异常。
如果Java虚拟机栈可以动态扩展，并且在尝试扩展的时候无法申请到足够的内存，或者在创建新的线程时没有足够的内存去创建对应的虚拟机栈，那Java虚拟机将会抛出一个OutOfMemoryError异常。
如下args是局部变量，不断调用main函数会导致局部变量表越来越多，比如快速排序和斐波拉契数列，如果递归无法结束也会导致stackoverflow
/**
* Created by 此生辽阔 on 2021/4/29 19:17
*/
public class StackErrorTest {
public static void main(String[] args) {
main(args);//args是局部变量，会导致局部变量表越来越多
}
}
设置栈内存大小
我们可以使用参数-Xss选项来设置线程的最大栈空间，栈的大小直接决定了函数调用的最大可达深度。
https://docs.oracle.com/en/java/javase/11/tools/java.html#GUID-3B1CE181-CD30-4178-9602-230B800D4FAE
修改栈的大小
栈的存储结构和运行原理
栈中存储什么？
每个线程都有自己的栈，栈中的数据都是以栈帧(Stack Frame)的格式存在。在这个线程上正在执行的每个方法都各自对应一个栈帧(stack Frame) 。栈帧是一个内存区块，是一个数据集，维系着方法执行过程中的各种数据信息。
JVM直接对Java栈的操作只有两个，就是对栈帧的压栈和出栈，遵循“先进后出”/“后进先出”原则。在一条活动线程中，一个时间点上，只会有一个活动的栈帧。即只有当前正在执行的方法的栈帧（栈顶栈帧）是有效的，这个栈帧被称为当前栈帧(current Frame)，与当前栈帧相对应的方法就是当前方法（currentMethod)，定义这个方法的类就是当前类(current class）。
执行引擎运行的所有字节码指令只针对当前栈帧进行操作。
如果在该方法中调用了其他方法，对应的新的栈帧会被创建出来，放在栈的顶端，成为新的当前帧。
不同线程中所包含的栈帧是不允许存在相互引用的，即不可能在一个栈帧之中引用另外一个线程的栈帧。（因为线程之间，栈是隔离的）
如果当前方法调用了其他方法，方法返回之际，当前栈帧会传回此方法的执行结果给前一个栈帧，接着，虚拟机会丢弃当前栈帧，使得前一个栈帧重新成为当前栈帧。
Java方法有两种返回函数的方式，一种是正常的函数返回，使用return指令;另外一种是抛出异常。不管使用哪种方式，都会导致栈帧被弹出。
方法1调用了方法2，如果方法2出现了异常但是没有捕获，就会把它抛给方法1处理，如果方法1的调用方法2的程序做了异常捕获，则程序可以正常执行完
栈帧的内部结构
每个栈帧中存储着:
局部变量表(Local variables)
操作数栈（operand stack）(或表达式栈）
动态链接(Dynamic Linking)(或指向运行时常量池的方法引用
方法返回地址（Return Address)(或方法正常退出或者异常退出的定义)
一些附加信息
局部变量表
局部变量表（一维的）也被称之为局部变量数组或本地变量表
定义为一个数字数组，主要用于存储方法参数和定义在方法体内的局部变量,这些数据类型包括各类基本数据类型(8种)、对象引用(reference)，以及returnAddress类型（返回值类型）。
由于局部变量表是建立在线程的栈上，是线程的私有数据，因此不存在数据安全问题（多个线程操作共享数据才会有线程安全问题）
局部变量表所需的容量大小是在编译期确定下来的，并保存在方法的Code属性的maximum local variables数据项中。在方法运行期间是不会改变局部变量表的大小的。
方法嵌套调用的次数由栈的大小决定。一般来说，栈越大，方法嵌套调用次数越多（栈越大，可以容纳越多的栈帧）。对一个函数而言，它的参数和局部变量越多，使得局部变量表膨胀,它的栈帧就越大（栈帧的大小主要由局部变量表决定），以满足方法调用所需传递的信息增大的需求。进而函数调用就会占用更多的栈空间，导致其嵌套调用次数就会减少。
局部变量表中的变量只在当前方法调用中有效。在方法执行时，虚拟机通过使用局部变量表完成参数值到参数变量列表的传递过程 。当方法调用结束后,随着方法栈帧的销毁，局部变量表也会随之销毁。
字节码中方法内部结构的剖析
https://www.bilibili.com/video/BV1PJ411n7xZ?p=49&spm_id_from=pageDriver
package jvm;
/**
* Created by 此生辽阔 on 2021/4/29 21:05
*/
import java.util.Date;
public class LocalVariablesTest {
private int count = 0;
public static void main(String[] args) {
LocalVariablesTest test = new LocalVariablesTest();
int num = 10;
test.test1();
}
//练习：
public static void testStatic(){
LocalVariablesTest test = new LocalVariablesTest();
Date date = new Date();
int count = 10;
System.out.println(count);
//因为this变量不存在于当前方法的局部变量表中！！
// System.out.println(this.count);
}
//关于Slot的使用的理解
public LocalVariablesTest(){
this.count = 1;
}
public void test1() {
Date date = new Date();
String name1 = "atguigu.com";
test2(date, name1);
System.out.println(date + name1);
}
public String test2(Date dateP, String name2) {
dateP = null;
name2 = "songhongkang";
double weight = 130.5;//占据两个slot
char gender = '男';
return dateP + name2;
}
public void test3() {
this.count++;
}
public void test4() {
int a = 0;
{
int b = 0;
b = a + 1;
}
//变量c使用之前已经销毁的变量b占据的slot的位置
int c = a + 1;
}
/*
变量的分类：按照数据类型分：① 基本数据类型 ② 引用数据类型
按照在类中声明的位置分：① 成员变量：在使用前，都经历过默认初始化赋值
类变量： linking的prepare阶段：给类变量默认赋值 ---> initial阶段：给类变量显式赋值即静态代码块赋值
实例变量：随着对象的创建，会在堆空间中分配实例变量空间，并进行默认赋值
② 局部变量：在使用前，必须要进行显式赋值的！否则，编译不通过
*/
public void test5Temp(){
int num;
//System.out.println(num);//错误信息：变量num未进行初始化
}
}
可以看到main方法中有3个变量，args test num,按照声明的位置占据索引，分别是0,1，2，描述符中记录了变量的类型
起始PC:字节码指令的行号（可以去上图查找java代码对应的行号）
长度：和起始PC一起描述当前变量的作用范围
可以看到 0+16=8+8+11+5=16，这是因为main方法字节码的总长度是16,（前面已经给出 ） ，那么局部变量作用的范围就是开始作用的地方到main方法结束的地方，比如test,在字节码行号为8的地方开始作用，作用域为8行字节码，因为第16行字节码，main方法执行结束，局部变量也就失效了
变量槽slot的理解与演示
参数值的存放总是在局部变量数组的index0开始，到数组长度-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处，其余的参数按照参数表顺序继续排列。（静态方法就没有this）构造器中的this代表当前正在创建的对象，静态方法不能调用this,因为this不存在静态方法的局部变量表中
double占据两个槽，引用类型占据一个槽
栈帧中的局部变量表中的槽位是可以重用的，如果一个局部变量过了其作用域，那么在其作用域之后申明的新的局部变量就很有可能会复用过期局部变量的槽位，从而达到节省资源的目的
public void test4() {
int a = 0;
{
int b = 0;
b = a + 1;
}
//变量c使用之前已经销毁的变量b占据的slot的位置
int c = a + 1;
}
我们看这个方法
最大槽是3，但是this a,b,c 4个局部变量不应该是4个槽吗，原因就是有槽被重复利用了，b出了代码块就结束作用域了
静态变量与局部变量的对比
参数表分配完毕之后，再根据方法体内定义的变量的顺序和作用域分配。
我们知道类变量表有两次初始化的机会，第一次是在“准备阶段”，执行系统初始化，对类变量设置零值，另一次则是在“初始化”阶段，赋予程序员在代码中定义的初始值。
和类变量初始化不同的是，局部变量表不存在系统初始化的过程，这意味着一旦定义了局部变量则必须人为的初始化，否则无法使用。
/*
变量的分类：按照数据类型分：① 基本数据类型 ② 引用数据类型
按照在类中声明的位置分：① 成员变量：在使用前，都经历过默认初始化赋值
类变量： linking的prepare阶段：给类变量默认赋值 ---> initial阶段：给类变量显式赋值即静态代码块赋值
实例变量：随着对象的创建，会在堆空间中分配实例变量空间，并进行默认赋值
② 局部变量：在使用前，必须要进行显式赋值的！否则，编译不通过
*/
public void test5Temp(){
int num;
//System.out.println(num);//错误信息：变量num未进行初始化
}
}
在栈帧中，与性能调优关系最为密切的部分就是前面提到的局部变量表。在方法执行时，虚拟机使用局部变量表完成方法的传递。
局部变量表中的变量也是重要的垃圾回收根节点，只要被局部变量表中直接或间接引用的对象都不会被回收。
下面代码，静态变量a没有赋值初值，但是也能调用，因为在类加载的准备阶段会赋值默认值0
public class TestAdd {
static int a;
public static void main(String[] args) {
System.out.println(a);
}
}
操作数栈
栈可以使用数组或链表来实现，栈可以看成满足特殊条件的数组或者链表
每一个独立的栈帧中除了包含局部变量表以外，还包含一个后进先出(Last-In-First-out）的操作数栈，也可以称之为表达式栈(Expression stack) 。
操作数栈，在方法执行过程中，根据字节码指令，往栈中写入数据或提取数据，即入栈(push)/出栈(pop)
某些字节码指令将值压入操作数栈，其余的字节码指令将操作数取出栈。使用它们后再把结果压入栈。比如:执行复制、交换、求和等操作
如果被调用的方法带有返回值的话，其返回值将会被压入当前栈帧的操作数栈中，并更新Pc寄存器中下一条需要执行的字节码指令。
操作数栈中元素的数据类型必须与字节码指令的序列严格匹配，这由编译器在编译器期间进行验证，同时在类加载过程中的类检验阶段的数据流分析阶段要再次验证。
另外，我们说Java虚拟机的解释引擎是基于栈的执行引擎，其中的栈指的就是操作数栈。
操作数栈，主要用于保存计算过程的中间结果，同时作为计算过程中变量临时的存储空间。
操作数栈就是JVM执行引擎的一个工作区，当一个方法刚开始执行的时候，一个新的栈帧也会随之被创建出来，这个方法的操作数栈是空的。
每一个操作数栈都会拥有一个明确的栈深度用于存储数值，其所需的最大深度在编译期就定义好了，保存在方法的code属性中，为max_stack的值。
栈中的任何一个元素都是可以任意的Java数据类型。
32bit的类型占用一个栈单位深度
64bit的类型占用两个栈单位深度
操作数栈并非采用访问索引的方式来进行数据访问的，而是只能通过标准的入栈(push）和出栈（pop）操作来完成一次数据访问。
涉及操作数栈的字节码指令执行分析
/**
* Created by 此生辽阔 on 2021/4/30 11:21
*/
public class OperateStackTest {
public void testAddOperation() {
//byte、short、char、boolean：在JVM中都以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
注意 byte i = 15; bipush 15 int j = 8; bipush 8 int c=127; bipush 127//因为还没有超过byte的范围，用bipush int d=128; sipush 128//超过了byte的范围，但是没有超过short的范围，用sipush int m = 800; 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;
}
public static void add(){
//第1类问题：
int i1 = 10;
i1++;
System.out.println("i1="+i1);
int i2 = 10;
++i2;
System.out.println("i2="+i2);
//第2类问题：
int i3 = 10;
int i4 = i3++;
System.out.println("i4="+i4);
int i5 = 10;
int i6 = ++i5;
System.out.println("i6="+i6);
//第3类问题：
int i7 = 10;
i7 = i7++;
System.out.println("i7="+i7);
int i8 = 10;
i8 = ++i8;
System.out.println("i8="+i8);
//第4类问题：
int i9 = 10;
int i10 = i9++ + ++i9;
System.out.println("i9="+i9);
System.out.println("i10="+i10);
}
i1=11 i2=11 i4=10 i6=11 i7=10 i8=11 i9=12 i10=22
分析一下
int i9 = 10; int i10 = i9++ + ++i9;
字节码
53 bipush 10 //压入10 55 istore 8 //先把10给i9，对应内存中8这个位置 57 iload 8 //把内存8对应的值取出来 现在是10 59 iinc 8 by 1 //加1 62 iinc 8 by 1 //加1 65 iload 8 //再次加载内存位置8的值，现在是12 67 iadd //相加 第一次加载的是10第二次加载的是12 68 istore 9 //得到的值存入第9个位置 70 return
栈顶缓存技术
前面提过，基于栈式架构的虚拟机所使用的零地址指令更加紧凑，但完成一项操作的时候必然需要使用更多的入栈和出栈指令，这同时也就意味着将需要更多的指令分派（instruction dispatch）次数和内存读/写次数。
由于操作数是存储在内存中的，因此频繁地执行内存读/写操作必然会影响执行速度。为了解决这个问题，Hotspot JVM的设计者们提出了栈顶缓存（Tos，Top-of-stack Cashing）技术，将栈顶元素全部缓存在物理cPu的寄存器中，以此降低对内存的读/写次数，提升执行引擎的执行效率。
动态链接（指向运行时常量池中的方法引用）
有些地方把动态链接 方法返回地址 附加信息叫做帧数据区
每一个栈帧内部都包含一个指向运行时常量池中该栈帧所属方法的引用,包含这个引用的目的就是为了支持当前方法的代码能够实现动态链接( Dynamic Linking）。比如: invokedynamic指令(栈帧中的动态链接保存了常量池中指向该栈帧所属方法的引用的地址)
在Java源文件被编译到字节码文件中时，所有的变量和方法引用都作为符号引用(symbolic Reference）保存在class文件的常量池里。比如:描述一个方法调用了另外的其他方法时，就是通过常量池中指向方法的符号引用来表示的，那么动态链接的作用就是为了将这些符号引用转换为调用方法的直接引用。
package jvm;
/**
* Created by 此生辽阔 on 2021/4/30 14:49
*/
public class DynamicLinkingTest {
int num = 10;
public void methodA(){
System.out.println("methodA()....");
}
public void methodB(){
System.out.println("methodB()....");
methodA();
num++;
}
}
没有主函数时，我们可以按照下图操作完成编译
然后我们在Terminal输入指令
javap -v DynamicLinkingTest.class
常量池
再理解一下这句话
在Java源文件被编译到字节码文件中时，所有的变量和方法引用都作为符号引用(symbolic Reference）保存在class文件的常量池里
字节码文件里面的常量池在运行起来之后就放在方法区了，又叫运行时常量池
为什么要把方法放在方法区，通过动态链接来引用，而不是直接把方法放在栈帧？
因为方法区是线程共享的，其他地方或者其他线程需要用到这个方法就直接引用方法区里面的方法就行了
多态的原理在这有所体现，编写的时候认为是父类，真正运行起来却是子类，通过动态链接把方法的执行转化为对子类的调用
为什么需要常量池？
字节码文件里面需要很多数据的支持，数据很大，不能直接保存在字节码中，就通过符号引用去引用相关的结构
常量池的作用：提供一些符号和常量，便于指令识别，同时使文件比较小，调用起来直接指针指向比较方便
方法的绑定机制：动态绑定与静态绑定
在JVM中，将符号引用转换为调用方法的直接引用与方法的绑定机制相关。
- 静态链接
当一个字节码文件被装载进JVM内部时，如果被调用的目标方法在编译期可知，且运行期保持不变时。这种情况下将调用方法的符号引用转换为直接引用的过程称之为静态链接。
- 动态链接
如果被调用的方法在编译期无法被确定下来，也就是说，只能够在程序运行期将调用方法的符号引用转换为直接引用，由于这种引用转换过程具备动态性，因此也就被称之为动态链接。
对应的方法的绑定机制为:早期绑定(Early Binding）和晚期绑定(Late Binding）。绑定是一个字段、方法或者类在符号引用被替换为直接引用的过程，这仅仅发生一次。
- 早期绑定(对应静态链接)
早期绑定就是指被调用的目标方法如果在编译期可知，且运行期保持不变时即可将这个方法与所属的类型进行绑定，这样一来，由于明确了被调用的目标方法究竟是哪一个，因此也就可以使用静态链接的方式将符号引用转换为直接引用。
- 晚期绑定(对应动态链接)
如果被调用的方法在编译期无法被确定下来，只能够在程序运行期根据实际的类型绑定相关的方法，这种绑定方式也就被称之为晚期绑定。
随着高级语言的横空出世,类似于Java一样的基于面向对象的编程语言如今越来越多，尽管这类编程语言在语法风格上存在一定的差别，但是它们彼此之间始终保持着一个共性，那就是都支持封装、继承和多态等面向对象特性，既然这一类的编程语言具备多态特性，那么自然也就具备早期绑定和晚期绑定两种绑定方式。
Java中任何一个普通的方法其实都具备虚函数的特征，它们相当于c++语言中的虚函数（C++中则需要使用关键字virtual来显式定义）。如果在Java程序中不希望某个方法拥有虚函数的特征时，则可以使用关键字final来标记这个方法。（final修饰的方法不能被重写，也就是说在编译期就确定了）
虚方法和非虚方法
如果方法在编译期就确定了具体的调用版木，这个版本在运行时是不可变的这样的方法称为非虚方法.静态方法、私有方法、final方法、实例构造器、父类方法都是非虚方法。
其他方法称为虚方法。
虚方法就是我们不能确定调用的是父类的方法还是子类的方法
多态的使用前提：类的继承关系、方法的重写、
package com.atguigu.java2;
/**
* 解析调用中非虚方法、虚方法的测试
*
* invokestatic指令和invokespecial指令调用的方法称为非虚方法
* @author shkstart
* @create 2020 下午 12:07
*/
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
super.showStatic("good!");
//invokespecial
showPrivate("hello!");
//invokespecial
super.showCommon();
//invokevirtual
showFinal();//因为此方法声明有final，不能被子类重写，所以也认为此方法是非虚方法。
//虚方法如下：
//invokevirtual
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();
}
father的构造器 son atguigu.com father good! son privatehello! father 普通方法 father show final father 普通方法
如果你的类文件有多个类，编译后可以点到相应的类再按如下操作
InvokeDynamic指令使用
动态解析出需要调用的方法
JVM字节码指令集一直比较稳定，一直到Java7中才增加了一个invokedynamic指令，这是Java为了实现『动态类型语言』支持而做的一种改进。
但是在Java7中并没有提供直接生成invokedynamic指令的方法，需要借助A.SM这种底层字节码工具来产生invokedynamic指令。直到Java8的Lambda表达式的出现， invokedynamic指令的生成，在Java中才有了直接的生成方式。
Java7中增加的动态语言类型支持的本质是对Java虚拟机规范的修改，而不是对Java语言规则的修改，这一块相对来讲比较复杂，增加了虚拟机中的方法调用，最直接的受益者就是运行在Java平台的动态语言的编译器。（比如在JAVA虚拟机运行Python,JS）
动态类型语言和静态类型语言
动态类型语言和静态类型语言两者的区别就在于对类型的检查是在编译期还是在运行期，满足前者就是静态类型语言，反之是动态类型语言。
说的再直白一点就是，静态类型语言是判断变量自身的类型信息;动态类型语言是判断变量值的类型信息，变量没有类型信息，变量值才有类型信息，这是动态语言的一个重要特征。
所以Java是静态类型的语言
比如定义 String name=“111”,如果String name=111就会报错
python中 info=130.5只有运行起来才知道是什么类型的，所以是动态类型的语言
package jvm;
/**
* Created by 此生辽阔 on 2021/4/30 16:19
*/
@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介绍:
程序试图访问或修改一个属性或调用一个方法，这个属性或方法，你没有权限访问。一般的，这个会引起编译器异常。这个错误如果发生在运行时，就说明一个类发生了不兼容的改变。
在面向对象的编程中，会很频繁的使用到动态分派，如果在每次动态分派的过程中都要重新在类的方法元数据中搜索合适的目标的话就可能影响到执行效率。因此，为了提高性能，JVM采用在类的方法区建立一个虚方法表(virtual method table）(非虚方法不会出现在表中)来实现。使用索引表来代替查找。
每个类中都有一个虚方法表，表中存放着各个方法的实际入口。
那么虚方法表什么时候被创建?
虚方法表会在类加载的链接阶段被创建并开始初始化，类的变量初始值准备完成之后，JVM会把该类的方法表也初始化完毕。
package com.atguigu.java3;
/**
* 虚方法表的举例
*
* @author shkstart
* @create 2020 下午 1:11
*/
interface Friendly {
void sayHello();
void sayGoodbye();
}
class Dog {
public void sayHello() {
}
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() {
}
}
public class VirtualMethodTable {
}
方法返回地址
存放调用该方法的pc寄存器的值。
一个方法的结束，有两种方式:
正常执行完成
出现未处理的异常，非正常退出
无论通过哪种方式退出，在方法退出后都返回到该方法被调用的位置。方法正常退出时，调用者的pc计数器的值作为返回地址，即调用该方法的指令的下一条指令的地址。而通过异常退出的，返回地址是要通过异常表来确定，栈帧中一般不会保存这部分信息。
当一个方法开始执行后，只有两种方式可以退出这个方法:
1、执行引擎遇到任意一个方法返回的字节码指令(return)，会有返回值传递给上层的方法调用者，简称正常完成出口;
一个方法在正常调用完成之后究竟需要使用哪一个返回指令还需要根据方法返回值的实际数据类型而定。
在字节码指令中，返回指令包含ireturn (当返回值是boolean、byte、char.
short和int类时使用）、lreturn（long）、 freturn(float)、dreturn(double)以及areturn（引用类型），另外还有一个return指令供声明为void的方法(直接return )、实例初始化方法、类和接口的初始化方法使用。
2、在方法执行的过程中遇到了异常（Exception)，并且这个异常没有在方法内进行处理，也就是只要在本方法的异常表中没有搜索到匹配的异常处理器，就会导致方法退出。简称异常完成出口。
方法执行过程中抛出异常时的异常处理，存储在一个异常处理表，方便在发生异常的时候找到处理异常的代码。
本质上，方法的退出就是当前栈帧出栈的过程。此时，需要恢复上层方法的局部变量表、操作数栈、将返回值压入调用者栈帧的操作数栈、设置PC寄存器值等，让调用者方法继续执行下去。
正常完成出口和异常完成出口的区别在于:通过异常完成出口退出的不会给他的上层调用者产生任何的返回值。
栈帧中的一些附加信息
栈帧中还允许携带与Java虚拟机实现相关的一些附加信息。例如，对程序调试提供支持的信息。
栈的相关面试题
举例栈溢出的情况?
调整栈大小，就能保证不出现溢出吗?
分配的栈内存越大越好吗?
垃圾回收是否会涉及到虚拟机栈?
方法中定义的局部变量是否线程安全?
举例栈溢出的情况?
StackOverFlow
解决：通过-Xss设置栈的大小
调整栈大小，就能保证不出现溢出吗?
答：不能保证（更大只能保证原来能执行5000次，现在可以执行6000次酱紫才出现StackOverFlow）
| ERROR | GC | |
|---|---|---|
| PC寄存器 | 无 | 无 |
| 虚拟机栈 | StackOverFlowError | 无，只有进栈出栈 |
| 本地方法栈 | StackOverFlowError | 无 |
| 堆 | OOM | OOM之前有GC |
| 方法区 | 数据放的时间比较长，比如类数据本身，生命周期与虚拟机的生命周期一样，导入的jar包过多会导致溢出 | 溢出之前，FULLGC |
分配的栈内存越大越好吗?
栈越大，一定时间内发生栈溢出的概率较小，避免StackOverFlow出现过早，但是无法避免StackOverFlow出现，栈越大，可以容纳的线程数就少了，因为内存空间是有限的
垃圾回收是否会涉及到虚拟机栈?
不会
方法中定义的局部变量是否线程安全?
具体问题，具体分析
何为线程安全：如果有一个线程才可以操作此数据，则必是线程安全的
如果多个线程操作此数据，则此数据为共享数据，如果不考虑同步机制的话，会存在线程安全问题
package com.atguigu.java3;
/**
* 面试题：
* 方法中定义的局部变量是否线程安全？具体情况具体分析
*
* 何为线程安全？
* 如果只有一个线程才可以操作此数据，则必是线程安全的。
* 如果有多个线程操作此数据，则此数据是共享数据。如果不考虑同步机制的话，会存在线程安全问题。
* @author shkstart
* @create 2020 下午 7:48
*/
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的操作：是线程不安全的，因为s1返回出去可能被其他线程使用
public static StringBuilder method3(){
StringBuilder s1 = new StringBuilder();
s1.append("a");
s1.append("b");
return s1;
}
//s1的操作：是线程安全的，因为s1在方法内已经死了，返回出去的是另一个对象
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);
}
}
本地方法接口
本地方法接口就是下图的红框部分
什么是本地方法?
简单地讲，一个Native Method就是一个Java调用非Java代码的接口。一个Native Method是这样一个Java方法:该方法的实现由非Java语言实现，比如c。这个特征并非Java所特有，很多其它的编程语言都有这一机制，比如在c++中，你可以用extern "c"告知C++编译器去调用一个c的函数。
“A native method is a Java method whose implementation is provided by non-java code .”
在定义一个native method时，并不提供实现体（有些像定义一个Javainterface) ，因为其实现体是由非java语言在外面实现的。
本地接口的作用是融合不同的编程语言为Java所用，它的初衷是融合c/C++程序。
Java层面的线程实际上都要转换成操作系统的本地线程，所以需要调用底层的C代码，所以有很多native方法
标识符native可以与所有其它的java标识符连用，但是abstract除外，因为native方法是有方法体的（可调用，不过调用的是本地的C方法），而abstract修饰的方法没有方法体。
为什么要使用Native Method ?
Java使用起来非常方便，然而有些层次的任务用Java实现起来不容易，或者我们对程序的效率很在意时，问题就来了。
与Java环境外交互:
有时Java应用需要与Java外面的环境交互，这是本地方法存在的主要原因。你可以想想Java需要与一些底层系统，如操作系统或某些硬件交换信息时的情况。本地方法正是这样一种交流机制:它为我们提供了一个非常简洁的接口，而且我们无需去了解Java应用之外的繁琐的细节。
与操作系统交互:
JVM支持着Java语言本身和运行时库，它是Java程序赖以生存的平台，它由一个解释器(解释字节码)和一些连接到本地代码的库组成。然而不管怎样，它毕竟不是一个完整的系统，它经常依赖于一些底层系统的支持。这些底层系统常常是强大的操作系统。通过使用本地方法，我们得以用Java实现了jre的与底层系统的交互，甚至JVM的一些部分就是用c写的。还有，如果我们要使用一些Java语言本身没有提供封装的操作系统的特性时，我们也需要使用本地方法。
Sun’ s Java
Sun的解释器是用C实现的，这使得它能像一些普通的C一 样与外部交互。jre大部分是.
用Java实现的，它也通过一些本地方法与外界交互。例如:类java. lang. Thread
的:setPriority()方法是用Java实现的，但是它实现调用的是该类里的本地方法setPriority0()。 这个本地方法是用c实现的，并被植入JVM内部，在Windows 95的平台上，这个本地方法最终将调用win32 SetPriority() API。这是一个本地方法的具体实现由JVM直接提供，更多的情况是本地方法由外部的动态链接库(external dynamic link library) 提供，然后被JVM调用。.
目前该方法使用的越来越少了，除非是与硬件有关的应用，比如通过Java程序驱动打印机或者Java系统管理生产设备，在企业级应用中已经比较少见。因为现在的异构领域间的通信很发达，比如可以使用Socket通信，也可以使用web Service等等， 不多做介绍。
本地方法栈
Java虛拟机栈用于管理Java方法的调用，而本地方法栈用于管理本地方法的调用。
本地方法栈，也是线程私有的。
允许被实现成固定或者是可动态扩展的内存大小。(在内存溢出方面是相同的)
➢如果线程请求分配的栈容量超过本地方法栈允许的最大容量，Java虚拟机将会抛出一个stackoverflowError 异常。
➢如果本地方法栈可以动态扩展，并且在尝试扩展的时候无法申请到足够的内存，或者在创建新的线程时没有足够的内存去创建对应的本地方法栈，那么Java虚拟机将会抛出一个outofMemoryError 异常。
本地方法是使用C语言实现的。
它的具体做法是Native Method Stack中 登记native方法，在Execution Engine执行时加载本地方法库。
当某个线程调用一个本地方法时，它就进入了一个全新的并且不再受虚拟机限制的世界。它和虚拟机拥有同样的权限。
➢本地方法可以通过本地方法接口来访问虚拟机内部的运行时数据区。
➢它甚至可以直接使用本地处理器中的寄存器
➢直接从本地内存的堆中分配任意数量的内存。
并不是所有的JVM都支持本地方法。因为Java虚拟机规范并没有明确要求本地方法栈的使用语言、具体实现方式、数据结构等。如果JVM产品不打算支持native方法，也可以无需实现本地方法栈。
在Hotspot JVM中， 直接将本地方法栈和虚拟机栈合二为一 。
这篇关于运行时数据区（程序计数器、虚拟机栈、本地方法栈）的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！
- 2024-07-04TiDB 资源管控的对撞测试以及最佳实践架构
- 2024-07-03万字长文聊聊Web3的组成架构
- 2024-07-02springboot项目无法注册到nacos-icode9专业技术文章分享
- 2024-06-26结对编程到底难不难？答案在这里
- 2024-06-19《2023版Java工程师》课程升级公告
- 2024-06-15matplotlib作图不显示3D图，怎么办？
- 2024-06-1503-Loki 日志监控
- 2024-06-1504-让LLM理解知识 -Prompt
- 2024-06-05做软件测试需要懂代码吗？
- 2024-06-0514-ShardingSphere的分布式主键实现
