从JAVA字节码到JVM逻辑内存模型

作者: Kay_Coding | 来源:发表于2018-12-28 21:13 被阅读0次

从JAVA字节码到JVM逻辑内存模型
jvm浅析
JVM内存模型及JIT运行优化
JVM综述
Jvm虚拟机原理分析性能调优
系统架构师-jVM调优学习笔记
Tomcat 类加载机制
大厂面试系列(一):：JVM基础
基础篇：JVM运行时内存布局
JVM

图片来源
本文将简单介绍java的字节码文件以及初步探索java内存模型，我会假定您的电脑上已经安装并配置好JDK，在命令行窗口下输入java -version显示如下信息：

D:\>java -version
java version "1.8.0_181"
Java(TM) SE Runtime Environment (build 1.8.0_181-b13)
Java HotSpot(TM) 64-Bit Server VM (build 25.181-b13, mixed mode)

阅读java字节码文件

首先，我们从一个简单的用例ClassDemo.java开始，类内容如下：

public class ClassDemo {
    public static void main(String[] args) {
        int a = 1;
        int b = 2;
        int c = 1 + 2;
        int d = 3;
        System.out.println(c + d);
    }
}

在ClassDemo.java文件的路径下编译并执行该类，注意执行java命令运行class文件时不需要后缀，否则报错。如下：

D:\>javac ClassDemo.java

D:\>java ClassDemo.class
错误: 找不到或无法加载主类 ClassDemo.class

D:\>java ClassDemo
6

