了解 JVM和JVM内存结构（JVM运行时数据区）

左手的ㄟ右手 2022-10-19 12:42 236阅读 0赞

上一篇：[Java 线程池使用详解][Java]

之前的文章中，我们大多是了解并发是怎么回事儿，怎么解决并发问题，juc给我们提供锁都有什么效果，是如何使用的。实际上，了解完前面的知识，日常的并发问题大多都可以应付了，但是，也只是停留在会用的水平上。  
至于底层是怎么实现的，这个代码到底是怎么运行的，就不是很清楚了。  
作为一名有追求的程序员，我们不仅要会用，还要知道为什么这么用，它是怎么实现的。这样，才能走的更高，看的更远。

# JVM #

**官方**参考文档：

[https://docs.oracle.com/javase/specs/jvms/se16/html/index.html][https_docs.oracle.com_javase_specs_jvms_se16_html_index.html]

首先，JVM就是 **Java虚拟机**，是一个抽象的计算机，可以通过指令集去操作不同的内存区域。

我们所编写的Java程序最终就是编译成 **.class** 字节码文件运行在Java虚拟机中的。

我们都知道 Java语言的一大特性就是**跨平台**。原因就是JVM可以在不同的操作系统中运行，而我们的程序是在JVM中运行的，所以，自然而然的我们的程序也就可以跨平台了。

大致执行过程如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1emhpcWlhbmdfMTk5Mw_size_16_color_FFFFFF_t_70]  
我们可以写个简单的例子看一下：

随便写一个简单的类，如下

public class YZQ {
        
        public static void main(String[] args) {
        
            String name = "yzq";
            name = "Xeon";
    
            System.out.println("name = " + name);
        }
    }

下面我们来用命令编译一下，然后运行看看

首先简单说一下后面用到的命令：

*  **javac** 文件名.java ： 是将java文件编译成class文件
 *  **java** 文件名（class文件） ：运行文件
 *  **javap -c** 文件名（class文件）：反汇编class文件，就是把class文件转成我们能看懂的指令

更多的命令去官方文档看：

**[https://docs.oracle.com/en/java/javase/16/docs/specs/man/index.html][https_docs.oracle.com_en_java_javase_16_docs_specs_man_index.html]**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1emhpcWlhbmdfMTk5Mw_size_16_color_FFFFFF_t_70 1]

操作步骤如下：

![在这里插入图片描述][20210711171746398.gif]

如图所示，我们先通过`javac 文件名.java` 将YZQ.java文件编译，编译结束后就多了一个`class`文件。  
然后通过`java class文件名` 命令就可以运行了。

我们来看一下class文件是啥样的。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1emhpcWlhbmdfMTk5Mw_size_16_color_FFFFFF_t_70 2]

如图所示，class文件里面都是**16进制**的数据。这玩意我们肯定看不懂，下面我们反汇编看看是什么样的。

`javap -c 文件名`

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1emhpcWlhbmdfMTk5Mw_size_16_color_FFFFFF_t_70 3]  
可以看到，我们的程序实际上就是一步一步执行的，至于这些指令的含义是什么，看官方文档即可。

**[https://docs.oracle.com/javase/specs/jvms/se16/html/jvms-2.html\#jvms-2.11][https_docs.oracle.com_javase_specs_jvms_se16_html_jvms-2.html_jvms-2.11]**

这里我们就不深究了，我们这里只需要知道从Java代码到JVM运行这个过程是什么样的就可以。

了解完Java代码运行的流程之后，我们来看看JVM的组成部分

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1emhpcWlhbmdfMTk5Mw_size_16_color_FFFFFF_t_70 4]

如图所示，主要有以下5个组成部分

<table> 
 <thead> 
  <tr> 
   <th>组成部分</th> 
   <th>作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>类加载器 （Class Loader）</td> 
   <td>加载字节码文件到内存（运行时数据区）中</td> 
  </tr> 
  <tr> 
   <td><strong>运行时数据区 （Runtime Data Area）</strong></td> 
   <td>是JVM核心的内存控件结构模型</td> 
  </tr> 
  <tr> 
   <td>执行引擎（Execution Engine）</td> 
   <td>也叫做<strong>命令解释器</strong>，将字节码文件翻译成操作系统认识的指令集去运行</td> 
  </tr> 
  <tr> 
   <td>本地方法接口 （Native Methord Interface）</td> 
   <td>Java语言和其他语言（一般是c或c++）相互调用的一种协议</td> 
  </tr> 
  <tr> 
   <td>本地方法库</td> 
   <td>Java本地方法的具体实现</td> 
  </tr> 
 </tbody> 
</table>

而我们常说的JVM内存结构，就是指JVM的运行时区域

--------------------

