JVM内存模型

最新推荐文章于 2022-09-24 10:50:58 发布

米兰的大笨钟

最新推荐文章于 2022-09-24 10:50:58 发布

阅读量221

点赞数

分类专栏： JVM

原文链接：https://blog.csdn.net/qq_37141773/article/details/103138476

版权

JVM 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

JVM内存组成

在这里插入图片描述
JVM的内存被划分5个区域：
堆区、方法区——这两个区域的数据共享
虚拟机栈、本地方法栈、程序计数器——这三个区域的数据私有隔离，不可共享

JVM内存模型

栈区

Java虚拟机栈（Java Virtual Machine Stacks）也是线程私有的，它的生命周期与线程相同。虚拟机栈描述的是Java方法执行的内存模型：每个方法被执行的时候都会同时创建一个栈帧（Stack Frame）用于存储局部变量表、操作栈、动态链接、方法出口等信息。每一个方法被调用直至执行完成的过程，就对应着一个栈帧在虚拟机栈中从入栈到出栈的过程。
局部变量表存放了编译期可知的各种基本数据类型（boolean、byte、char、short、int、float、long、double）、对象引用（reference类型，它不等同于对象本身，根据不同的虚拟机实现，它可能是一个指向对象起始地址的引用指针，也可能指向一个代表对象的句柄或者其他与此对象相关的位置）和returnAddress类型（指向了一条字节码指令的地址）。
其中64位长度的long和double类型的数据会占用2个局部变量空间（Slot），其余的数据类型只占用1个。局部变量表所需的内存空间在编译期间完成分配，当进入一个方法时，这个方法需要在帧中分配多大的局部变量空间是完全确定的，在方法运行期间不会改变局部变量表的大小。
在Java虚拟机规范中，对这个区域规定了两种异常状况：如果线程请求的栈深度大于虚拟机所允许的深度，将抛出StackOverflowError异常；如果虚拟机栈可以动态扩展（当前大部分的Java虚拟机都可动态扩展，只不过Java虚拟机规范中也允许固定长度的虚拟机栈），当扩展时无法申请到足够的内存时会抛出OutOfMemoryError异常。

public class RamDemo {
    public static int initAge = 18;
    public static User user = new User();
    public static final String NAME = "lv";
    public int ints[] = {1,2};

    public void initUser(String name){
        int offset = 1;
        initAge = initAge + offset;
        user.setAge(initAge);
        user.setName(name);
    }

    public int compute() {
        int a = 1;
        int b = 2;
        int c = (a+b) * 10;
        return c;
    }

    public static void main(String[] args) throws FileNotFoundException {
        RamDemo ramDemo = new RamDemo();
        ramDemo.compute();
        //ramDemo.initUser(NAME);
        //System.out.println(user.toString());
    }
}

在这里插入图片描述
上述程序在执行的过程如上所示，main方法和compute方法都会产生各自的栈帧，对应存储各自运行过程中的局部变量、操作数、动态链接和方法出口。
使用javap -c RamDemo.class命令反编译将产生如下JVM指令码文件，包含类、静态变量、常量、数组、构造方法、compute()方法、main()方法、initUser()方法。

Compiled from "RamDemo.java"
public class com.uniview.jvm.demo.RamDemo {
  public static int initAge;

  public static com.uniview.jvm.demo.User user;

  public static final java.lang.String NAME;

  public int[] ints;

  public com.uniview.jvm.demo.RamDemo();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: aload_0
       5: iconst_2
       6: newarray       int
       8: dup
       9: iconst_0
      10: iconst_1
      11: iastore
      12: dup
      13: iconst_1
      14: iconst_2
      15: iastore
      16: putfield      #2                  // Field ints:[I
      19: return

