运行时数据区（程序计数器、虚拟机栈）

最新推荐文章于 2022-03-09 15:48:08 发布
最新推荐文章于 2022-03-09 15:48:08 发布
阅读量121 收藏
点赞数 1
分类专栏： JVM 文章标签： jvm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_32196893/article/details/120542953
版权

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

运行时数据区

在这里插入图片描述
Java虚拟机定义了若干程序运行期间会使用到的运行时数据区，其中有一些会随着虚拟机启动而创建，随着虚拟机退出而销毁。另一些则是与线程一一对应的，这些与线程对应的数据区会随着线程的开始和结束而创建和销毁。
从图中可以看出：程序计数器（PC）、本地方法栈（NMS）、虚拟机栈（VMS）是线程私有的。表明每个线程一份，相互不影响。
在这里插入图片描述
灰色的为单独线程私有的，橙色的为多个线程共享的，即方法区和堆区。

线程

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

JVM系统线程

  1. 使用jconsole或是任何一个调试工具，都能看到在后台有许多线程在运行。这些后台线程不包括调用public stati void main(Srting[])的main线程以及所有这个main线程自己创建的线程。
  2. Hotspot JVM里主要的几个后台线程：
    1. 虚拟机线程：这种线程的操作是需要JVM达到安全点才会出现。这些操作必须在不同的线程中发生的原因是他们都需要JVM达到安全点，这样堆才不会变化。这种线程的执行类型包括“stop-the-world"的垃圾收集，线程栈收集，线程挂起以及偏向锁撤销。
    2. 周期任务线程：这种线程是时间周期事件的体现（比如中断），他们一般用于周期性操作的调度执行。
    3. GC线程：这种线程对在JVM里不同种类的垃圾收集行为提供了支持。
    4. 编译线程：这种线程在运行时会将字节码编译成本地代码。
    5. 信号调度线程： 这种线程接收信号并发送给JVM，在它内部通过调用适当的方法进行处理。

PC程序计数器

在这里插入图片描述
JVM中的程序计数寄存器（Program Counter Register）中，Register的命名源于CPU的寄存器，寄存器存储指令相关的现场信息。CPU只有把数据装载到寄存器才能运行。

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

作用

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

PC寄存器
  1. 它是一块很小的内存空间，几乎可以忽略不计。也是运行速度最快的存储区域。
  2. 在JVM规范中，每个线程都有它自己的程序计数器，是线程私有的，生命周期与线程的生命周期保持一致。
  3. 任何时间一个线程都只有一个方法在执行，也就是所谓的当前方法。程序计数器会存储当前线程正在执行的的java方法的jvm指令地址；或者，如果是在执行native方法，则是未指定值（underfined）。
  4. 它是程序控制流的指示器，分支，循环，跳转，异常处理，线程恢复等基础功能都需要依赖这个计数器来完成。
  5. 字节码解释器工作时就是通过改变这个计数器的值来选取下一条需要执行的字节码指令。
  6. 它是唯一一个在Java虚拟机规范中没有规定任何OutOfMemoryError情况的区域。