# JVM 内存结构 #

上面也说了，JVM 内存结构实际上就是JVM中的运行时数据区，是JVM程序在操作系统上运行时分配的内存区域。

运行时数据区主要分为5个部分，如下图  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1emhpcWlhbmdfMTk5Mw_size_16_color_FFFFFF_t_70 5]

<table> 
 <thead> 
  <tr> 
   <th>组成部分</th> 
   <th>作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>方法区</td> 
   <td><strong>线程共享</strong>，主要用来存放类信息、常量、静态变量等数据</td> 
  </tr> 
  <tr> 
   <td>堆</td> 
   <td><strong>线程共享</strong>，主要用来存放新创建的对象以及数组等数据，占用空间较大，是GC主要管理的区域</td> 
  </tr> 
  <tr> 
   <td>虚拟机栈</td> 
   <td><strong>线程私有</strong>，存放的是栈帧，每个栈帧对应一个方法</td> 
  </tr> 
  <tr> 
   <td>程序计数器</td> 
   <td><strong>线程私有</strong>，用来记录当前线程执行的指令行号，主要是为了解决线程切换的问题</td> 
  </tr> 
  <tr> 
   <td>本地方法栈</td> 
   <td><strong>线程私有</strong> 本地方法执行时所属的区域</td> 
  </tr> 
 </tbody> 
</table>

需要注意的是：

> 方法区和堆是线程**共享**的  
> 虚拟机栈和程序计数器以及本地方法栈是线程**私有**的

上面我们说到了每个线程中都会有各自的虚拟机栈、程序计数器以及本地方法栈。  
图示如下  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1emhpcWlhbmdfMTk5Mw_size_16_color_FFFFFF_t_70 6]

我们主要来看下线程内部的虚拟机栈的结构

一个栈由多个**栈帧**组成，每个方法都对应一个栈帧，栈帧中主要分为四个区域

*  局部变量表
 *  操作数栈
 *  动态链接
 *  方法出口

图示如下：  
![在这里插入图片描述][8e106a44e67d444fab77c2250121e8e0.png]

我们来看下这四个区域分别的作用是什么

<table> 
 <thead> 
  <tr> 
   <th>区域</th> 
   <th>作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>局部变量表</td> 
   <td>存放方法中的产生的局部变量，以及对象类型的引用地址</td> 
  </tr> 
  <tr> 
   <td>操作数栈</td> 
   <td>主要负责存值，取值，做运算等操作，是一个临时区域</td> 
  </tr> 
  <tr> 
   <td>动态链接</td> 
   <td>简单理解就是当前栈帧的入口位置，该位置的值存放在方法区，其他方法想要调用当前方法就可以通过入口位置信息找到该方法</td> 
  </tr> 
  <tr> 
   <td>方法出口</td> 
   <td>简单理解就是调用该方法时其他方法的执行位置，执行完毕后返回到该位置继续执行</td> 
  </tr> 
 </tbody> 
</table>

举个例子：  
有如下代码

public class TestJVM {
        
        public static void main(String[] args) {
        
            String name = "yzq";
            int sum = sum();
            System.out.println("name = " + name);
            System.out.println("sum = " + sum);
        }
        public static int sum() {
        
            int a = 10;
            int b = 20;
            int sum = a + b;
            return sum;
        }
    }

我们javap -c TestJVM 看一下, 指令如下

Compiled from "TestJVM.java"
    public class yzq.jvm.TestJVM {
        
      public yzq.jvm.TestJVM();
        Code:
           0: aload_0
           1: invokespecial #1                  // Method java/lang/Object."<init>":()V
           4: return
    
      public static void main(java.lang.String[]);
        Code:
           0: ldc           #2                  // String yzq
           2: astore_1
           3: invokestatic  #3                  // Method sum:()I
           6: istore_2
           7: getstatic     #4                  // Field java/lang/System.out:Ljava/io/PrintStream;
          10: new           #5                  // class java/lang/StringBuilder
          13: dup
          14: invokespecial #6                  // Method java/lang/StringBuilder."<init>":()V
          17: ldc           #7                  // String name =
          19: invokevirtual #8                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
          22: aload_1
          23: invokevirtual #8                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
          26: invokevirtual #9                  // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
          29: invokevirtual #10                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
          32: getstatic     #4                  // Field java/lang/System.out:Ljava/io/PrintStream;
          35: new           #5                  // class java/lang/StringBuilder
          38: dup
          39: invokespecial #6                  // Method java/lang/StringBuilder."<init>":()V
          42: ldc           #11                 // String sum =
          44: invokevirtual #8                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
          47: iload_2
          48: invokevirtual #12                 // Method java/lang/StringBuilder.append:(I)Ljava/lang/StringBuilder;
          51: invokevirtual #9                  // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
          54: invokevirtual #10                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
          57: return
    
      public static int sum();
        Code:
           0: bipush        10
           2: istore_0
           3: bipush        20
           5: istore_1
           6: iload_0
           7: iload_1
           8: iadd
           9: istore_2
          10: iload_2
          11: ireturn
    }

