【从零开始学JVM】第三章_运行时数据区

第三章_运行时数据区

1.介绍

1.1整体结构

这些运行时数据区，有一些会随着虚拟机启动而创建，随着虚拟机退出而销毁，另一些与线程一一对应，随着线程开始和结束而创建和销毁

如上图所示：灰色为线程私有，红色为多个线程共享

每个线程：独立包括程序计数器，虚拟机栈，本地栈
线程间共享：堆，堆外内存（永久代或元空间，代码缓存）

程序计数器：程序计数器是一块较小的内存空间，它可以看做是当前线程所执行的字节码的行号指示器。

虚拟机栈：虚拟机栈是Java方法执行的内存模型，每个线程在执行Java方法时都会创建一个==栈帧 ==，用于存储局部变量、操作数栈、动态链接、方法出口等信息。每个方法在执行时都会创建一个栈帧，并将其压入虚拟机栈顶。当方法执行完毕后，对应的栈帧会被弹出，控制权会回到上一个栈帧。

本地方法栈：本地方法栈与虚拟机栈类似，但是它是为Native方法服务的。Native方法是指使用其他语言（如C或C++）编写的方法，它们需要使用本地方法栈来管理参数和局部变量。

堆：堆是Java虚拟机管理的内存中最大的一块。所有的对象和数组都在堆上分配。当对象不再被引用时，垃圾回收器会自动回收它所占用的内存。

方法区：方法区用于存储已加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。它是所有线程共享的内存区域，通常被称为"永久代"，但在JDK8之后，永久代已经被移除，被Metaspace取代。

运行时常量池：运行时常量池是方法区的一部分，用于存储编译期生成的各种字面量和符号引用。在运行时，Java虚拟机可以将一些常量从class文件中加载到运行时常量池中，并且可以通过ldc指令从常量池中获取常量的值。

1.2详细架构

1.3Runtime---运行时环境

Runtime 类表示==应用程序的运行时环境==，它允许应用程序与其运行时环境进行交互。

每个JVM只有一个Runtime实例，即运行时环境

通过 Runtime 类，Java应用程序可以执行系统级操作，如调用外部程序、获取系统信息、管理进程等
Runtime类的常用方法：

getRuntime()：静态方法，返回当前应用程序的 Runtime 对象实例。

exec(String command)：执行指定的命令，并返回一个 Process 对象，可以用来控制和监视进程。

totalMemory()：返回JVM的总内存量。

freeMemory()：返回JVM的空闲内存量。

maxMemory()：返回JVM试图使用的最大内存量。

gc()：运行垃圾回收器。

1.4线程

线程可以看作是程序执行的最小单位，JVM允许多个线程并行执行，它负责执行程序中的指令，执行过程中需要访问共享数据。

线程在Java虚拟机中的实现是基于操作系统提供的线程实现的，每个Java线程都会被映射到一个操作系统的本地线程上。

2.1 当一个Java线程准备好执行时，也就是调用了start()方法后，操作系统会为该线程创建一个本地线程，并将其调度到可用的CPU上执行。本地线程会负责执行Java线程中的run()方法内的代码。

2.2 当Java线程执行完毕或被终止时，对应的本地线程也会被回收，释放相关资源。

2.3 好处：（1）Java线程的创建和执行可以直接利用操作系统的线程调度机制，提高了并发性能和效率

（2）java线程可以与操作系统无缝交互，使得Java程序能够充分利用底层系统资源。

注意：Java线程与本地线程之间的映射并非一对一的关系，一个Java线程可能对应多个本地线程，这取决于操作系统和JVM的实现方式

1.4.1JVM的系统线程

JVM（Java虚拟机）在运行时会启动多个系统线程来执行不同的任务，这些系统线程主要用于支持JVM的运行和管理。

主线程（Main Thread） ：即入口线程，是Java应用程序启动时的主线程，负责执行main()方法以及初始化应用程序的各项资源。（除了这个，下面四个均为后台线程）

虚拟机线程（VM Thread）：负责执行JVM的一些特殊任务，如类加载、异常处理等。

编译线程（Compiler Threads）：负责将Java字节码编译成本地机器码，以提高程序的执行效率。编译线程包括即时编译器（Just-In-Time Compiler，JIT）线程和预编译器线程等。