编译后的文件ClassDemo.class文件用UE直接打开内容如下，文件开头是一个0xcafebabe```16进制特殊标志（魔数），文件内容我们无法阅读：

直接打开.class文件

我们需要对class文件进行反编译，使用javap -v命令将class文件反编译并输出到ClassDemo.txt中：

D:\>javap -v ClassDemo.class > ClassDemo.txt

打开ClassDemo.txt就可以看到反编译后的class文件指令集：

Classfile /D:/ClassDemo.class
  Last modified 2018-12-28; size 416 bytes
  MD5 checksum 8fc0289dea72a11671d7a74bdb62a225
  Compiled from "ClassDemo.java"
public class ClassDemo
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Methodref          #5.#14         // java/lang/Object."<init>":()V
   #2 = Fieldref           #15.#16        // java/lang/System.out:Ljava/io/PrintStream;
   #3 = Methodref          #17.#18        // java/io/PrintStream.println:(I)V
   #4 = Class              #19            // ClassDemo
   #5 = Class              #20            // java/lang/Object
   #6 = Utf8               <init>
   #7 = Utf8               ()V
   #8 = Utf8               Code
   #9 = Utf8               LineNumberTable
  #10 = Utf8               main
  #11 = Utf8               ([Ljava/lang/String;)V
  #12 = Utf8               SourceFile
  #13 = Utf8               ClassDemo.java
  #14 = NameAndType        #6:#7          // "<init>":()V
  #15 = Class              #21            // java/lang/System
  #16 = NameAndType        #22:#23        // out:Ljava/io/PrintStream;
  #17 = Class              #24            // java/io/PrintStream
  #18 = NameAndType        #25:#26        // println:(I)V
  #19 = Utf8               ClassDemo
  #20 = Utf8               java/lang/Object
  #21 = Utf8               java/lang/System
  #22 = Utf8               out
  #23 = Utf8               Ljava/io/PrintStream;
  #24 = Utf8               java/io/PrintStream
  #25 = Utf8               println
  #26 = Utf8               (I)V
{
  public ClassDemo();
    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 1: 0

  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=3, locals=5, args_size=1
         0: iconst_1
         1: istore_1
         2: iconst_2
         3: istore_2
         4: iconst_3
         5: istore_3
         6: iconst_3
         7: istore        4
         9: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
        12: iload_3
        13: iload         4
        15: iadd
        16: invokevirtual #3                  // Method java/io/PrintStream.println:(I)V
        19: return
      LineNumberTable:
        line 3: 0
        line 4: 2
        line 5: 4
        line 6: 6
        line 7: 9
        line 8: 19
}
SourceFile: "ClassDemo.java"

class文件是交给JVM阅读并解释执行的，其中包括：java版本、访问标志、常量池、当前类、超类、接口、字段、方法、属性。

JVM逻辑内存模型

接下来我们先看看JVM中内存的主要逻辑划分，然后结合class字节码文件理解JVM各内存区域存储的具体内容。

jvm逻辑内存模型

线程共享内存区域

所有线程都能访问这块内存空间，随虚拟机或者GC而创建和销毁。

方法区(Method Area，非堆Non-Heap)：JVM用来存储已加载的类信息、常量、静态变量、即时编译器编译后的代码等数据，虚拟机规范中这是一个逻辑区域。具体实现根据不同虚拟机来实现，如：oracle的HotSpot在java7中方法区放在永久代，java8放在元数据空间，并且通过GC机制对这个区域进行管理，回收主要目标是针对常量池的回收和对类型的卸载。

运行时常量池（Runtime Constant Pool）是方法区的一部分。Class 文件中除了有类的版本、字段、方法、接口等描述等信息外，还有一项信息是常量池（Constant Pool Table），用于存放编译期生成的各种字面量和符号引用，这部分内容将在类加载后存放到方法区的运行时常量池中。运行期间也可能将新的常量放入池中，这种特性被开发人员利用得比较多的便是：String类的intern()方法。

堆内存（也称"GC"堆，Garbage Collected Heap）：所有的对象实例以及数组都要在堆上分配，但是随着JIT 编译器的发展与逃逸分析技术的逐渐成熟，栈上分配、标量替换优化技术将会导致一些微妙的变化发生，所有的对象都分配在堆上也渐渐变得不是那么“绝对”了。由jvm自动垃圾回收器来管理。

线程私有内存区域

每个线程都会有独立的内存空间，随线程生命周期而创建和销毁。

虚拟机栈(Java Virtual Machine Stacks)：线程栈由多个栈帧(Stack Frame)组成。一个线程会执行一个或多个方法，一个方法对应一个栈帧。栈帧内容包括：局部变量表、操作栈、动态链接、方法返回地址、附加信息等。每一个方法被调用直至执行完成的过程，就对应着一个栈帧在虚拟机栈中从入栈到出栈的过程。
如果线程请求的栈深度大于虚拟机所允许的深度，将抛出StackOverflowError 异常；如果虚拟机栈可以动态扩展，当扩展时无法申请到足够的内存时会抛出OutOfMemoryError 异常。

局部变量包括：基本数据类型(boolean、byte、char、short、int、float、long、double)、对象引用reference类型和returnAddress类型。

程序计数器(Program Counter Register)：它的作用可以看做是当前线程所执行的字节码的行号指示器，字节码解释器工作时就是通过改变这个计数器的值来选取下一条需要执行的字节码指令，分支、循环、跳转、异常处理、线程恢复等功能都依赖于此。
每个线程都有一个私有的程序计数器空间，占用很少的内存空间。
执行java方法时，计数器记录的是正在执行的虚拟机字节码指令的地址；如果执行Native方法，则计数器值为空(Undefined)。
CPU同一时间，只会执行一条线程中的指令。JVM会在多线程间轮流切换并使用CPU分配的执行时间。线程切换后，需要通过程序计数器来恢复正确的执行位置。
此内存区域是唯一一个在Java虚拟机规范中没有规定任何OutOfMemoryError情况的区域。
本地方法栈(Native Method Stacks)；与虚拟机栈作用类似，服务于Native方法，同时也会抛出：StackOverflowError和OutOfMemoryError异常。

字节码文件分析

接下来，我们分析一下反编译的ClassDemo.txt文件内容的具体含义。

字节码中的类信息

public class ClassDemo
  minor version: 0                                      //次版本号
  major version: 52                                     //主版本号
  flags: ACC_PUBLIC, ACC_SUPER                          //访问标志

版本号规则：

JDK版本	字节码中的主版本号
JDK1.2	0x002E = 46
JDK1.3	0x002F = 47
JDK1.4	0x0030 = 48
JDK5	0x0031 = 49
JDK6	0x0032 = 50
JDK7	0x0033 = 51
JDK8	0x0034 = 52

访问标志规则：

访问标志

字节码中的常量池信息

Constant pool:
   #1 = Methodref          #5.#14         // java/lang/Object."<init>":()V
   #2 = Fieldref           #15.#16      // java/lang/System.out:Ljava/io/PrintStream;
   #3 = Methodref          #17.#18        // java/io/PrintStream.println:(I)V
   #4 = Class              #19            // ClassDemo
   #5 = Class              #20            // java/lang/Object
   #6 = Utf8               <init>
   #7 = Utf8               ()V
   #8 = Utf8               Code
   #9 = Utf8               LineNumberTable
  #10 = Utf8               main
  #11 = Utf8               ([Ljava/lang/String;)V
  #12 = Utf8               SourceFile
  #13 = Utf8               ClassDemo.java
  #14 = NameAndType        #6:#7          // "<init>":()V
  #15 = Class              #21            // java/lang/System
  #16 = NameAndType        #22:#23        // out:Ljava/io/PrintStream;
  #17 = Class              #24            // java/io/PrintStream
  #18 = NameAndType        #25:#26        // println:(I)V
  #19 = Utf8               ClassDemo
  #20 = Utf8               java/lang/Object
  #21 = Utf8               java/lang/System
  #22 = Utf8               out
  #23 = Utf8               Ljava/io/PrintStream;
  #24 = Utf8               java/io/PrintStream
  #25 = Utf8               println
  #26 = Utf8               (I)V

常量池规则
字节码中<init>表示构造函数，而()V的解释如下：

【引用】在JVM规范中，每个变量/字段都有描述信息，描述信息主要的作用是是描述字段的数据类型、方法的参数信息（包括数量、类型与顺序）与返回值，根据描述符规则，基本数据类型和代表无返回值的void类型都用一个大写字符来表示，对象类型则使用字符L加对象的全限定名称来表示，为了压缩字节码文件的体积，对于基本数据类型，JVM都只使用一个大写字母来表示，如下所示：B -> byte、C -> char、D -> double、F -> float、I -> int、J -> long【由于L被其它数据类型给占用了所以用J来表示】、S -> short、Z -> boolean【由于B已经被前面的byte类型所占用】、V -> void、 L -> 对象类型，如Ljava/lang/String;
对于数组类型来说，每一个维度使用一个前置的“[”来表示，如int[]被记录为[I、String[][]被记录为[[Ljava/lang/String。
用描述符描述方法时，按照先参数列表，后返回值的顺序来描述。参数列表按照参数的严格顺序放在一组（）之内，如方法：
String getRealNamebyIdAndNickName(int id, String name)的描述符为：(I, Ljava/lang/String) Ljava/lang/String;

字节码中的构造函数信息

public ClassDemo();
    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 1: 0

由于没有显示的申明构造函数，此处的默认的无参构造函数。
descrptor：方法入参和返回描述
flags：访问控制。
stack：方法对应栈帧中的操作数栈的深度
locals：本地变量数量
args_size：参数数量

其中无参构造器但是args_size=1是因为无参构造器和非静态方法调用会默认传入this变量参数，其中aload_0即表示的this，stack=1,locals=1同理。

invokespecial:调用一个初始化方法，私有方法或者父类的方法。
invokestatic:调用静态方法
invokevirtual:调用实例方法

【引用】LineNumberTable:为调试器提供源码中的每一行对应的字节码信息。即源码与指令集的对应关系。

字节码中的方法信息

public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=3, locals=5, args_size=1
         0: iconst_1
         1: istore_1
         2: iconst_2
         3: istore_2
         4: iconst_3
         5: istore_3
         6: iconst_3
         7: istore        4
         9: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
        12: iload_3
        13: iload         4
        15: iadd
        16: invokevirtual #3                  // Method java/io/PrintStream.println:(I)V
        19: return
      LineNumberTable:
        line 3: 0
        line 4: 2
        line 5: 4
        line 6: 6
        line 7: 9
        line 8: 19

内存溢出示例

下面是三个内存溢出和堆栈溢出的示例，增加对内存模型的理解。

代码

import java.util.List;
import java.util.ArrayList;

public class HeapOOMTest {
    public static void main(String[] args) {
        List<Object> list = new ArrayList<Object>();
        while(true) {
            list.add(new Object());
        }
    }
}

输入输出：

D:\>javac HeapOOMTest.java

D:\>java -Xmx10M -Xms10M HeapOOMTest
Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
        at java.util.Arrays.copyOf(Unknown Source)
        at java.util.Arrays.copyOf(Unknown Source)
        at java.util.ArrayList.grow(Unknown Source)
        at java.util.ArrayList.ensureExplicitCapacity(Unknown Source)
        at java.util.ArrayList.ensureCapacityInternal(Unknown Source)
        at java.util.ArrayList.add(Unknown Source)
        at HeapOOMTest.main(HeapOOMTest.java:8)

代码

public class StackOverflowTest {
    public static void main(String[] args) {
        recursion();
    }
    
    public static void recursion() {
        recursion();    
    }
}

输入输出

D:\>javac StackOverflowTest.java

D:\>java -Xmx10M -Xms10M StackOverflowTest
Exception in thread "main" java.lang.StackOverflowError
        at StackOverflowTest.recursion(StackOverflowTest.java:8)
        at StackOverflowTest.recursion(StackOverflowTest.java:8)
        at StackOverflowTest.recursion(StackOverflowTest.java:8)
        at StackOverflowTest.recursion(StackOverflowTest.java:8)
        at StackOverflowTest.recursion(StackOverflowTest.java:8)
        at StackOverflowTest.recursion(StackOverflowTest.java:8)
        at StackOverflowTest.recursion(StackOverflowTest.java:8)
        at StackOverflowTest.recursion(StackOverflowTest.java:8)

代码

import java.util.List;
import java.util.ArrayList;

public class ConstantPoolTest {
    
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        int i = 0;
        while(true) {
            list.add(String.valueOf(i++).intern()); 
        }
    }

}

输入输出

D:\>javac ConstantPoolTest.java

D:\>java -Xmx10M -Xms10M ConstantPoolTest
Exception in thread "main" java.lang.OutOfMemoryError: GC overhead limit exceeded
        at java.lang.Integer.toString(Unknown Source)
        at java.lang.String.valueOf(Unknown Source)
        at ConstantPoolTest.main(ConstantPoolTest.java:10)