  public void initUser(java.lang.String);
    Code:
       0: iconst_1
       1: istore_2
       2: getstatic     #3                  // Field initAge:I
       5: iload_2
       6: iadd
       7: putstatic     #3                  // Field initAge:I
      10: getstatic     #4                  // Field user:Lcom/uniview/jvm/demo/User;
      13: getstatic     #3                  // Field initAge:I
      16: invokevirtual #5                  // Method com/uniview/jvm/demo/User.setAge:(I)V
      19: getstatic     #4                  // Field user:Lcom/uniview/jvm/demo/User;
      22: aload_1
      23: invokevirtual #6                  // Method com/uniview/jvm/demo/User.setName:(Ljava/lang/String;)V
      26: return

  public int compute();
    Code:
       0: iconst_1
       1: istore_1
       2: iconst_2
       3: istore_2
       4: iload_1
       5: iload_2
       6: iadd
       7: bipush        10
       9: imul
      10: istore_3
      11: iload_3
      12: ireturn

  public static void main(java.lang.String[]) throws java.io.FileNotFoundException;
    Code:
       0: new           #7                  // class com/uniview/jvm/demo/RamDemo
       3: dup
       4: invokespecial #8                  // Method "<init>":()V
       7: astore_1
       8: aload_1
       9: invokevirtual #9                  // Method compute:()I
      12: pop
      13: aload_1
      14: ldc           #10                 // String lv
      16: invokevirtual #11                 // Method initUser:(Ljava/lang/String;)V
      19: getstatic     #12                 // Field java/lang/System.out:Ljava/io/PrintStream;
      22: getstatic     #4                  // Field user:Lcom/uniview/jvm/demo/User;
      25: invokevirtual #13                 // Method com/uniview/jvm/demo/User.toString:()Ljava/lang/String;
      28: invokevirtual #14                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      31: return

  static {};
    Code:
       0: bipush        18
       2: putstatic     #3                  // Field initAge:I
       5: new           #15                 // class com/uniview/jvm/demo/User
       8: dup
       9: invokespecial #16                 // Method com/uniview/jvm/demo/User."<init>":()V
      12: putstatic     #4                  // Field user:Lcom/uniview/jvm/demo/User;
      15: return
}

以compute()方法的执行为例，解析栈内存如何操作。

0: iconst_1 将int类型常量1压入操作数栈

在这里插入图片描述

1: istore_1 将int类型值存入局部变量1

在这里插入图片描述

2: iconst_2 将int类型常量2压入操作数栈

3: istore_2 将int类型值存入局部变量2

在这里插入图片描述

4: iload_1 从局部变量1中装载int类型值

5: iload_2 从局部变量2中装载int类型值

在这里插入图片描述

6: iadd 执行int类型的加法

在这里插入图片描述

7: bipush 10 将一个8位带符号整数压入栈

在这里插入图片描述

9: imul 执行int类型的乘法

在这里插入图片描述

10: istore_3 将int类型值存入局部变量3

在这里插入图片描述

11: iload_3 从局部变量3中装载int类型值

在这里插入图片描述

12: ireturn 返回int类型值

程序计数器

程序计数器（Program Counter Register）是一块较小的内存空间，它的作用可以看做是当前线程所执行的字节码的行号指示器。在虚拟机的概念模型里（仅是概念模型，各种虚拟机可能会通过一些更高效的方式去实现），字节码解释器工作时就是通过改变这个计数器的值来选取下一条需要执行的字节码指令，分支、循环、跳转、异常处理、线程恢复等基础功能都需要依赖这个计数器来完成。由于Java虚拟机的多线程是通过线程轮流切换并分配处理器执行时间的方式来实现的，在任何一个确定的时刻，一个处理器（对于多核处理器来说是一个内核）只会执行一条线程中的指令。因此，为了线程切换后能恢复到正确的执行位置，每条线程都需要有一个独立的程序计数器，各条线程之间的计数器互不影响，独立存储，我们称这类内存区域为“线程私有”的内存。如果线程正在执行的是一个Java方法，这个计数器记录的是正在执行的虚拟机字节码指令的地址；如果正在执行的是Natvie方法，这个计数器值则（Undefined）。

方法区（元数据空间）

