虚拟机栈详解

川长思鸟来 2022-09-09 00:30 245阅读 0赞

# 虚拟机栈概述 #

## 虚拟机栈出现的背景 ##

由于跨平台性的设计, Java的指令都是根据栈来设计的。不同平台CPU架构不同,所以不能设计为基于寄存器的。

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

## 误解 ##

有不少Java开发人员一提到Java内存结构,就会非常粗粒度地将JVM中的内存区理解为仅有Java堆(heap)和Java栈(stack)

## 内存中的栈与堆 ##

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

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

栈：用来存储局部变量，堆：用来存储对象和数组

## 虚拟机栈基本内容 ##

### Java虚拟机栈是什么? ###

Java虚拟机栈(Java virtual Machine stack) ,早期也叫Java栈。每个线程在创建时都会创建一个虚拟机栈,其内部保存一个个的栈帧(stack Frame) ,对应着一次次的Java方法调用。一次方法的调用，就是栈帧入栈到出栈的过程

是线程私有的

### 生命周期 ###

生命周期和线程一致。

### 作用 ###

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

package com.dongguo.jvm05;
    
    /** * @author Dongguo * @date 2021/8/26 0026-15:09 * @description: */
    public class StackTest { 
        public static void main(String[] args) { 
            StackTest stackTest = new StackTest();
            stackTest.methodA();
        }
    
        public void methodA() { 
            int i = 10;
            int j = 20;
            methodB();
        }
    
        private void methodB() { 
            int k = 30;
            int m = 40;
        }
    }

![image-20210826151530778][]

### 栈的优点 ###

栈是一种快速有效的分配存储方式,访问速度仅次于程序计数器。

JVM直接对Java栈的操作只有两个:

每个方法执行,伴随着进栈(入栈、压栈)

执行结束后的出栈工作

对于栈来说不存在垃圾回收问题

存在OOM

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

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

如果采用固定大小的Java虚拟机栈,那每一个线程的Java虚拟机栈容量可以在线程创建的时候独立选定。如果线程请求分配的栈容量超过Java虚拟机栈允许的最大容量, Java虚拟机将会抛出一个stackoverflowError异常。

如果Java虚拟机栈可以动态扩展,并且在尝试扩展的时候无法申请到足够的内存,或者在创建新的线程时没有足够的内存去创建对应的虚拟机栈,那Java虚拟机将会抛出一个outOfMemoryError异常。

package com.dongguo.jvm05;
    
    /** * @author Dongguo * @date 2021/8/26 0026-15:25 * @description: stackoverflowError */
    public class StackErrorTest { 
        private static int count =0;
        //递归调用
        public static void main(String[] args) { 
            count++;
            System.out.println(count);
            main(args);
        }
    }

![image-20210826155353595][]

### 设置栈内存大小 ###

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

[oracle官方文档][oracle]

-Xss size
    Sets the thread stack size (in bytes). Append the letter k or K to indicate KB, m or M to indicate MB, and g or G to indicate GB. The default value depends on the platform:
    
    Linux/x64 (64-bit): 1024 KB
    
    macOS (64-bit): 1024 KB
    
    Oracle Solaris/x64 (64-bit): 1024 KB
    
    Windows: The default value depends on virtual memory
    
    The following examples set the thread stack size to 1024 KB in different units:
    
    -Xss1m
    -Xss1024k
    -Xss1048576
    This option is similar to -XX:ThreadStackSize.

上一段代码输出count为11410，修改-Xss256k看看输出值为多少

点击run->Edit Configrations

![image-20210826160045712][]

![image-20210826162338868][]

我使用的是idea2021版默认没有显示VM，点击Modify options ->add VM options

![image-20210826162452271][]

重新运行程序输出2464，说明配置起作用了

![image-20210826162542360][]

# 栈的存储单位 #

每个线程都有自己的栈,栈中的数据都是以栈帧(stack Frame)的格式存在。

在这个线程上正在执行的每个方法都各自对应一个栈帧(stack Erame)，方法的执行，就是栈帧入栈到出栈的过程。

栈帧是一个内存区块,是一个数据集,维系着方法执行过程中的各种数据信息。

## 栈运行原理 ##

JVM直接对Java栈的操作只有两个,就是对栈帧的压栈和出栈,遵循“先进后出" / “后进先出”原则。

在一条活动线程中,一个时间点上,只会有一个活动的栈帧。即只有当前正在执行的方法的栈帧(栈顶栈帧)是有效的,这个栈帧被称为当前栈帧 (Current Frame) , 与当前栈帧相对应的方法就是当前方法(currentMethod) ,定义这个方法的类就是当前类(Current class) 。

执行引擎运行的所有字节码指令只针对当前栈帧进行操作。

如果在该方法中调用了其他方法,对应的新的栈帧会被创建出来,放在栈的顶端,成为新的当前帧。

![image-20210826163317731][]

package com.dongguo.jvm05;
    
    /** * @author Dongguo * @date 2021/8/26 0026-16:35 * @description: */
    public class StackFrameTest { 
        public static void main(String[] args) { 
            StackFrameTest stackFrameTest = new StackFrameTest();
            stackFrameTest.methodA();
        }
    
        public void methodA() { 
            System.out.println("methodA方法开始执行");
            methodB();
            System.out.println("methodA方法执行结束");
        }
    
        public int methodB() { 
            System.out.println("methodB方法开始执行");
            int i = 10;
            int m = (int) methodC();
            System.out.println("methodB方法即将结束");
            return i + m;
        }
    
        public double methodC() { 
            System.out.println("methodC方法开始执行");
            double j = 20.0;
            System.out.println("methodC方法即将结束");
            return j;
        }
    }
    运行结果：
    methodA方法开始执行
    methodB方法开始执行
    methodC方法开始执行
    methodC方法即将结束
    methodB方法即将结束
    methodA方法执行结束