举例
public class PCRegister {

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

执行命令：

javap -c PCRegister.class

得到如下结果：

Compiled from "PCRegister.java"
public class PCRegister {
  public PCRegister();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public static void main(java.lang.String[]);
    Code:
       0: bipush        10
       2: istore_1
       3: bipush        20
       5: istore_2
       6: iload_1
       7: iload_2
       8: iadd
       9: istore_3
      10: return
}

在这里插入图片描述
指令地址，是存储在PC寄存器中的。当执行引擎需要执行操作指令的时候，会从PC寄存器中取出指令地址，然后根据指令地址找到相应的操作指令，接着执行指令。

问题
  1. 为什么使用PC寄存器记录当前线程的执行地址呢？
    因为CPU需要不停的切换各个线程，这时候切换回来以后，就得知道接着从哪里开始继续执行。
    JVM的字节码解释器就需要通过改变PC寄存器的值来明确下一条应该执行什么样的字节码指令。
  2. PC寄存器为啥会设定了线程私有的？
    我们都知道所谓的多线程在一个特定的时间段内只会执行其中某一个线程的方法，CPU会不停地做任务切换，这样必然导致经常中断或恢复，如何保证分毫无差？为了能够准确地记录各个线程正在执行的当前字节码指令地址，最好的办法自然是为每一个线程都分配一个PC寄存器，这样一来各个线程之间便可以进行独立计算，从而不会出现相互干扰的情况。
CPU时间片

CPU时间片即CPU分配给各个程序的时间，每个线程被分配一个时间段，称作它的时间片。

在宏观上，我们可以同时打开多个应用程序，每个程序并行不悖，同时运行。
在微观上，由于只有一个CPU，一次只能处理程序要求的一部分，如何处理公平，一种方法就是引入时间片，每个程序轮流执行。

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

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

并行：并行，对应的时串行。并行，就是一个cpu，多个核心，同时执行多个线程。
并发：就是一个cpu的一个核心，快速的在线程间间切换执行。感觉线程在并行执行，其实某一个时刻，只有一个线程在执行。但是，由于cpu执行速度非常快，感觉起来像是在并行执行，其实时并发。

虚拟机栈

由于跨平台性的设计，Java的指令都是根据栈来设计的。不同平台CPU架构不同，所以不能设计为基于寄存器的。
优点是跨平台，指令集小，编译容易实现，缺点是性能下降，实现同样的功能需要更多指令。

虚拟机栈的概述
JAVA虚拟机是什么？

JAVA虚拟机栈，早期也叫JAVA栈。每个线程在创建时都会创建一个虚拟机栈，其内部保存一个个的栈帧（Stack Frame），对应着一次次的方法调用。是线程私有的。一个栈帧对应的一个方法调用

作用

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

栈的特点
  1. 栈是一种快速有效的分配存储方式，访问速度仅仅次于程序计数器。
  2. JVM直接对JAVA栈的操作只有两个：a.进栈（每个方法的执行），b.出栈（方法执行完）。
  3. 不存在垃圾回收。
栈中可能出现的异常
  1. java虚拟机规范允许java栈的大小是动态的或者是固定不变的。因此

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

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

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

    例如：-Xss256k 或 -Xss1m

栈的存储单位
栈中存储什么？
  1. 每个线程都有自己的栈，栈中的数据都是栈帧（Stack Frame）的格式存在。
  2. 在这个线程上正在执行的每个方法都各自对应一个栈帧（Stack Frame） 。
  3. 栈帧是一个内存区块，是一个数据集，维系着方法执行过程中的各种数据信息。
栈运行原理
  1. JVM直接对JAVA栈的操作只有两个，就是对栈帧的压栈和出栈，遵循“先进后出”。
  2. 在一条活动线程中，一个时间点上，只会有一个活动的栈帧。即只有当前正在执行的方法栈帧（栈顶栈帧）是有效的，这个栈帧被称为当前栈帧。与当前栈帧相对应的方法就是当前方法，定义这个方法的类就是当前类。
  3. 执行引擎运行的所有字节码指令只针对当前栈帧进行操作。
  4. 如果在该方法中调用了其他方法，对应的新的栈帧会被创建出来，放在栈的顶端，成为新的当前帧。
  5. 不同线程中所包含的栈帧是不允许存在相互引用的，即不可能在一个栈帧之中引用另外一个线程的栈帧。
  6. 如果当前方法调用了其他方法，方法返回之际，当前栈帧会传回此方法的执行结果给前一个栈帧，接着，虚拟机会丢弃当前栈帧，使得前一个栈帧重新成为当前栈帧。
  7. JAVA方法有两种返回函数的方式：1种是正常的函数返回，使用return指令；2另一种是抛出异常。不管使用哪种方式，都会导致栈帧被弹出。
栈帧的内部结构

在这里插入图片描述
局部变量表、操作数栈、动态链接、方法返回地址。

局部变量表（本地变量表）

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

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

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

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

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 name = "zhangsan";
        String info = test2(date, name);
        System.out.println(date + name);
    }

    private String test2(Date date, String name) {

        date = null;
        name = "Matrin";
        double weight = 120.0;
        char gender = '女';
        return date + name;
    }
}