方法区主要是存储类的元数据的，如虚拟机加载的类信息、编译后的代码等。JDK8之前方法区的实现是被称为一种“永久代”的区域，这部分区域使用JVM内存，但是JDK8的时候便移除了“永久代（Per Gen）”，转而使用“元空间（MetaSpace）”的实现，而且很大的不同就是元空间不再共用JVM内存，并将运行时常量池、静态变量也移到堆区进行存储。

本地方法栈

由于java需要与一些底层系统如操作系统或某些硬件交换信息时的情况。本地方法正是这样一种交流机制：它为我们提供了一个非常简洁的接口，而且我们无需去了解java应用之外的繁琐的细节，一个Native Method就是一个java调用非java代码的接口。方法对应的实现不是在当前文件，而是在用其他语言（如C和C++）实现的文件中。Java语言本身不能对操作系统底层进行访问和操作，但是可以通过JNI接口调用其他语言来实现对底层的访问。如果有运行到本地方法，那么必然也要产生局部变量等，那么就需要存储在本地方法栈了。如果没有本地方法，也就没有本地方法栈了。

堆区

堆区是JVM中最大一块内存区域，存储着各类生成的对象、数组等，JVM8中把运行时常量池、静态变量也移到堆区进行存储。根据Java虚拟机规范的规定，Java堆可以处于物理上不连续的内存空间中，只要逻辑上是连续的即可，就像我们的磁盘空间一样。在实现时，既可以实现成固定大小的，也可以是可扩展的，不过当前主流的虚拟机都是按照可扩展来实现的（通过-Xmx和-Xms控制）。如果在堆中没有内存完成实例分配，并且堆也无法再扩展时，将会抛出OutOfMemoryError异常。堆区被细化可以分为年轻代、老年代，老年代默认占堆内存大小的2/3，而年轻代又可分为Eden区、From Survivor、To Survivor三个区域，比例是8:1:1，如图：
在这里插入图片描述
我们new出来的对象一般都放在Eden区，如果new的是一个超大对象，无法再Eden区分配到足够的空间，将将此对象放在老年代。

HotSpot虚拟机对象

对象的内存布局

对象在内存中存储的布局可以分为3块区域：对象头（Header）、实例数据（Instance Data）和对齐填充（Padding）。下图是普通对象实例与数组对象实例的数据结构：
在这里插入图片描述
对象头

HotSpot虚拟机的对象头包括两部分信息：
Mark Word：第一部分markword,用于存储对象自身的运行时数据，如哈希码（HashCode）、GC分代年龄、锁状态标志、线程持有的锁、偏向线程ID、偏向时间戳等，这部分数据的长度在32位和64位的虚拟机（未开启压缩指针）中分别为32bit和64bit，官方称它为“MarkWord”。
Klass Pointer：对象头的另外一部分是klass类型指针，即对象指向它的类元数据的指针，虚拟机通过这个指针来确定这个对象是哪个类的实例.
数组长度（只有数组对象有）：如果对象是一个数组, 那在对象头中还必须有一块数据用于记录数组长度.

实例数据

实例数据部分是对象真正存储的有效信息，也是在程序代码中所定义的各种类型的字段内容。无论是从父类继承下来的，还是在子类中定义的，都需要记录起来。

对齐填充

第三部分对齐填充并不是必然存在的，也没有特别的含义，它仅仅起着占位符的作用。由于HotSpot VM的自动内存管理系统要求对象起始地址必须是8字节的整数倍，换句话说，就是对象的大小必须是8字节的整数倍。而对象头部分正好是8字节的倍数（1倍或者2倍），因此，当对象实例数据部分没有对齐时，就需要通过对齐填充来补全。

对象创建

在这里插入图片描述
检查类加载

虚拟机遇到一条new指令时，首先将去检查这个指令的参数是否能在常量池中定位到一个类的符号的引用，并且检查这个符号引用代表的类是否已经被加载、解析和初始化过。如果没有那必须先执行相应的类加载过程。类加载过程下一篇为大家讲解。