对生成的StackFrameTest.class进行反编译

E:\workspace\JVMDemo\target\classes\com\dongguo>cd jvm05
    
    E:\workspace\JVMDemo\target\classes\com\dongguo\jvm05>javap -v StackFrameTest.class

public void methodA();
        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           #8                  // String methodA方法开始执行
             5: invokevirtual #7                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
             8: aload_0
             9: invokevirtual #9                  // Method methodB:()I
            12: pop
            13: getstatic     #5                  // Field java/lang/System.out:Ljava/io/PrintStream;
            16: ldc           #10                 // String methodA方法执行结束
            18: invokevirtual #7                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V 
            21: return  //没有返回值
          LineNumberTable:
            line 16: 0
            line 17: 8
            line 18: 13
            line 19: 21
          LocalVariableTable:
            Start  Length  Slot  Name   Signature
                0      22     0  this   Lcom/dongguo/jvm05/StackFrameTest;
    
      public int methodB();
        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           #11                 // String methodB方法开始执行
             5: invokevirtual #7                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
             8: bipush        10
            10: istore_1
            11: aload_0
            12: invokevirtual #12                 // Method methodC:()D
            15: d2i
            16: istore_2
            17: getstatic     #5                  // Field java/lang/System.out:Ljava/io/PrintStream;
            20: ldc           #13                 // String methodB方法即将结束
            22: invokevirtual #7                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
            25: iload_1
            26: iload_2
            27: iadd
            28: ireturn  //int return
          LineNumberTable:
            line 22: 0
            line 23: 8
            line 24: 11
            line 25: 17
            line 26: 25
          LocalVariableTable:
            Start  Length  Slot  Name   Signature
                0      29     0  this   Lcom/dongguo/jvm05/StackFrameTest;
               11      18     1     i   I
               17      12     2     m   I
    
      public double methodC();
        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           #14                 // String methodC方法开始执行
             5: invokevirtual #7                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
             8: ldc2_w        #15                 // double 20.0d
            11: dstore_1
            12: getstatic     #5                  // Field java/lang/System.out:Ljava/io/PrintStream;
            15: ldc           #17                 // String methodC方法即将结束
            17: invokevirtual #7                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
            20: dload_1
            21: dreturn  //double return
          LineNumberTable:
            line 30: 0
            line 31: 8
            line 32: 12
            line 33: 20
          LocalVariableTable:
            Start  Length  Slot  Name   Signature
                0      22     0  this   Lcom/dongguo/jvm05/StackFrameTest;
               12      10     1     j   D
    }

不同线程中所包含的栈帧是不允许存在相互引用的,即不可能在一个栈帧之中引用另外一个线程的栈帧。

如果当前方法调用了其他方法,方法返回之际,当前栈帧会传回此方法的执行结果,给前一个栈帧,接着,虚拟机会丢弃当前栈帧,使得前一个栈帧重新成为当前栈帧。

Java方法有两种返回函数的方式,一种是正常的函数返回,使用return指令;另外一种是抛出异常。不管使用哪种方式,都会导致栈帧被弹出。

package com.dongguo.jvm05;
    
    /** * @author Dongguo * @date 2021/8/26 0026-16:35 * @description: */
    public class StackFrameTest { 
        public static void main(String[] args) { 
            StackFrameTest stackFrameTest = new StackFrameTest();
            stackFrameTest.methodA();
            System.out.println("main方法正常结束");
        }
    
        public void methodA() { 
            System.out.println("methodA方法开始执行");
            methodB();
            System.out.println("methodA方法执行结束");
            System.out.println(10/0);//异常
        }
    
        public int methodB() { 
            System.out.println("methodB方法开始执行");
            int i = 10;
            int m = (int) methodC();
            System.out.println("methodB方法即将结束");
            return i + m;
        }
    
        public double methodC() { 
            System.out.println("methodC方法开始执行");
            double j = 20.0;
            System.out.println("methodC方法即将结束");
            return j;
        }
    }

methodA发生异常会将异常抛给调用者也就是main()，如果main()捕获了异常能够继续执行

如果没有处理异常就无法继续执行

![image-20210826165207106][]

捕获异常

package com.dongguo.jvm05;
    
    /** * @author Dongguo * @date 2021/8/26 0026-16:35 * @description: */
    public class StackFrameTest { 
        public static void main(String[] args) { 
            StackFrameTest stackFrameTest = new StackFrameTest();
            try { 
                stackFrameTest.methodA();
            } catch (Exception e) { 
                e.printStackTrace();
            }
            System.out.println("main方法正常结束");
        }
    
        public void methodA() { 
            System.out.println("methodA方法开始执行");
            methodB();
            System.out.println("methodA方法执行结束");
            System.out.println(10/0);//异常
        }
    
        public int methodB() { 
            System.out.println("methodB方法开始执行");
            int i = 10;
            int m = (int) methodC();
            System.out.println("methodB方法即将结束");
            return i + m;
        }
    
        public double methodC() { 
            System.out.println("methodC方法开始执行");
            double j = 20.0;
            System.out.println("methodC方法即将结束");
            return j;
        }
    }