编译以后执行 javap -v LocalVariablesTest.class 命令，查看

Classfile /home/mall/work/gitrepository/jvm/out/production/jvm/LocalVariablesTest.class
  Last modified Oct 1, 2021; size 1330 bytes
  MD5 checksum b5f9bf0e1ae61567d83004f3d13c525f
  Compiled from "LocalVariablesTest.java"
public class LocalVariablesTest
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Methodref          #19.#48        // java/lang/Object."<init>":()V
   #2 = Class              #49            // LocalVariablesTest
   #3 = Methodref          #2.#48         // LocalVariablesTest."<init>":()V
   #4 = Methodref          #2.#50         // LocalVariablesTest.test1:()V
   #5 = Class              #51            // java/util/Date
   #6 = Methodref          #5.#48         // java/util/Date."<init>":()V
   #7 = String             #52            // zhangsan
   #8 = Methodref          #2.#53         // LocalVariablesTest.test2:(Ljava/util/Date;Ljava/lang/String;)Ljava/lang/String;
   #9 = Fieldref           #54.#55        // java/lang/System.out:Ljava/io/PrintStream;
  #10 = Class              #56            // java/lang/StringBuilder
  #11 = Methodref          #10.#48        // java/lang/StringBuilder."<init>":()V
  #12 = Methodref          #10.#57        // java/lang/StringBuilder.append:(Ljava/lang/Object;)Ljava/lang/StringBuilder;
  #13 = Methodref          #10.#58        // java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
  #14 = Methodref          #10.#59        // java/lang/StringBuilder.toString:()Ljava/lang/String;
  #15 = Methodref          #60.#61        // java/io/PrintStream.println:(Ljava/lang/String;)V
  #16 = String             #62            // Matrin
  #17 = Double             120.0d
  #19 = Class              #63            // java/lang/Object
  #20 = Utf8               <init>
  #21 = Utf8               ()V
  #22 = Utf8               Code
  #23 = Utf8               LineNumberTable
  #24 = Utf8               LocalVariableTable
  #25 = Utf8               this
  #26 = Utf8               LLocalVariablesTest;
  #27 = Utf8               main
  #28 = Utf8               ([Ljava/lang/String;)V
  #29 = Utf8               args
  #30 = Utf8               [Ljava/lang/String;
  #31 = Utf8               test
  #32 = Utf8               num
  #33 = Utf8               I
  #34 = Utf8               test1
  #35 = Utf8               date
  #36 = Utf8               Ljava/util/Date;
  #37 = Utf8               name
  #38 = Utf8               Ljava/lang/String;
  #39 = Utf8               info
  #40 = Utf8               test2
  #41 = Utf8               (Ljava/util/Date;Ljava/lang/String;)Ljava/lang/String;
  #42 = Utf8               weight
  #43 = Utf8               D
  #44 = Utf8               gender
  #45 = Utf8               C
  #46 = Utf8               SourceFile
  #47 = Utf8               LocalVariablesTest.java
  #48 = NameAndType        #20:#21        // "<init>":()V
  #49 = Utf8               LocalVariablesTest
  #50 = NameAndType        #34:#21        // test1:()V
  #51 = Utf8               java/util/Date
  #52 = Utf8               zhangsan
  #53 = NameAndType        #40:#41        // test2:(Ljava/util/Date;Ljava/lang/String;)Ljava/lang/String;
  #54 = Class              #64            // java/lang/System
  #55 = NameAndType        #65:#66        // out:Ljava/io/PrintStream;
  #56 = Utf8               java/lang/StringBuilder
  #57 = NameAndType        #67:#68        // append:(Ljava/lang/Object;)Ljava/lang/StringBuilder;
  #58 = NameAndType        #67:#69        // append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
  #59 = NameAndType        #70:#71        // toString:()Ljava/lang/String;
  #60 = Class              #72            // java/io/PrintStream
  #61 = NameAndType        #73:#74        // println:(Ljava/lang/String;)V
  #62 = Utf8               Matrin
  #63 = Utf8               java/lang/Object
  #64 = Utf8               java/lang/System
  #65 = Utf8               out
  #66 = Utf8               Ljava/io/PrintStream;
  #67 = Utf8               append
  #68 = Utf8               (Ljava/lang/Object;)Ljava/lang/StringBuilder;
  #69 = Utf8               (Ljava/lang/String;)Ljava/lang/StringBuilder;
  #70 = Utf8               toString
  #71 = Utf8               ()Ljava/lang/String;
  #72 = Utf8               java/io/PrintStream
  #73 = Utf8               println
  #74 = Utf8               (Ljava/lang/String;)V
{
  public LocalVariablesTest();
    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   LLocalVariablesTest;

  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
         0: new           #2                  // class LocalVariablesTest
         3: dup
         4: invokespecial #3                  // Method "<init>":()V
         7: astore_1
         8: bipush        10
        10: istore_2
        11: aload_1
        12: invokevirtual #4                  // Method test1:()V
        15: return
      LineNumberTable:
        line 7: 0
        line 8: 8
        line 9: 11
        line 10: 15
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      16     0  args   [Ljava/lang/String;
            8       8     1  test   LLocalVariablesTest;
           11       5     2   num   I

  public void test1();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=3, locals=4, args_size=1
         0: new           #5                  // class java/util/Date
         3: dup
         4: invokespecial #6                  // Method java/util/Date."<init>":()V
         7: astore_1
         8: ldc           #7                  // String zhangsan
        10: astore_2
        11: aload_0
        12: aload_1
        13: aload_2
        14: invokespecial #8                  // Method test2:(Ljava/util/Date;Ljava/lang/String;)Ljava/lang/String;
        17: astore_3
        18: getstatic     #9                  // Field java/lang/System.out:Ljava/io/PrintStream;
        21: new           #10                 // class java/lang/StringBuilder
        24: dup
        25: invokespecial #11                 // Method java/lang/StringBuilder."<init>":()V
        28: aload_1
        29: invokevirtual #12                 // Method java/lang/StringBuilder.append:(Ljava/lang/Object;)Ljava/lang/StringBuilder;
        32: aload_2
        33: invokevirtual #13                 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
        36: invokevirtual #14                 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
        39: invokevirtual #15                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
        42: return
      LineNumberTable:
        line 13: 0
        line 14: 8
        line 15: 11
        line 16: 18
        line 17: 42
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      43     0  this   LLocalVariablesTest;
            8      35     1  date   Ljava/util/Date;
           11      32     2  name   Ljava/lang/String;
           18      25     3  info   Ljava/lang/String;
}
SourceFile: "LocalVariablesTest.java"
mall@ubuntu:~/work/gitrepository/jvm/out/production/jvm$ javap -c LocalVariablesTest.class 
Compiled from "LocalVariablesTest.java"
public class LocalVariablesTest {
  public LocalVariablesTest();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public static void main(java.lang.String[]);
    Code:
       0: new           #2                  // class LocalVariablesTest
       3: dup
       4: invokespecial #3                  // Method "<init>":()V
       7: astore_1
       8: bipush        10
      10: istore_2
      11: aload_1
      12: invokevirtual #4                  // Method test1:()V
      15: return

  public void test1();
    Code:
       0: new           #5                  // class java/util/Date
       3: dup
       4: invokespecial #6                  // Method java/util/Date."<init>":()V
       7: astore_1
       8: ldc           #7                  // String zhangsan
      10: astore_2
      11: aload_0
      12: aload_1
      13: aload_2
      14: invokespecial #8                  // Method test2:(Ljava/util/Date;Ljava/lang/String;)Ljava/lang/String;
      17: astore_3
      18: getstatic     #9                  // Field java/lang/System.out:Ljava/io/PrintStream;
      21: new           #10                 // class java/lang/StringBuilder
      24: dup
      25: invokespecial #11                 // Method java/lang/StringBuilder."<init>":()V
      28: aload_1
      29: invokevirtual #12                 // Method java/lang/StringBuilder.append:(Ljava/lang/Object;)Ljava/lang/StringBuilder;
      32: aload_2
      33: invokevirtual #13                 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
      36: invokevirtual #14                 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
      39: invokevirtual #15                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      42: return
}

可以看到，每个方法都有局部变量表LocalVariableTable。并且列出了局部变量表中的内容。
在这里插入图片描述

关于slot 的理解
  1. 参数值的存放总是从局部变量数组的index0开始，到数组长度-1的索引结束。
  2. 局部变量表，最基本的存储单元是Slot（变量槽）。
  3. 局部变量表中存放编译期可知的各种基本数据类型（8种），引用类型，returnAddress类型。
  4. 在局部变量表里，32位以内的类型只占用一个slot（包括returnAddress类型），64位的类型（long和double）占用两个slot。
  5. JVM会为局部变量表中的每一个slot都分配一个访问索引，通过这个索引可以成功访问到局部变量表中指定的局部变量值。
  6. 当一个实例方法被调用的时候，它的方法参数和方法体内部定义的局部变量将会按照顺序复制到局部变量表中的每一个slot上。
  7. 如果需要访问局部变量表中的一个64bit的局部变量时，只需要使用前一个索引即可。
  8. 如果当前帧是由构造方法或者实例方法创建的，那么该对象引用this将会存放在index为0的slot处，其余的参数按照参数的顺序继续排列。
slot 重复利用

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

public void test() {
    int a = 10;
    {
        int b = 0;
        b = a + 10;
    }
    // 这里c会用到b的槽位，局部变量表中槽位，
    // 因为槽位可以重复利用，而b出了大括号后，就会被回收
    int c = 20;
}

在这里插入图片描述
从局部变量表中，原来index为2的位置，存放的是变量b的值，后面被变量c用了。因此，同一个方法内部的局部变量对应的slot，是有可能被重复利用的。从而达到节省空间的目的。

静态变量与局部变量

变量按照在类中的位置，分为成员变量（类变量、实例变量）和局部变量。成员变量在使用之前都经过过默认初始化阶段。局部变量必须要显式赋值，才能够使用；否则编译不通过。

补充说明
  1. 栈帧中，与性能调优关系最为密切的部分就是前面提到的局部变量表。在方法执行时，虚拟机使用局部变量表完成方法的传递。
  2. 局部变量表中的变量也是重要的垃圾回收根节点，只要被局部变量表中直接或间接引用的对象都不会被回收。
操作数栈
  1. 操作数栈，在方法执行过程中，根据字节码指令，往栈中写入数据或提取数据，即入栈、出栈。某些字节码指令将值压入操作数栈，其余的字节码指令将操作数取出栈。
  2. 如果被调用的方法带有返回值的话，其返回值将会被压入当前栈帧的操作数栈中，并更新PC寄存器中下一条需要执行的字节码指令。
  3. 操作数栈中元素的数据类型必须与字节码指令的序列严格匹配，这由编译器在编译期间进行验证，同时在类加载过程中的类检验的数据流分析阶段要再次验证。
  4. JAVA 虚拟机的解释引擎是基于栈的执行引擎，其中的栈指的就是操作数栈。
  • 定义：
    1. 操作数栈，主要用于保存计算过程的中间结果，同时作为计算过程中变量临时的存储空间。
    2. 操作数栈就是 JVM 执行引擎的一个工作区。当一个方法刚开始执行的时候，一个新的栈帧也会随之被创建出来，这个方法的操作数栈是空的。
    3. 每一个操作数栈都会拥有一个明确的栈深度用于存储数值，其所需的最大深度在编译期就定义好了，保存在方法的code属性中，为max_stack的值。
    4. 栈中的任何一个元素都可以是任意的 JAVA 数据类型。32bit的类型占用一个栈单位的深度，64bit的类型占用两个栈单位的深度。
    5. 操作数栈并非采用访问索引的方式来进行数据访问，而是只能通过标准的入栈和出栈操作来完成一次数据访问。
      在这里插入图片描述
栈顶缓存技术

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

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

动态链接
  1. 每个栈帧内部都包含一个指向运行时常量池中该栈帧所属方法的引用。包含这个引用的目的就是为了支持当前方法的代码能够实现动态链接。
  2. 在JAVA源文件被编译到字节码文件中时，所有的变量和方法引用都作为符号引用保存在class文件的常量池里。比如，描述一个方法调用了另外的其他方法时，就是通过常量池中指向方法符号引用来表示的，那么动态链接的作用就是为了将这些符号引用转换为调用方法的直接引用。
    在这里插入图片描述
方法返回地址
  1. 存放调用该方法的pc寄存器的值。
  2. 一个方法的结束有两种方式：正常退出和异常退出。无论通过那种方式退出，在方法退出后都返回到该方法被调用的位置。方法正常退出时，调用者的pc计数器的值作为返回地址，即调用该方法的指令的下一条指令的地址。而异常退出的，返回地址是要通过异常表来确定，栈帧中一般不会保存这部分信息。
  3. 本质上，方法的退出就是当前栈帧出栈的过程。此时，需要恢复上层方法的局部变量表，操作数栈，将返回值压入调用者栈帧的操作数栈，设置PC寄存器值等，让调用者方法继续执行下去。

方法的调用

早期绑定和晚期绑定
  1. 早期绑定就是指被调用的目标方法如果在编译期可知，且运行期保持不变时，即可将这个方法与所属的类型进行绑定，这样一来，由于明确了被调用的目标方法究竟时是哪一个，因此也就可以使用静态链接的方式将符号引用转换为直接引用。
  2. 如果被调用的方法在编译期间无法被确定下来，只能够在程序运行期根据实际的类型绑定相关的方法，这种绑定方式也就被称之为晚期绑定。
public class AnimalTest {

    public void showAnimal(Animal animal) {
        animal.eat();
    }

    public void showHunt(Huntable h) {
        h.hunt();
    }
}

class Animal {
    public void eat() {
        System.out.println("动物进食");
    }
}

interface Huntable {

    void hunt();
}

class Dog extends Animal implements Huntable {

    public Dog() {
        super();
    }

    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }

    @Override
    public void hunt() {
        System.out.println("捕食耗子，多管闲事");
    }
}