垃圾回收线程（Garbage Collection Threads）：负责执行垃圾回收操作，包括标记、清除、整理等工作。垃圾回收线程通常有多个，可以同时进行垃圾回收操作，提高效率。

定时器线程（Timer Thread） ：负责执行定时任务，如java.util.Timer类中的定时任务。

2.程序计数器（PC寄存器）

2.1介绍

JVM的程序计数寄存器（Program Counter Register）中，Register的命名源于CPU的寄存器，但他并非广义上所指的物理寄存器，或许将其翻译为==PC计算器（或指令计算器）==会更加贴切（也称程序的钩子）。JVM中的PC寄存器是对物理PC寄存器的一种抽象模拟

他是一块很小的内存空间，几乎可以忽略不急。也是运行速度最快的存储区域

在JVM规范中，每个线程都有他自己的程序计数器，是线程私有的，生命周期与线程的生命周期保持一致

任何时间一个线程都只有一个方法在执行，也就是所谓的当前方法。程序计数器会存储当前线程正在执行的java方法的JVM指令地址的下一条指令的地址；如果是在执行naive方法，则是未指定值（undefind）

他是查程序控制流的指示器，分支、循环、跳转、异常处理、线程恢复等基础功能都需要依赖这个计数器来完成

字节码解释器工作时就是通过改变这个计数器的值来选取下一条需要执行的字节码指令

2.2作用

字节码指令的跟踪：用来 存储指向下一条指令的地址 ，也即将要执行的指令代码。由执行引擎读取下一条指令
线程切换的恢复点：线程之间独立，当线程切换时，JVM可以通过程序计数器的值来恢复线程的执行位置，确保线程能够从正确的地方继续执行。
异常处理的准备：：在Java程序中，当发生异常时，JVM会根据异常处理表（Exception Table）中的信息确定要跳转到哪个异常处理代码块。程序计数器记录了当前异常处理的起始地址，以便JVM能够正确地定位异常处理代码块。

2.3举例

指令地址：指字节码中每条指令的位置或索引

在Java虚拟机执行字节码时，它会逐条读取指令并按顺序执行。

Java虚拟机使用一个称为程序计数器（Program Counter）的特殊变量来记录指令地址。程序计数器存储的是下一条将要执行的指令在字节码中的偏移量。

注意：指令地址是相对于字节码起始位置的偏移量，而不是绝对的内存地址。

例如，如果我们有一段字节码序列，其中包含多条指令，那么程序计数器的值会随着指令的执行而递增。初始时，程序计数器的值为0，表示将要执行的是字节码的第一条指令。执行完第一条指令后，程序计数器的值会增加到下一条指令的偏移量，以此类推。

java 复制代码

public class PCRegisterTest {

    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);

    }
}

以上代码生成对应的字节码文件，流程，如下图：

刚开始，程序计数器的值为0，则执行字节码的第一条指令：bipush 10（执行引擎会根据程序计数器的值去局部变量表中取出来具体的指令内容，再去操作我们栈结构中的局部变量表、操作数栈实现数据的存储，再将字节码指令翻译成机器指令，最后让CPU做运算即可）；会执行完毕后，程序计数器的值更新为2（下一条指令的地址，即基于起始位置的偏移量）

以此类推

2.4常见问题

2.4.1PC存储字节码指令的作用？

字节码指令的跟踪

线程切换的恢复点

2.4.2PC寄存器为什么是私有的？

我们都知道所谓的多线程在一个特定的时间段内只会执行其中某一个线程的方法，CPU会不停的做任务切换，这样必然导致经常终断或恢复，如何保证分毫无差？为了能够准确地记录各个线程正在执行的当前字节码指令地址，最好的办法自然是为每一个线程都分配一个PC寄存器，这样一来各个线程之间便可以进行独立计算，从而不会出现相互干扰的情况

3.虚拟机栈

3.1介绍

java虚拟机栈（java virtual machine stack），早期也叫java栈。每个线程在创建时都会创建一个虚拟机栈，去内部保存一个个的栈帧，对应着一次次的java方法调用。

是线程私有的

生命周期：与线程一致

特点

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

JVM直接对java栈的操作只有两个：
每个方法执行，伴随着进栈
执行结束后出栈

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