![image-20210826165248321][]

## 栈帧的内部结构 ##

每个栈帧中存储着:

局部变量表(Local variables)

操作数栈(operand stack) (或表达式栈)

动态链接(Dynamic Linking) (或指向运行时常量池的方法引用)

方法返回地址(Return Address) (或方法正常退出或者异常退出的定义)

一些附加信息

![image-20210826172229278][]

多线程下

![image-20210826180455365][]

# 局部变量表（Local variables） #

局部变量表也被称之为局部变量数组或本地变量表

定义为一个数字数组,主要用于存储方法参数和定义在方法体内的局部变量,这些数据类型包括各类基本数据类型、对象引用(reference) ,以及returnAddress类型。

由于局部变量表是建立在线程的栈上,是线程的私有数据,因此不存在数据安全问题

局部变量表所需的容量大小是在编译期确定下来的,并保存在方法的code属性的maximum local variables数据项中。在方法运行期间是不会改变局部变量表的大小的。

main方法的局部变量表 执行javap

public static void main(java.lang.String[]);
        descriptor: ([Ljava/lang/String;)V
        flags: ACC_PUBLIC, ACC_STATIC
        Code:
          stack=2, locals=3, args_size=1  //locals=3 指局部变量最大容量为3
             0: new           #3                  // class com/dongguo/jvm05/LocalVariablesTest
             3: dup
             4: invokespecial #4                  // Method "<init>":()V
             7: astore_1
             8: bipush        10
            10: istore_2
            11: aload_1
            12: invokevirtual #5                  // Method test1:()V
            15: return
          LineNumberTable:
            line 14: 0
            line 15: 8
            line 16: 11
            line 17: 15
          LocalVariableTable:
            Start  Length  Slot  Name   Signature
                0      16     0  args   [Ljava/lang/String;
                8       8     1  test   Lcom/dongguo/jvm05/LocalVariablesTest;
               11       5     2   num   I

使用jclasslib

![image-20210826182513960][]

![image-20210826182712385][]

这两种方法显示的内容是一样的

方法嵌套调用的次数由栈的大小决定。一般来说,栈越大,方法嵌套调用次数越多。对一个函数而言,它的参数和局部变量越多,使得局部变量表膨胀,它的栈帧就越大,以满足方法调用所需传递的信息增大的需求。进而函数调,用就会占用更多的栈空间,导致其嵌套调用次数就会减少。

局部变量表中的变量只在当前方法调用中有效。在方法执行时,虚拟机通过使用局部变量表完成参数值到参数变量列表的传递过程。当方法调用结束后,随着方法栈帧的销毁,局部变量表也会随之销毁。

具体分析

package com.dongguo.jvm05;
    
    import java.util.Date;
    
    /** * @author Dongguo * @date 2021/8/26 0026-18:08 * @description: */
    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 name = "zhangsan";
            String info = test2(date, name);
            System.out.println(date + name);
        }
    
        public String test2(Date date2, String name2) { 
            date2 = null;
            name2 = "lisi";
            double weight = 130.5;
            char gender = '男';
            return date2 + name2;
        }
        public void test3(){ 
            count++;
        }
        public void test4() { 
            int a = 0;
            { 
                int b = 0;
                b = a + 1;
            }
            int c = a + 1;
        }
    }

![image-20210826204604445][]

![image-20210826204705135][]

![image-20210826204749333][]

![image-20210826204936457][]

![image-20210826205018222][]

有3个局部变量args、test、num

静态方法

package com.dongguo.jvm05;
    
            import java.util.Date;
    
    /** * @author Dongguo * @date 2021/8/26 0026-18:08 * @description: */
    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);
        }
    
        public void test1() { 
            Date date = new Date();
            String name = "zhangsan";
            String info = test2(date, name);
            System.out.println(date + name);
        }
    
        public String test2(Date date2, String name2) { 
            date2 = null;
            name2 = "lisi";
            double weight = 130.5;
            char gender = '男';
            return date2 + name2;
        }
        public void test3(){ 
            count++;
        }
            public void test4() { 
            int a = 0;
            { 
                int b = 0;
                b = a + 1;
            }
            int c = a + 1;
        }
    }

![image-20210826205719678][]

![image-20210826205746062][]

![image-20210826210003568][]

![image-20210826205810202][]

代码从20行到24行

![image-20210826205826827][]

## Slot (变量槽) ##

参数值的存放总是在局部变量数组的index0开始,到数组长度-1的索引结束。

局部变量表,最基本的存储单元是Slot (变量槽)

局部变量表中存放编译期可知的各种基本数据类型(8种),引用类型.(reference), returnAddress类型的变量。

在局部变量表里, 32位以内的类型只占用一个slot (包括returnAddress类型) , 64位的类型(1ong和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处**,其余的参数按照参数表顺序继续排列。

![image-20210826210434028][]

### 关于slot的使用的理解 ###

package com.dongguo.jvm05;
    
    import java.util.Date;
    
    /** * @author Dongguo * @date 2021/8/26 0026-18:08 * @description: */
    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);
        }
        public LocalVariablesTest(){ 
            this.count = 1;
        }
    
        public void test1() { 
            Date date = new Date();
            String name = "zhangsan";
            String info = test2(date, name);
            System.out.println(date + name);
        }
    
        public String test2(Date date2, String name2) { 
            date2 = null;
            name2 = "lisi";
            double weight = 130.5;
            char gender = '男';
            return date2 + name2;
        }
    
        public void test3() { 
            count++;
        }
    
        public void test4() { 
            int a = 0;
            { 
                int b = 0;
                b = a + 1;
            }
            int c = a + 1;
        }
    }