首先用 jclasslib 工具看 AnimalTest 类中编译成的字节码：
showAnimal 方法的字节码：

0 aload_1
1 invokevirtual #2 <Animal.eat : ()V>
4 return

showHunt 方法的字节码：

0 aload_1
1 invokeinterface #3 <Huntable.hunt : ()V> count 1
6 return

看到两个指令： invokevirtual 和 invokeinterface ，表明方法运行是晚期绑定。就是在编译期间，无法确定具体的对象。到运行期间才可以。
接着用 jclasslib 工具看 Dog 类中编译成的字节码：
查看 构造器 Dog() 方法的字节码：

0 aload_0
1 invokespecial #1 <Animal.<init> : ()V>
4 return

这里用到了指令 invokespecial ，表明这里是早期绑定。也就是说，在编译器期间，调用super()方法，明确可以直到调用的是父类的构造器方法，而不用等待运行期间再确定。

相关面试题目

  1. 举例栈溢出的情况？
  2. 调整栈大小，就能保证不出现溢出吗？
  3. 分配的栈内存越大越好吗？
  4. 垃圾回收是否会涉及到虚拟机栈？
  5. 方法中定义的局部变量是否线程安全？
解答
  1. StackOverflowError。
  2. 不能。
  3. 栈和线程相对应，栈越大，能创建的线程就会少。
  4. 不会。
  5. 看情况。如果是基本类型的变量，则是线程安全的。如果是引用类型的变量，看引用指向的内存区域是否是共享的内存区域。如果线程独享，则是；否则不是。