我们以sum方法为例，来简单看看执行的过程：

<table> 
 <thead> 
  <tr> 
   <th>指令</th> 
   <th>作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>0: bipush 10</td> 
   <td>向操作数栈中压入一个值 10</td> 
  </tr> 
  <tr> 
   <td>2: istore_0</td> 
   <td>从操作数栈中取出值10，存入局部变量表 a=10</td> 
  </tr> 
  <tr> 
   <td>3: bipush 20</td> 
   <td>向操作数栈中压入一个值 20</td> 
  </tr> 
  <tr> 
   <td>5: istore_1</td> 
   <td>从操作数栈中取出值20，存入局部变量表中 b=20</td> 
  </tr> 
  <tr> 
   <td>6: iload_0</td> 
   <td>从局部变量表中取出变量a的值 10,压入操作数栈中</td> 
  </tr> 
  <tr> 
   <td>7: iload_1</td> 
   <td>从局部变量表中取出变量b的值 20,压入操作数栈中</td> 
  </tr> 
  <tr> 
   <td>8: iadd</td> 
   <td>从操作数栈中取出最上面的两个值，分别为20和10，做加法操作，得出30 ，压入操作数栈中</td> 
  </tr> 
  <tr> 
   <td>9: istore_2</td> 
   <td>将值30从操作数栈中取出，存到局部变量表中，sum=30</td> 
  </tr> 
  <tr> 
   <td>10: iload_2</td> 
   <td>从局部变量表中取出sum的值 30</td> 
  </tr> 
  <tr> 
   <td>11: ireturn</td> 
   <td>返回int类型的数据到方法出口</td> 
  </tr> 
 </tbody> 
</table>

通过上面的步骤我们可以看到，局部变量表中就是存放当前方法产生的局部变量以及对应的值，操作数栈就是用来临时存储值，是一个入栈，出栈的过程。

一个非常简单的方法代码的执行过程就是这样。

--------------------

**如果你觉得本文对你有帮助，麻烦动动手指顶一下，可以帮助到更多的开发者，如果文中有什么错误的地方，还望指正，转载请注明转自[喻志强的博客][Link 1] ，谢谢！**

[Java]: https://blog.csdn.net/yuzhiqiang_1993/article/details/118437806?spm=1001.2014.3001.5501
[https_docs.oracle.com_javase_specs_jvms_se16_html_index.html]: https://docs.oracle.com/javase/specs/jvms/se16/html/index.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1emhpcWlhbmdfMTk5Mw_size_16_color_FFFFFF_t_70]: /images/20221005/651a017ea33f40fc86a78d5d5c7a1422.png
[https_docs.oracle.com_en_java_javase_16_docs_specs_man_index.html]: https://docs.oracle.com/en/java/javase/16/docs/specs/man/index.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1emhpcWlhbmdfMTk5Mw_size_16_color_FFFFFF_t_70 1]: /images/20221005/d1ae8d16dcc64be298729daea6a4fb7f.png
[20210711171746398.gif]: /images/20221005/dcd0e1280f5c4453bf59d6efd13e5d13.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1emhpcWlhbmdfMTk5Mw_size_16_color_FFFFFF_t_70 2]: /images/20221005/c6e25752df5148fe9b78aea48e1a5384.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1emhpcWlhbmdfMTk5Mw_size_16_color_FFFFFF_t_70 3]: /images/20221005/1464b84b4cd2485ab6802dd8143293d1.png
[https_docs.oracle.com_javase_specs_jvms_se16_html_jvms-2.html_jvms-2.11]: https://docs.oracle.com/javase/specs/jvms/se16/html/jvms-2.html#jvms-2.11
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1emhpcWlhbmdfMTk5Mw_size_16_color_FFFFFF_t_70 4]: /images/20221005/fd6d1493cdae4b71be9a7d657cfb33f6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1emhpcWlhbmdfMTk5Mw_size_16_color_FFFFFF_t_70 5]: /images/20221005/0347c9a7a9a141129425b544f3941214.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1emhpcWlhbmdfMTk5Mw_size_16_color_FFFFFF_t_70 6]: /images/20221005/de52fea6fe5748bba31690364a76f871.png
[8e106a44e67d444fab77c2250121e8e0.png]: /images/20221005/70c9d358a4274dc1b387a527253f6f3c.png
[Link 1]: https://yuzhiqiang.blog.csdn.net/