实例方法test1()

![image-20210826211251575][]

实例方法test2()

![image-20210826211422362][]

double占用2个slot，所以weight的序号是3，gender的序号是5

实例方法test3()

![image-20210826211738879][]

构造器

![image-20210826211831800][]

### slot的重复利用 ###

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

实例方法test4()

![image-20210826212039026][]

按理说局部变量表的长度是4，其中存在重复利用，c使用之前已经已经销毁的变量b占据的slot的位置

### 扩展： ###

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

参数表分配完毕之后,再根据方法体内定义的变量的顺序和作用域分配。

我们知道类变量表有两次初始化的机会,第一次是在“准备阶段” ,执行系统初始化,对类变量设置零值,另一次则是在“初始化”阶段,赋子程序员在代码中定义的初始值。

和类变量初始化不同的是,局部变量表不存在系统初始化的过程,这意味着一旦定义了局部变量则必须人为的初始化,否则无法使用。

#### 变量的分类: ####

按照数据类型分: 1基本数据类型2引用数据类型

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

1成员变量:在使用前,都经历过默认初始化赋值

类变量: Linking的prepare阶段:给类变量默认赋值–>initial阶段：给类变量显示赋值即静态代码快赋值

实例变量:随着对象的创建,会在堆空间中分配实例变量空间,并进行默认赋值。

2局部变量:在使用前,必须要进行显式赋值的!否则,编译不通过

public void testTemp(){ 
            int num;//局部变量
            System.out.println(num);//Variable 'num' might not have been initialized变量num没有初始化
        }

## 补充说明 ##

在栈帧中,与性能调优关系最为密切的部分就是前面提到的局部变量表。在方法执行时,虚拟机使用局部变量表完成方法的传递。

**局部变量表中的变量也是重要的垃圾回收根节点,只要被局部变量表中直接或间接引用的对象都不会被回收。**

# 操作数栈（Operand Stack） #

每一个独立的栈帧中除了包含局部变量表以外,还包含一个后进先出(Last-In-First-out)的操作数栈,也可以称之为表达式栈(Expression stack),

**操作数栈,在方法执行过程中,根据字节码指令,往栈中写入数据或提取数据,即入栈(push) /出栈(pop) 。**

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

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

![image-20210826213834503][]

![image-20210826214103990][]

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

操作数栈就是JVM执行引擎的一个工作区,当一个方法刚开始执行的时候,一个新的栈帧也会随之被创建出来,这个方法的操作数栈是空的。

每一个操作数栈都会拥有一个明确的栈深度用于存储数值,其所需的最大深度在编译期就定义好了,保存在方法的Code属性中,为max\_stack的"值。

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

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

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

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

![image-20210826214505772][]

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

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

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

# 代码追踪 #

编译后查看jclasslib

![image-20210827082151964][]

init方法是默认构造器方法

testAddOperation（）自定义的方法

![image-20210827082324424][]

第一行 bipush，byte类型保存为int类型，PC寄存器记录的行号为0，此时局部变量表没有值，操作数栈值为15

第二行 istore\_1 ，PC寄存器记录的行号为2，此时将操作数栈中的值放入局部变量表索引为1的位置中，操作数栈无值。

局部变量表索引为0的记录的是this

![image-20210827083045740][]

![image-20210827083614714][]

![image-20210827083646568][]

iload将局部变量表指定索引的值放到操作数栈中

![image-20210827083858550][]

iadd 执行相加操作8、15出栈，23入栈

istore\_3 将23从操作数栈存到局部变量表中

![image-20210827084058562][]

所以操作数栈最大深度为2，局部变量最大槽数为4（索引为0的是this）

**类型的自动转换**

![image-20210827084408971][]

bipush 将8看成byte类型入栈

istore存储为int类型放到局部变量表索引为4的位置

![image-20210827084555645][]

sipush 将800当做short类型入栈

istore 存储为int类型放到局部变量表索引为4的位置

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

package com.dongguo.jvm05;
    
    /** * @author Dongguo * @date 2021/8/27 0027-8:17 * @description: */
    public class OperandStackTest { 
        public void testAddOperation() { 
            byte i = 15;
            int j = 8;
            int k = i + j;
    
    // int m = 800;
        }
    
        public int getSum() { 
            byte m = 10;
            int n = 20;
            int o = m + n;
            return o;
        }
    
        public void test() { 
            int i = getSum();
            int j = 10;
        }
    }

重新编译

![image-20210827085304151][]

getSum() 字节码11 ireturn

![image-20210827085453218][]

aload\_0

获取上一个栈帧返回的结果，并保存在操作数栈中

# 栈顶缓存(Top-of-Stack-Cashing)技术 #

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

由于操作数是存储在内存中的,因此频繁地执行内存读/写操作必然会影响执行速度。为了解决这个问题, HotSpot JVM的设计者们提出了栈顶缓存(Tos, Top-of-stack Cashing)技术,**将栈顶元素全部缓存在物理CPU的寄存器中,以此降低对内存的读/写次数,提升执行引擎的执行效率**。

## 动态链接(Dynamic Linking) ##

![image-20210827122454204][]

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