~Rookie~Newbie~Noob~
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JVM学习-运行时数据区的认识
TyuIn的博客
11-07 503
一、运行时数据区的认识 线程共享和线程私有的区域 名词解释：PC程序计数器 VMS 虚拟机栈 NMS 本地方法栈 从上图可以大致的了解到线程私有区域的构成，接下来就对里面的每一个部分展开描述一下： （1）程序计数器（PC） 内存空间小，线程私有。字节码解释器工作是就是通过改变这个计数器的值来选取下一条需要执行指令的字节码指令，分支、循环、跳转、异常处理、线程恢复等基础功能都需要依赖计数器完成。 程序计数器线程私有的理解：由于Java 虚...
Java程序运行时数据区域
weixin_44250483的博客
10-22 150
概述 java程序员虽然把内存控制的权利全权交给Java虚拟机，但是，当出现内存泄漏和溢出方面的问题时，如果不了解虚拟机是怎样使用内存的，那么排查错误将会成为一项异常艰难的任务。 java程序运行时的数据区域（java虚拟机管理的内存）分为多个线程共享内存和线程私有内存。 所有线程共享的数据区域：依赖虚拟机进程的启动和结束而建立和销毁。细分为：堆和方法区（Java 8之后是元空间）。 线程私有的数据区域：依赖用户线程的启动和结束而建立和销毁。细分为：虚拟机栈、本地方法...
一个很简单的基于栈式过程虚拟机的实现，它运行目标平台【x86】的原生代码。
liulilittle的博客
09-06 1214
    本文提供的 “栈式过程虚拟机” 的实现，挂在本人的 github 上面，对想要深入了解 “栈式过程虚拟机” 的人，它或许可以起到一个不错的作用，但是本人建议一般性了解就可以了，另外顺带一提：如果你想要依靠它维持生活，在咋们国家是不可能不现实的，到时候你就只有 “多冷的隆冬 恨啊啊啊 在东北玩泥巴” 西北风吹啊吹；差不多这样子的凄惨。     如果你真想要搞 “过程虚拟机” 这方面的东西，...