为新生对象分配内存

类加载检查通过后，虚拟机将为新生对象分配内存。对象所需内存的大小在类加载完成后便可以确定，为对象分配空间的任务等同于把一块确定大小的内存从java堆中划分出来。
在划分内存的时候根据内存是否是绝对规整，有两种划分形式：指针碰撞和空闲列表。Java堆是否规整由所采用的垃圾收集器是否带有压缩整理功能决定。通常使用Serial、ParNew等带Compact过程的收集器时，系统采用的分配算法是指针碰撞；使用CMS这种基于Mart-Sweep算法的收集器时，通常采用空闲列表。
（1）指针碰撞

假如Java堆内存是绝对规整的，所有用过的内存都放在一边，空闲的内存放在另一边，中间放着一个指针作为分界点的指示器，那所分配内存就仅仅是把那个指针想空闲空间那边挪动一段与对象大小相等的距离，这种分配方式成为“指针碰撞”。
（2）空闲列表

如果Java堆中的内存并不是规整的，已使用的内存和空闲的内存相互交错，这时候就没有办法使用“指针碰撞”，虚拟机就必须维护一个列表，记录上哪些内存块是可用的，在分配的时候从列表中找到一块足够大的空间划分给对象实例，并更新列表上的记录，这种分配方式成为“空闲列表”。

有了可用空间还需要考虑另一个问题：对象创建在虚拟机中是非常频繁的行为，即使是仅仅修改一个指针所指向的位置，在并发情况下也并不是线程安全的，这种情况有两种解决方案：
①并发问题–CAS

对分配内存空间的动作进行同步处理，虚拟机采用CAS配上失败重试的方式保证更新操作的原子性。

CAS：比较交换（compare and swap）是一种有名的无锁算法、CAS的工作原理：需要3个操作数，分别是内存位置（在java中可以简单理解为变量的内存地址，用V表示）、旧的预期值（用A表示）和新值（用B表示）。CAS指令执行时，当且仅当V符合旧预期值A时，处理器用新值B更新V的值，否则他就不执行更新，但是无论是否更新了V的值，都会返回V的旧值，删除的处理过程是一个原子操作。
②并发问题-TLAB

把内存分配的动作按照线程划分在不同的空间之中进行，即每个线程在java堆中预先分配一小块内存，称为本地线程缓冲（Thread Local Allocation Buffer TLAB）。哪个线程要分配内存，就在那个线程的TLAB上分配，只有TLAB用完并分配新的TLAB时，才需要同步锁定。虚拟机是否使用TLAB，可以通过-XX:+/-UseTLAB参数设定。

初始化为零值

内存分配完后，虚拟机需要将分配到的内存空间都初始化为零值（不包括对象头），如果使用TLAB，这一工作也可以提前到TLAB分配时进行。

设置对象头

接下来，虚拟机要对对象进行必要的设置，这部分信息都存放在对象的对象头之中。

执行init方法

在上面工作都完成之后，从虚拟机的视角来看，一个新的对象已经产生了，但从java程序的视角来看，对象创建才刚刚开始——方法还没有执行，所有的字段都还为零。所以，一般来说（由字节码中是否跟随invokespecial指令所决定），执行new指令之后会接着执行方法，把对象按照程序员的意愿进行初始化，这样一个真正可用的对象才算完全产生出来。

对象的访问

使用对象时，通过栈上的 reference 数据来操作堆上的具体对象。可以通过句柄访问和直接指针访问
句柄访问
Java 堆中会分配一块内存作为句柄池。reference 存储的是句柄地址。详情见图。
在这里插入图片描述
直接指针访问
reference 中直接存储对象地址

比较：使用句柄的最大好处是 reference 中存储的是稳定的句柄地址，在对象移动(GC)是只改变实例数据指针地址，reference 自身不需要修改。直接指针访问的最大好处是速度快，节省了一次指针定位的时间开销。如果是对象频繁 GC 那么句柄方法好，如果是对象频繁访问则直接指针访问好。