每一个栈帧内部都包含一个**指向运行时常量池中该栈帧所属方法的引用**。包含这个引用的目的就是为了支持当前方法的代码能够实现动态链接(Dynamic Linking) 。比如: invokedynamic指令,

在Java源文件被编译到字节码文件中时,所有的变量和方法引用都作为符号引用(Symbolic Reference)保存在class文件的常量池里。比如:描述一个方法调用了另外的其他方法时,就是通过常量池中指向方法的符号引用来表示的,那么\*\*动态链接的作用就是为了将这些符号引用转换为调用方法的直接引用\*\*\*\*。

package com.dongguo.jvm05;
    
    /** * @author Dongguo * @date 2021/8/27 0027-10:29 * @description: */
    public class DynamicLinkingTest { 
        int num = 10;
    
        public void methodA() { 
            System.out.println("methodA()---");
        }
    
        public void methodB() { 
            System.out.println("methodB()---");
            methodA();
            num++;
        }
    }

编译后

E:\workspace\JVMDemo\target\classes\com\dongguo\jvm05>javap -v DynamicLinkingTest.class

public class com.dongguo.jvm05.DynamicLinkingTest
      minor version: 0
      major version: 52
      flags: ACC_PUBLIC, ACC_SUPER
    Constant pool:   //常量池
       #1 = Methodref          #9.#23         // java/lang/Object."<init>":()V
       #2 = Fieldref           #8.#24         // com/dongguo/jvm05/DynamicLinkingTest.num:I
       #3 = Fieldref           #25.#26        // java/lang/System.out:Ljava/io/PrintStream;
       #4 = String             #27            // methodA()---
       #5 = Methodref          #28.#29        // java/io/PrintStream.println:(Ljava/lang/String;)V
       #6 = String             #30            // methodB()---
       #7 = Methodref          #8.#31         // com/dongguo/jvm05/DynamicLinkingTest.methodA:()V
       #8 = Class              #32            // com/dongguo/jvm05/DynamicLinkingTest
       #9 = Class              #33            // java/lang/Object
      #10 = Utf8               num
      #11 = Utf8               I
      #12 = Utf8               <init>
      #13 = Utf8               ()V
      #14 = Utf8               Code
      #15 = Utf8               LineNumberTable
      #16 = Utf8               LocalVariableTable
      #17 = Utf8               this
      #18 = Utf8               Lcom/dongguo/jvm05/DynamicLinkingTest;
      #19 = Utf8               methodA
      #20 = Utf8               methodB
      #21 = Utf8               SourceFile
      #22 = Utf8               DynamicLinkingTest.java
      #23 = NameAndType        #12:#13        // "<init>":()V
      #24 = NameAndType        #10:#11        // num:I
      #25 = Class              #34            // java/lang/System
      #26 = NameAndType        #35:#36        // out:Ljava/io/PrintStream;
      #27 = Utf8               methodA()---
      #28 = Class              #37            // java/io/PrintStream
      #29 = NameAndType        #38:#39        // println:(Ljava/lang/String;)V
      #30 = Utf8               methodB()---
      #31 = NameAndType        #19:#13        // methodA:()V
      #32 = Utf8               com/dongguo/jvm05/DynamicLinkingTest
      #33 = Utf8               java/lang/Object
      #34 = Utf8               java/lang/System
      #35 = Utf8               out
      #36 = Utf8               Ljava/io/PrintStream;
      #37 = Utf8               java/io/PrintStream
      #38 = Utf8               println
      #39 = Utf8               (Ljava/lang/String;)V
    {
      int num;
        descriptor: I
        flags:
    
      public com.dongguo.jvm05.DynamicLinkingTest();
        descriptor: ()V
        flags: ACC_PUBLIC
        Code:
          stack=2, locals=1, args_size=1
             0: aload_0
             1: invokespecial #1                  // Method java/lang/Object."<init>":()V
             4: aload_0
             5: bipush        10
             7: putfield      #2                  // Field num:I
            10: return
          LineNumberTable:
            line 8: 0
            line 9: 4
          LocalVariableTable:
            Start  Length  Slot  Name   Signature
                0      11     0  this   Lcom/dongguo/jvm05/DynamicLinkingTest;
    
      public void methodA();
        descriptor: ()V
        flags: ACC_PUBLIC
        Code:
          stack=2, locals=1, args_size=1
             0: getstatic     #3                  // Field java/lang/System.out:Ljava/io/PrintStream;
             3: ldc           #4                  // String methodA()---
             5: invokevirtual #5                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
             8: return
          LineNumberTable:
            line 12: 0
            line 13: 8
          LocalVariableTable:
            Start  Length  Slot  Name   Signature
                0       9     0  this   Lcom/dongguo/jvm05/DynamicLinkingTest;
    
      public void methodB();
        descriptor: ()V
        flags: ACC_PUBLIC
        Code:
          stack=3, locals=1, args_size=1
             0: getstatic     #3                  // Field java/lang/System.out:Ljava/io/PrintStream;
             3: ldc           #6                  // String methodB()---
             5: invokevirtual #5                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
             8: aload_0
             9: invokevirtual #7                  // Method methodA:()V
            12: aload_0
            13: dup
            14: getfield      #2                  // Field num:I
            17: iconst_1
            18: iadd
            19: putfield      #2                  // Field num:I
            22: return
          LineNumberTable:
            line 16: 0
            line 17: 8
            line 18: 12
            line 19: 22
          LocalVariableTable:
            Start  Length  Slot  Name   Signature
                0      23     0  this   Lcom/dongguo/jvm05/DynamicLinkingTest;
    }
    SourceFile: "DynamicLinkingTest.java"