3.2作用

主管java程序的运行

保存方法的局部变量（8种基本数据类型，对象的引用地址）、部分结果，并参与方法的调用和返回

3.3可能出现的异常

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

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

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

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

java 复制代码

/**
 *
 *  默认情况下：count : 11420
 *  设置栈的大小： -Xss256k : count : 2465
 */
public class StackErrorTest {
    private static int count = 1;
    public static void main(String[] args) {
        System.out.println(count);
        count++;
        main(args);
    }

}

3.4栈的单位

每个线程都有自己的栈，栈中的数据都是以栈帧的格式存在的。

在这个线程上正在执行的**每个方法都各自对应一个栈帧**

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

3.5栈的运行原理

JVM直接对java栈的操作只有两个，对栈帧的压栈和出栈，遵循"先进后出/后出先进"原则

在一条活动线程中，一个时间点上，只会有一个活动的栈帧。即当前正在执行的方法的栈帧是有效的，被称为==当前栈帧 （Current Frame），与当前栈帧对应的方法就是当前方法 ，定义这个方法的类就是当前类==

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

如果在该方法中调用其他方法，对应的新的栈帧会被创建，放在栈顶，成为新的当前帧

不同线程中所包含的栈帧不允许存在相互引用。

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

java方法有两种返回函数的方式：一种是正常的函数返回，使用retrun指令；另外一种是抛出异常。不管使用那种方式，都会导致栈帧被弹出。

3.6栈帧的内部结构

每个栈帧中存储着：

局部变量表（Local Variables）

操作数栈（Operand Stack）（或表达式栈）

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

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

一些附加信息
后三者有些地方统称为帧数据区

3.6.1局部变量表

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

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

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

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

方法嵌套调用的次数由栈的大小决定，栈越大，调用次数越多。参数和局部变量越多，栈帧越大，调用次数也少。

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

按照数据类型分：① 基本数据类型 ② 引用数据类型

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

① 成员变量：在使用前，都经历过默认初始化赋值
类变量： linking的prepare阶段：给类变量默认赋值 ---> initial阶段：给类变量显式赋值即静态代码块赋值
实例变量：随着对象的创建，会在堆空间中分配实例变量空间，并进行默认赋值

② 局部变量：在使用前，必须要进行显式赋值的！否则，编译不通过

3.6.2操作数栈

操作数栈，在方法执行过程中，根据字节码指令，往栈中写数据或提取数据，即入栈和出栈

主要用于==保存计算过程的中间结果，同时作为计算过程中变量临时的存储空间==

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

每个操作数栈有明确的栈深度用于存储数值，最大深度在编译期就定义好了

栈中的任何一个元素可以是任意的java数据类型，32bit一个栈深度，64bit两个栈深度

操作数栈并非采用访问索引的方式来进行数据访问的，而是入栈和出栈操作来完成（虽然底层是数组）

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

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

java虚拟机的解释引擎是基于栈的执行引擎，其中==栈指的是操作数栈==

3.6.3动态链接---指向运行时常量池的方法引用

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

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

3.6.4方法返回地址

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

方法结束两种方式：1. 正常执行完成 2. 出现未处理异常，非正常退出

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

3.6.5一些附加信息

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

3.7面试题

举例栈溢出的情况？（StackOverflowError）

通过-Xss设置栈的大小

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

不能，只能延迟溢出的出现，不能保证你的代码在溢出出现之前就能完成，可能出现溢出

分配的栈内存越大越好吗？

不是，就栈来说可以延迟溢出出现，有益，但对内存中其他结构来说，挤占了他们的空间，无益

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

不会，只存在入栈和出栈操作，出栈已经相当于销毁了

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

具体问题具体分析

java 复制代码

  /**
   * 面试题：
   * 方法中定义的局部变量是否线程安全？具体情况具体分析
   *
   *   何为线程安全？
   *      如果只有一个线程才可以操作此数据，则必是线程安全的。
   *      如果有多个线程操作此数据，则此数据是共享数据。如果不考虑同步机制的话，会存在线程安全问题。
   */
  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的操作：是线程不安全的
      public static StringBuilder method3(){
          StringBuilder s1 = new StringBuilder();
          s1.append("a");
          s1.append("b");
          return 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);
  
      }
  
  }