虚拟机栈
虚拟机栈的概述
栈是运行时的单位，而堆是存储的单位
即： 栈解决程序的运行的问题，即程序如何执行，或者说如何处理数据，
堆解决的是数据的存储的问题，即，数据怎么放，放在哪儿，（对象
是存储在堆中的，方法中的局部变量是保存到栈（栈帧）当中的。局部变量是基本数据类型，对于引用数据类型，保存的还是引用地址）
Java虚拟机栈是什么
Java虚拟机栈Java Virtual Machine Stack，早期也叫Java栈
每个线程在创建时都是创建一个虚拟机栈，其内部保存一个个的栈帧(存储数据的基本单位)，
对应着 一次次的Java方法调用（一个方法对应着一个栈帧）
是线程私有的
生命周期
生命周期和线程一致
作用
主管Java程序的运行，他保存方法的局部变量（8种基本类型 ,对象的引用地址），部分结果，并参与方法的调用和返回
局部变量 vs 成员变量（属性）
基本数据类型 vs 引用数据类型 （类、数组、接口）
栈的优点
栈是一种快速有效的分配存储方式，访问速度仅次于程序计数器。
JVM直接对Java栈的操作只有两个
每个方法执行，伴随着进栈（入栈、压栈）
执行结束后的出栈工作
对于栈来说不存在垃圾回收问题（方法执行结束就会自动出栈）
不存在CG，可能存在OOM内存溢出
栈中可能出现的异常
栈的存储单位
栈中存储什么
每个线程都有自己的栈，栈中的数据都是以栈帧（Stack Frame）的格式存在。
在这个线程上正在执行的每个方法都各自对应一个栈帧（Stack Frame）。
栈帧是一个内存区块，是一个数据集，维系着方法执行过程中的各种数据信息。
栈运行原理
JVM直接对Java栈的操作只有两个,就是对栈帧的 压栈和出栈,遵循 "先进后出"或者"后进先出"的原则 。
在一条活动的线程中，一个时间点上，只会有一个活动的栈帧，即只有当前正在执行的方法的栈帧（栈顶栈帧）是有效的，这个栈帧被称为当前栈帧，与当前栈帧相对应的方法就是当前方法，定义这个方法的类就是当前类。
执行引擎运行的所有字节码指令只针对当前栈帧进行操作
如果在该方法中调用了其他方法，对应的新的栈帧会被创建出来，放在栈的顶端，成为新的当前帧。
不同线程中所包含的栈帧是不允许存在相互引用的，即不可能在一个栈帧之中引用另外一个线程的栈帧。
如果当前方法调用了其他方法，方法返回之际。当前栈帧会传回此方法的执行结果给前一个栈帧，接着，虚拟机会丢弃当前栈帧，使得前一个栈帧重新成为当前栈帧。
Java方法有两种返回函数的方式，一种是正常的函数返回，使用return指令，另外一个是抛出异常，不管使用那种方式，都会导致栈帧被弹出。
代码演示
package com.atguigu.java.stack;
public class StackFrameTest {
public static void main(String[] args) {
StackFrameTest stackFrameTest = new StackFrameTest();
stackFrameTest.method1();
}
private void method1() {
System.out.println("method1 开始执行");
method2();
System.out.println("method1 开始执行结束");
}
private int method2() {
System.out.println("method2 开始执行");
int i =10;
int j = (int)method3();
System.out.println("method2 即将结束执行");
return i+j;
}
private double method3() {
System.out.println("method3 开始执行");
double j = 20.0;
System.out.println("method3 即将结束执行");
return j;
}
}
字节码分析
public class com.atguigu.java.stack.StackFrameTest
minor version: 0
major version: 49
flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
#1 = Methodref #17.#41 // java/lang/Object."<init>":()V
#2 = Class #42 // com/atguigu/java/stack/StackFrameTest
#3 = Methodref #2.#41 // com/atguigu/java/stack/StackFrameTest."<init>":()V
#4 = Methodref #2.#43 // com/atguigu/java/stack/StackFrameTest.method1:()V
#5 = Fieldref #44.#45 // java/lang/System.out:Ljava/io/PrintStream;
#6 = String #46 // method1 开始执行
#7 = Methodref #47.#48 // java/io/PrintStream.println:(Ljava/lang/String;)V
#8 = Methodref #2.#49 // com/atguigu/java/stack/StackFrameTest.method2:()I
#9 = String #50 // method1 开始执行结束
#10 = String #51 // method2 开始执行
#11 = Methodref #2.#52 // com/atguigu/java/stack/StackFrameTest.method3:()D
#12 = String #53 // method2 即将结束执行
#13 = String #54 // method3 开始执行
#14 = Double 20.0d
#16 = String #55 // method3 即将结束执行
#17 = Class #56 // java/lang/Object
#18 = Utf8 <init>
#19 = Utf8 ()V
#20 = Utf8 Code
#21 = Utf8 LineNumberTable
#22 = Utf8 LocalVariableTable
#23 = Utf8 this
#24 = Utf8 Lcom/atguigu/java/stack/StackFrameTest;
#25 = Utf8 main
#26 = Utf8 ([Ljava/lang/String;)V
#27 = Utf8 args
#28 = Utf8 [Ljava/lang/String;
#29 = Utf8 stackFrameTest
#30 = Utf8 method1
#31 = Utf8 method2
#32 = Utf8 ()I
#33 = Utf8 i
#34 = Utf8 I
#35 = Utf8 j
#36 = Utf8 method3
#37 = Utf8 ()D
#38 = Utf8 D
#39 = Utf8 SourceFile
#40 = Utf8 StackFrameTest.java
#41 = NameAndType #18:#19 // "<init>":()V
#42 = Utf8 com/atguigu/java/stack/StackFrameTest
#43 = NameAndType #30:#19 // method1:()V
#44 = Class #57 // java/lang/System
#45 = NameAndType #58:#59 // out:Ljava/io/PrintStream;
#46 = Utf8 method1 开始执行
#47 = Class #60 // java/io/PrintStream
#48 = NameAndType #61:#62 // println:(Ljava/lang/String;)V
#49 = NameAndType #31:#32 // method2:()I
#50 = Utf8 method1 开始执行结束
#51 = Utf8 method2 开始执行
#52 = NameAndType #36:#37 // method3:()D
#53 = Utf8 method2 即将结束执行
#54 = Utf8 method3 开始执行
#55 = Utf8 method3 即将结束执行
#56 = Utf8 java/lang/Object
#57 = Utf8 java/lang/System
#58 = Utf8 out
#59 = Utf8 Ljava/io/PrintStream;
#60 = Utf8 java/io/PrintStream
#61 = Utf8 println
#62 = Utf8 (Ljava/lang/String;)V
{
public com.atguigu.java.stack.StackFrameTest();
descriptor: ()V
flags: ACC_PUBLIC
Code:
stack=1, locals=1, args_size=1
0: aload_0
1: invokespecial #1 // Method java/lang/Object."<init>":()V
4: return
LineNumberTable:
line 3: 0
LocalVariableTable:
Start Length Slot Name Signature
0 5 0 this Lcom/atguigu/java/stack/StackFrameTest;
public static void main(java.lang.String[]);
descriptor: ([Ljava/lang/String;)V
flags: ACC_PUBLIC, ACC_STATIC
Code:
stack=2, locals=2, args_size=1
0: new #2 // class com/atguigu/java/stack/StackFrameTest
3: dup
4: invokespecial #3 // Method "<init>":()V
7: astore_1
8: aload_1
9: invokevirtual #4 // Method method1:()V
12: return
LineNumberTable:
line 5: 0
line 7: 8
line 8: 12
LocalVariableTable:
Start Length Slot Name Signature
0 13 0 args [Ljava/lang/String;
8 5 1 stackFrameTest Lcom/atguigu/java/stack/StackFrameTest;
public void method1();
descriptor: ()V
flags: ACC_PUBLIC
Code:
stack=2, locals=1, args_size=1
0: getstatic #5 // Field java/lang/System.out:Ljava/io/PrintStream;
3: ldc #6 // String method1 开始执行
5: invokevirtual #7 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
8: aload_0
9: invokevirtual #8 // Method method2:()I
12: pop
13: getstatic #5 // Field java/lang/System.out:Ljava/io/PrintStream;
16: ldc #9 // String method1 开始执行结束
18: invokevirtual #7 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
21: return
LineNumberTable:
line 11: 0
line 12: 8
line 13: 13
line 15: 21
LocalVariableTable:
Start Length Slot Name Signature
0 22 0 this Lcom/atguigu/java/stack/StackFrameTest;
public int method2();
descriptor: ()I
flags: ACC_PUBLIC
Code:
stack=2, locals=3, args_size=1
0: getstatic #5 // Field java/lang/System.out:Ljava/io/PrintStream;
3: ldc #10 // String method2 开始执行
5: invokevirtual #7 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
8: bipush 10
10: istore_1
11: aload_0
12: invokevirtual #11 // Method method3:()D
15: d2i
16: istore_2
17: getstatic #5 // Field java/lang/System.out:Ljava/io/PrintStream;
20: ldc #12 // String method2 即将结束执行
22: invokevirtual #7 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
25: iload_1
26: iload_2
27: iadd
28: ireturn i代表返回int
LineNumberTable:
line 18: 0
line 19: 8
line 20: 11
line 21: 17
line 22: 25
LocalVariableTable: /** 局部变量表，每个方法都有一个，因为局部变量表存在于栈中 */
Start Length Slot Name Signature
0 29 0 this Lcom/atguigu/java/stack/StackFrameTest;
11 18 1 i I
17 12 2 j I
public double method3();
descriptor: ()D
flags: ACC_PUBLIC
Code:
stack=2, locals=3, args_size=1
0: getstatic #5 // Field java/lang/System.out:Ljava/io/PrintStream;
3: ldc #13 // String method3 开始执行
5: invokevirtual #7 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
8: ldc2_w #14 // double 20.0d
11: dstore_1
12: getstatic #5 // Field java/lang/System.out:Ljava/io/PrintStream;
15: ldc #16 // String method3 即将结束执行
17: invokevirtual #7 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
20: dload_1
21: dreturn d代表返回double
LineNumberTable:
line 26: 0
line 28: 8
line 29: 12
line 30: 20
LocalVariableTable:
Start Length Slot Name Signature
0 22 0 this Lcom/atguigu/java/stack/StackFrameTest;
12 10 1 j D
}
SourceFile: "StackFrameTest.java"
私有方法通过反编译是看不到的
栈帧的内部结构
局部变量表 （Local Variables)
操作数栈 (Operand SStack )(或者表达式栈)
动态连接 （指向运行时常量池的方法引用）
方法返回地址 （方法正常退出或者异常退出的定义）
一些附加信息
局部变量表
局部变量表也被称之为局部变量数组或本地变量表
定义为一个数字数组，主要用于存储方法参数和定义在方法体内的局部变量，这些数据类型包括各类基本数据类型、对象引用(reference） ，以及 returnAddress类型。
由于局部变量表是建立在线程的栈上，是线程的私有数据，因此不存在数据安全问题
局部变量表所需的容量大小是在编译期确定下来的，并保存在方法的code属性的maximum local variables数据项中。在方法运行期间是不会改变局部变量表的大小的。
代码演示
package com.atguigu.java.stack;
public class LocalVariableTest {
public static void main(String[] args) {
LocalVariableTest localVariaTbaleTest = new LocalVariableTest();
int a=10;
int b=10;
int c=10;
}
public void method1(){
double c =10.0;
System.out.println(c);
}
public void method2(){
}
}
分析字节码 main方法 验证 局部变量表所需的容量大小是在编译期确定下来的
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 # locals=5 代表局部变量表长度是 5
0: new #2 // class com/atguigu/java/stack/LocalVariableTest
3: dup
4: invokespecial #3 // Method " < init > " : ()V
7: astore_1
8: bipush 10
10: istore_2
11: bipush 10
13: istore_3
14: bipush 10
16: istore 4
18: return
LineNumberTable:
line 5: 0
line 6: 8
line 7: 11
line 8: 14
line 9: 18
LocalVariableTable: # 局部变量表
Start Length Slot Name Signature
0 19 0 args [Ljava/lang/String; # [ 代表是个数值 L 第一个字母L 代表引用类型
8 11 1 localVariaTbaleTest Lcom/atguigu/java/stack/LocalVariableTest;
11 8 2 a I # I 代表int
14 5 3 b I
18 1 4 c I
分析字节码 method1方法 验证局部变量表所需的容量大小是在编译期确定下来的
public void method1();
descriptor: ()V
flags: ACC_PUBLIC
Code:
stack=3, **locals=3**, args_size=1 # locals=3, 长度是3
0: ldc2_w #4 // double 10.0d
3: dstore_1
4: getstatic #6 // Field java/lang/System.out:Ljava/io/PrintStream;
7: dload_1
8: invokevirtual #7 // Method java/io/PrintStream.println:(D)V
11: return
LineNumberTable:
line 12: 0
line 13: 4
line 14: 11
LocalVariableTable:
Start Length Slot Name Signature
0 12 0 this Lcom/atguigu/java/stack/LocalVariableTest;
4 8 1 c D # D 代表Double
使用字节码插件进行查看
局部变量表所需的容量大小是在编译期确定下来的**，并保存在方法的code属性的maximum local variables数据项中 这句话就对应着下图所示：
😦 方法嵌套调用的次数由栈的大小决定。一般来说，栈越大，方法嵌套调用次数越多。对一个函数而言，它的参数和局部变量越多，使得局部变量表膨胀，它的栈帧就越大，以满足方法调用所需传递的信息增大的需求。进而函数调用就会占用更多的栈空间，导致其嵌套调用次数就会减少。
😦 局部变量表中的变量只在当前方法调用中有效。在方法执行时，虚拟机通过使用局部变量表完成参数值到参数变量列表的传递过程。当方法调用结束后，随着方法栈帧的销毁，局部变量表也会随之销毁。
局部变量表是影响栈帧大小的关键
字节码中方法内部结构的剖析
代码
package com.atguigu.java.stack;
import java.util.Date;
public class LocalVariablesTest {
public static void main(String[] args) {
LocalVariablesTest test = new LocalVariablesTest();
int num = 10;
test.test1();
}
public void test1() {
Date date = new Date();
String name1 = "yc.com";
String info = test2(date,name1);
System.out.println(date + name1);
}
public String test2(Date dateP, String name2) {
dateP =null;
name2 = "我是test2中的name2";
double weiht =130.5;
return dateP + name2;
}
}
使用字节码插件查看字节码分析
Code 中内容
main
字节码指令
异常表
其他项（杂项 Misc）
**行号表 LineNumberTable **
局部变量表 LocalVariableTable
保存的是方法中的局部变量
局部变量表,每一列说明
😦 起始PC： 对应的字节码指令行号。也就是作用域的起始位置。一个变量在我们定义完成之后才能使用。
😦 长度：往后多少行。（起始PC 加上 长度 的和，正好等于字节码指令的长度 。也对应着方法的结束）
😦 序号: 被加载的顺序吧，先加载就在前面
😦 名字： 就是参数定义的名字
😦 描述符 Signature 参数的信息，[ 代表是数组，L 代表是引用类型，I 代表是 int ，D 代表是double。
分析 形参 String[] args的作用范围
行号表
起始PC,长度
从代码中角度分析 args 参数肯定是在整个 main方法中都可以使用的，结合行号表看出 字节码指令0，对应的代码行号是 7，说明从第7 行就可以使用了。 结合起始PC和长度得知 ，作用域是往后8行，往后 16行，正好对应方法的结束。
**分析test 的作用范围 **
从代码中角度分析 test 肯定是在我们new 之后才能使用，结合行号可以看出，对应的代码行号是8，说明从第8行就可以使用了， 结合起始PC和长度得知，作用域是往后8行。也是对应着方法的结束。
变量槽 slot的理解
参数值的存放总是在局部变量数组的index0 开始，到数组长度- 1 的索引结束。
局部变量表，最基本的存储单元是Slot （变量槽）。
局部变量表中存放编译期可知的各种基本数据类型，引用数据类型和return Address类型的变量。
在局部变量表里，32以内的类型只占用一个slot （包括return address类型）64位的类型占用两个slot 。
解释： 如果当前帧是由构造方法或者实例方法创建的，那么 该对象引用this将会存放在index0的slot中，其余的参数按照参数表顺序继续排列
静态方法是不能使用this的。因为局部变量表中没有保存 this。
slot的重复利用
栈帧中的局部变量表中的槽位是可以重用的，如果一个局部变量过了其作用域，那么在其作用域之后申明的新的局部变量就很有可能会复用过期局部变量的槽位，从而达到节省资源的目的。
静态变量于局部变量的对比
变量的分类：
按照数据类型分：基本数据类型，引用数据类型
按照在类中声明的位置分：
成员变量：在使用前，都经历过默认初始化赋值。
类变量：linking的prepare阶段：给类变量默认赋值，----->initial阶段：给类变量显示赋值即静态代码块赋值。
实例变量：随着对象的创建，会在堆空间中分配实例变量空间，并默认赋值。
局部变量：在使用前，必须要进行显示赋值的。否则，编译不通过
2912
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