![21cea1c0bd496a5323ad1353aa7519b7.png][]

### 为什么需要常量池？ ###

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

# 方法的调用：解析与分派 #

## 静态链接与动态链接 ##

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

**静态链接**

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

**动态链接**

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

## 早期绑定与晚期绑定 ##

对应的方法的绑定机制为:早期绑定(Early Binding)和晚期绑定Late Binding) 。绑定是一个字段、方法或者类在符号引用被替换为直接引用的过程,这仅仅发生一次。

**早期绑定:**

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

**晚期绑定:**

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

package com.dongguo.jvm05;
    
    /** * @author Dongguo * @date 2021/8/27 0027-10:54 * @description: 早期绑定和晚期绑定 */
    class Animal { 
        public void eat() { 
            System.out.println("动物进食");
        }
    }
    
    interface Huntable { 
        public 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 huntable) { 
            huntable.hunt();//接口 为晚期绑定
        }
    
    
    }

编译

晚期绑定

![image-20210827110414354][]

![image-20210827110435711][]

早期绑定

![image-20210827110510808][]

![image-20210827110539458][]

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

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

## 方法的调用：虚方法与非虚方法 ##

非虚方法:如果方法在编译期就确定了具体的调用版本,这个版本在运行时是不可变的。这样的方法称为非虚方法。

静态方法、私有方法、final方法、实例构造器、父类方法都是非虚方法。

其他方法称为虚方法。

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

普通调用指令:

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

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

1.  invokevirtual:调用所有虚方法
2.  invokeinterface:调用接口方法

动态调用指令:

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

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

package com.dongguo.jvm05;
    
    /** * @author Dongguo * @date 2021/8/27 0027-11:20 * @description: 非虚方法和虚方法 */
    class Father{ 
        public Father(){ 
            System.out.println("Father的构造器");
        }
        public static void showStatic(String str){ 
            System.out.println("Father show static "+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 show static "+str);
        }
        private void showPrivate(String str){ 
            System.out.println("Son private " +str);
        }
        public void show(){ 
            //invokestatic
            showStatic("showStatic");//Son show static showStatic
            //invokestatic
            super.showStatic(" super.showStatic");//Father show static super.showStatic
            //invokespecial
            showPrivate("showPrivate");//Son private showPrivate
            //invokespecial
            super.showCommon();//Father 普通方法
           
            //invokevirtual
            showFinal();//Father show final 因为此方法声明为final，不能被子类重写，所以也可以认为此方法是非虚方法
            //invokevirtual
            showCommon();//Father 普通方法 没有显示的使用super. 在编译期间无法确定
            //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 son = new Son();
            son.show();
        }
    }
    interface MethodInterface{ 
        void methodA();
    }
    运行结果：
    Father的构造器
    Son show static showStatic
    Father show static  super.showStatic
    Son private showPrivate
    Father 普通方法
    Father show final
    Father 普通方法
    Exception in thread "main" java.lang.NullPointerException
    	at com.dongguo.jvm05.Son.show(Son.java:48)
    	at com.dongguo.jvm05.Son.main(Son.java:59)

![4d2e7f40fc4581c9f00aabda0ea8b2a0.png][]

### invokedynamic指令的使用 ###

JM字节码指令集一直比较稳定,一直到Java7中才增加了一个invokedynamic指令,这是Java为了实现「动态类型语言」支持而做的一种改进。

但是在Java7中并没有提供直接生成invokedynamic指令的方法,需要借助ASM这种底层字节码工具来产生invokedynamic指令。直到Java8的Lambda表达式的出现, invokedynamic指令的生成,在Java中才有了直接的生成方式。

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

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

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

说的再直白一点就是,静态类型语言是判断变量自身的类型信息:动态类型语言是判断变量值的类型信息,变量没有类型信息,变量值才有类型信息,这是动态语言的一个重要特征。

package com.dongguo.jvm05;
    
    /** * @author Dongguo * @date 2021/8/27 0027-11:52 * @description: invokedynamic指令 */
    @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();
            //invokedynamic
            Func func = s -> { 
                return true;
            };
    
            lambda.lambda(func);
    		//invokedynamic
            lambda.lambda(s -> { 
                return true;
            });
        }
    }

![image-20210827115810727][]

## 方法重写的本质 ##

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

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

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

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

4.如果始终没有找到合适的方法,则抛出java. lang .AbstractMethodError异常。

**IllegalAccessError介绍:**

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

## 虚方法表 ##

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

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

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

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

举例1

![image-20210827120944080][]

未重写的方法指向父类，重写的方法指向自己

举例2

![image-20210827121224952][]

package com.dongguo.jvm05.virtulmethodtable;
    
    /** * @author Dongguo * @date 2021/8/27 0027-12:13 * @description: 虚方法表 */
    interface Friendly { 
        void sayHello();
    
        void SayGoodbye();
    }
    
    class Dog { 
        public void sayHello() { 
    
        }
    
        @Override
        public String toString() { 
            return "Dog";
        }
    
    }
    
    class Cat implements Friendly { 
    
        @Override
        public void sayHello() { 
    
        }
    
        @Override
        public void SayGoodbye() { 
    
        }
    
        @Override
        protected void finalize() throws Throwable { 
    
        }
    
        @Override
        public String toString() { 
            return "Cat";
        }
    
        public void eat() { 
    
        }
    }
    
    class CockerSpaniel extends Dog implements Friendly { 
        @Override
        public void sayHello() { 
            super.sayHello();
        }
    
        @Override
        public void SayGoodbye() { 
    
        }
    }
    
    public class VirtulMethodTable { 
    }