Understanding the JVM（一）运行时数据区域
u012975128的博客
10-27 183
JVM在执行Java代码时都会把内存分为几个部分，即数据区来使用，这些区域都拥有自己的用途，并随着JVM进程的启动或者用户线程的启动和结束建立和销毁。 程序计数器 作用 记录当前线程所执行到的字节码的行号。字节码解释器工作的时候就是通过改变这个计数器的值来选取下一条需要执行的字节码指令。 意义 JVM的多线程是通过线程轮流切换并分配处理器执行时间来实现的，在任何一个确定的时刻，一个处理器或者多核处
Java 虚拟机中的运行时数据区分析
12-21
同时，方法调用和返回的过程依赖于程序计数器和虚拟机栈。本地方法栈则负责处理与本地代码的交互。 了解这些运行时数据区对于优化Java程序的性能至关重要，比如调整堆大小、设置新生代和老年代的比例、监控垃圾回收...
java虚拟机运行时数据区分析
08-28
Java虚拟机运行时数据区分析 Java虚拟机（JVM）是一种抽象的计算机，它提供了一个运行Java字节码的环境。JVM将Java源代码编译为字节码，并在运行时执行这些字节码。为了更好地理解JVM的工作原理，我们需要了解JVM的...
Java运行时数据区划分原理解析
08-19
Java运行时数据区划分原理解析 Java运行时数据区划分原理是Java虚拟机中的一种内存管理机制，它将内存区域划分为不同的部分，每个部分都有其特定的作用和功能。了解Java运行时数据区划分原理对于Java程序员来说非常...
Java运行时数据区概述详解
08-26
Java运行时数据区是Java虚拟机（JVM）在执行Java程序时管理内存的核心组成部分。这一数据区由多个不同的内存区域组成，每个区域都有特定的用途，为程序的执行提供必要的支持。以下是对这些区域的详细说明： 1. **...
运行时数据区域——程序计数器（Program Counter Register）。
孤芳不自赏
03-27 2081
博文中的内容来源《深入理解Java虚拟机_JVM高级特性与最佳实践》这一本书，感激不尽。
程序内存空间（代码段、数据段、堆栈段）
Enjoy Coding
08-24 5万+
在冯诺依曼的体系结构中必须有：代码段，堆栈段，数据段。 进程的虚拟地址空间图示如下： 堆栈段： 　　1. 为函数内部的局部变量提供存储空间。 　　2. 进行函数调用时，存储“过程活动记录”。 　　3. 用作暂时存储区。如计算一个很长的算术表达式时，可以将部分计算结果压入堆栈。 数据段（静态存储区）： 　　包括BSS段的数据段。BSS段存储未初始化的
C语言数据存储区
ABCisCOOL的博客
04-07 1628
Make a little progress every day.
java运行时数据区
zhouzhou_98的博客
05-21 327
java运行时数据区 每个线程都有PC/VMS/NMS,这些都是私有的，只有堆和方法区是公共的。 Runtime Data Area PC 程序计数器 存放指令位置 虚拟机的运行，类似于这样的循环： while( not end ) { ​ 取PC中的位置，找到对应位置的指令； ​ 执行该指令； ​ PC ++; } JVM Stack Frame - 每个方法对应一个栈帧 Local Variable Table Operand Stack对于...
BSS段，代码段，堆（heap），栈(stack)
大学学习ing
04-19 965
BSS段：BSS段（bss segment）通常是指用来存放程序中未初始化的全局变量的一块内存区域。BSS是英文Block Started by Symbol的简称。BSS段属于静态内存分配。数据段：数据段（data segment）通常是指用来存放程序中已初始化的全局变量的一块内存区域。数据段属于静态内存分配。代码段：代码段（code segment/text segment）通常是指用
Linux进程栈区、堆区、数据区、程序区
chenkaifang的博客
07-20 1796
1、内存映射 堆区 栈区 程序区 数据区 函数参数从右向左入栈 栈溢出原理：栈中保存的局部变量缓冲区发生溢出，导致栈中其它存储单元内容被重写。导致溢出的常用函数strcpy、memcpy 1>栈区：主要用来存放局部变量, 传递参数, 存放函数的返回地址。.esp 始终指向栈顶, 栈中的数据越多, esp的值越小。 2>堆区：用于存放动态分配的对象, 当你使用 ...
堆、栈、程序区、静态数据区、字符常量区的介绍与区别
qq_36802648的博客
03-18 1175
http://blog.csdn.net/razilfelix/article/details/53609571自己总结一下关于内存分区的基础知识：        先上图：    在VS测试中发现，字符常量区（只读数据区）在编译时候与静态数据区放在了一起。因此在静态数据区的几种类型没有独立的地址区域，都是按照定义的时间顺序进行分配。而动态内存区不同，堆和栈有独立的地址区域，具体介绍可以看下文。1、...
栈区,堆区,全局区：内存结构图
豆子的collection
04-20 1万+
#include  int main(){ int a[1000000];//局部变量 return 0; } 编译运行后发现溢出错误。 #include  int a[1000000];//全局变量 int main(){ return 0; } 编译运行后正常。 在解释原因前我们先看一下一个由C/C++编译的程序占用的内存分为几个部分： 1、 栈区
常见网络端口及其服务
热门推荐
煜铭2011
06-15 7万+
# tcpmux 1/tcp 0.001995 # TCP Port Service Multiplexer [rfc-1078] tcpmux 1/udp 0.001236 # TCP Port Service Multiplexer compressnet 2/tcp 0.000013 # Management Utility compressnet 2/udp 0.001845 # Mana
运行时数据区
the_same_dream的博客
03-09 747
运行时数据区主要分为五部分， 第一部分：程序计数器，可以看做是当前线程所执行字节码的行号知识器，线程私有； 第二部分：java虚拟机栈，描述的是java方法执行的线程模型，每个方法被执行时都会同步创建一个栈帧，用于存储局部变量表、动态连接、方法出口、操作数栈等信息。其中局部变量表用于存储编译期已知的基本数据类型、引用类型（reference类型，并不代表对象自身，可能是一个指向该对象起始内存地址的引用指针，也可能是一个指向该对象的句柄或其他和此对象相关的位置）和retrunAddress类型，...
1.GC垃圾回收1
最新发布
08-03
1.程序计数器 2.虚拟机栈 3.本地方法栈 5.方法区 6.运行时常量池 7.直接内存 8.对象访问 1.引用计数法

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值