Dog虚方法表

![image-20210827122002492][]

CockerSpaniel虚方法表

![image-20210827122151378][]

# 方法返回地址（Return Address） #

![image-20210827122443527][]

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

一个方法的结束,有两种方式:

正常执行完成

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

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

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

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

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

2、在方法执行的过程中遇到了异常(Exception) ,并且这个异常没有在方法内进行处理,也就是只要在不方法的异常表中没有搜索到匹配的异常处理器,就会导致方法退出。简称异常完成出口。

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

![image-20210827124702180][]

package com.dongguo.jvm05;
    
    import java.util.Date;
    
    /** * @author Dongguo * @date 2021/8/27 0027-12:34 * @description: */
    public class ReturnAddressTest { 
        public boolean methodBoolean(){ 
            return false;//ireturn
        }
        public byte methodByte(){ 
            return 0;//ireturn
        }
        public short methodShort(){ 
            return 0;//ireturn
        }
        public char methodChar(){ 
            return 'a';//ireturn
        }
        public int methodInt(){ 
            return 0;//ireturn
        }
        public long methodLong(){ 
            return 0L;//lreturn
        }
        public float methodFloat(){ 
            return 0.0f;//freturn
        }
        public double methodDouble(){ 
            return 0.0;//dreturn
        }
        public String methodString(){ 
            return null;//areturn
        }
        public Date methodDate(){ 
            return null;//areturn
        }
        public void methodVoid(){ 
            //return
        }
        static { 
            int i = 10;
            //return
        }
        //默认构造器方法
        //return
        
            public void method2(){ 
            try { 
                method1();
            } catch (Exception e) { 
                e.printStackTrace();
            }
        }
    
        public void method1() throws IOException { 
            FileReader fis = new FileReader("xxx.txt");
            char[] cBuffer = new char[1024];
            int len;
            while ((len =fis.read(cBuffer))!=-1){ 
                String str =new String(cBuffer,0,len);
                System.out.println(str);
            }
            fis.close();
        }
    }

编译后使用javap

方法一出现异常

找到方法二的异常处理表，在代码52行处理异常

Exception table:
         from    to  target type
             0     4     7   Class java/lang/Exception

![image-20210827125720799][]

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

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

# 一些附加信息 #

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

# 栈的相关面试题 #

## 举例栈溢出的情况? ##

StackOverflowError

通过-Xss设置栈的大小

## 调整栈大小,就能保证不出现溢出吗? ##

不能，理论上只能延缓出现栈溢出的时间，不能保证一定不出现溢出

## 分配的栈内存越大越好吗? ##

内存空间有限 ，会占用过多

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

不会

![image-20210825164827598][]

Error (StackOverflowError) GC(OOM)

程序计数器 不存在 不存在

虚拟机栈 存在 不存在

本地方法栈 存在 不存在

堆 存在 存在

方法区 存在 存在

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

分情况而定

package com.dongguo.jvm05;
    
    /** * @author Dongguo * @date 2021/8/27 0027-13:19 * @description: 方法中定义的局部变量是否线程安全? */
    public class StringBuildTest { 
        //sb1线程安全
        public static void method1() { 
            //StringBuilder线程不安全
            StringBuilder sb1 = new StringBuilder();
            sb1.append("a");
            sb1.append("b");
            //...
        }
        //sb线程不安全
        public static void method2(StringBuilder sb) { 
            sb.append("a");
            sb.append("b");
            //...
        }
        //sb2有可能线程不安全，返回后可能被多个线程占用
        public static StringBuilder method3() { 
            StringBuilder sb2 = new StringBuilder();
            sb2.append("a");
            sb2.append("b");
            return sb2;
        }
        //sb3线程安全
        public static String method4() { 
            StringBuilder sb3 = new StringBuilder();
            sb3.append("a");
            sb3.append("b");
            return sb3.toString();
        }
        public static void main(String[] args) { 
            StringBuilder s = new StringBuilder();
            new Thread(() -> { 
                s.append("a");
                s.append("b");
            }).start();
    
            method2(s);
        }
    }

[image-20210826151530778]: /images/20220829/40d7b594dc8f457b96530e61798ab303.png
[image-20210826155353595]: /images/20220829/0d5fa5e1dda74ad2a07e0a575be2268a.png
[oracle]: https://docs.oracle.com/en/java/javase/11/tools/java.html#GUID-3B1CE181-CD30-4178-9602-230B800D4FAE
[image-20210826160045712]: /images/20220829/e89abbe22b6f4ce3ade68a35593819ad.png
[image-20210826162338868]: /images/20220829/fce76287c7544cd89863b95ec298c859.png
[image-20210826162452271]: /images/20220829/097f8fe8a6aa45898f6f3d7674e98580.png
[image-20210826162542360]: /images/20220829/741fd3329a004712ba83f151c55d0ecc.png
[image-20210826163317731]: /images/20220829/286947665f4345de90716aea2a225dd0.png
[image-20210826165207106]: /images/20220829/05f322bdc4344f9b85c6798fbbf23b6c.png
[image-20210826165248321]: /images/20220829/343ddce5051e428ca6877950d9abe450.png
[image-20210826172229278]: /images/20220829/75d42e521e0746cdab414fb4afe7daa6.png
[image-20210826180455365]: /images/20220829/c3a0ae23b6cc494f80d23f1887053006.png
[image-20210826182513960]: /images/20220829/075f72723e68491197ff4bca34732ca4.png
[image-20210826182712385]: /images/20220829/192c17a5ab184ad6a7921a317ef6449f.png
[image-20210826204604445]: /images/20220829/ef36fa6df5ef4c06899c500384155a98.png
[image-20210826204705135]: /images/20220829/e95cede36efe40179d83cf2b06a77ef0.png
[image-20210826204749333]: /images/20220829/73972346ac484a61824eb215e2d58572.png
[image-20210826204936457]: /images/20220829/f7e8de9b1d5e465eb426a4a4504d6a9f.png
[image-20210826205018222]: /images/20220829/cc93adaf9c5840c3828c63d73483cc87.png
[image-20210826205719678]: /images/20220829/9d15259049394894b724eb7804f417fc.png
[image-20210826205746062]: /images/20220829/a5d26ed5cb634013808406ca93475539.png
[image-20210826210003568]: /images/20220829/9b8972d08e564aa582ff3e3d3cce90a0.png
[image-20210826205810202]: /images/20220829/8d4b2877e1bd4b44a7d50e6ebedc9eba.png
[image-20210826205826827]: /images/20220829/edaa610ad71e41a9b57dbf8e51128e27.png
[image-20210826210434028]: /images/20220829/506cb3158ce1452b8af344c13cadc530.png
[image-20210826211251575]: /images/20220829/1cb6ba87d9b741ddaf95ce1b7836827c.png
[image-20210826211422362]: /images/20220829/f34dc99e1931464e88e857d3b9bd0fd4.png
[image-20210826211738879]: /images/20220829/79d0419e3eb64b4080c9fd43ba6bbb0b.png
[image-20210826211831800]: /images/20220829/9b29e05bc7194f2bac58be3938e41003.png
[image-20210826212039026]: /images/20220829/cd70a59cfdc84b63aadcc2f0b021af8c.png
[image-20210826213834503]: /images/20220829/d98704d5f79e4f159f8f6a38475f7b04.png
[image-20210826214103990]: /images/20220829/389f723c6a3b49f89e3a690c1b10cac4.png
[image-20210826214505772]: /images/20220829/ea6f89d22c5a4392866b8fd91441c3b4.png
[image-20210827082151964]: /images/20220829/810259666c9b4a70a1920b0320bdb43b.png
[image-20210827082324424]: /images/20220829/639f3ab7a7584134a60484949aad06ed.png
[image-20210827083045740]: /images/20220829/cb50f47efd1146f893ec82be143024c4.png
[image-20210827083614714]: /images/20220829/8eb6fb38abf74477b8eebd4f1f084885.png
[image-20210827083646568]: /images/20220829/e7162401c82e424fa09119e43670de69.png
[image-20210827083858550]: /images/20220829/b1f48c9d984e423c9419f6c3baf9a3a8.png
[image-20210827084058562]: /images/20220829/1177f36c16cc42b09bb1a18c7bdf5a39.png
[image-20210827084408971]: /images/20220829/ea65dfe78477491f8416b3d5fa8a149a.png
[image-20210827084555645]: /images/20220829/9f31a51a94f04b678792e8df102916f1.png
[image-20210827085304151]: /images/20220829/7ffa30c0b64947cfb3cc9467b2150bcb.png
[image-20210827085453218]: /images/20220829/f6d5548a8f274d309ba71f4225f0bf75.png
[image-20210827122454204]: /images/20220829/1a9a8743bc79453ab073bdceee8e7b00.png
[21cea1c0bd496a5323ad1353aa7519b7.png]: /images/20220829/c4fec8d61eef4019b8b6dd3f700bf396.png
[image-20210827110414354]: /images/20220829/7bd175ed97a84a0db699baad01777d62.png
[image-20210827110435711]: /images/20220829/b0706cb292fa4dfb94084361ccbbc27b.png
[image-20210827110510808]: /images/20220829/cd25a5507fd84acbbb619f3ef6f497ac.png
[image-20210827110539458]: /images/20220829/39f976068f1748589aec047268ab2c55.png
[4d2e7f40fc4581c9f00aabda0ea8b2a0.png]: /images/20220829/b110914a41b74663b51c305e5b7233eb.png
[image-20210827115810727]: /images/20220829/699692f105124a418ad24e009f8a9c67.png
[image-20210827120944080]: /images/20220829/4ec0288d3d3a46efb6f71d63efe7b4a1.png
[image-20210827121224952]: /images/20220829/0ad9905a5a2c4b51a1bd64669aebe42b.png
[image-20210827122002492]: /images/20220829/d8ccad63df16492cafe780e2a9222447.png
[image-20210827122151378]: /images/20220829/111fabcdfeed47348b80653e7277b6d9.png
[image-20210827122443527]: /images/20220829/0647837f63144d88b09fa3cf6aaa4bda.png
[image-20210827124702180]: /images/20220829/90f6a18a53714dca81ef203b731dc9c8.png
[image-20210827125720799]: /images/20220829/c9bb7c5743254b07b4d1afe14ca79f17.png
[image-20210825164827598]: /images/20220829/f3a3629585ff4116a62665f26c60b432.png