2021-08-17【JVM系列-1】 JVM内存结构

最新推荐文章于 2024-10-16 22:44:39 发布

mireux

最新推荐文章于 2024-10-16 22:44:39 发布

阅读量340

点赞数

分类专栏： JVM系列文章标签： jvm

本文链接：https://blog.csdn.net/qq_44455033/article/details/119768043

版权

JVM系列专栏收录该内容

4 篇文章 0 订阅

订阅专栏

【JVM系列-1】 JVM内存结构

文章目录

- 【JVM系列-1】 JVM内存结构
前言
一、什么是JVM？
二、JVM的内存结构
总结

前言

为了更好的巩固和梳理JVM知识，写下这篇文章。为了秋招而做准备。
本篇知识大部分来源《深入理解JAVA虚拟机》，有兴趣的可以自行拜读~！
还有部分内容来自B站解密JVM【黑马程序员出品】教学视频

提示：以下是本篇文章正文内容，下面案例可供参考
提示：所有的JVM文章的虚拟机都是HotSpot虚拟机

一、什么是JVM？

JVM是Java Virtual Machine（Java虚拟机）的缩写，引入Java语言虚拟机后，Java语言在不同平台上运行时不需要重新编译。Java语言使用Java虚拟机屏蔽了与具体平台相关的信息，使得Java语言编译程序只需生成在Java虚拟机上运行的目标代码（字节码），就可以在多种平台上不加修改地运行。也就是“一次编译，到处运行”的理念。

二、JVM的内存结构

JVM内存结构图
JVM的内存结构主要由五个部分组成：方法区(Method Area)、堆(Heap)、虚拟机栈(JVM Stack)、本地方法栈(Native Method Stack)、程序计数器(PC Register)。

1.程序计数器(PC Register)

程序计数器是一块较小的的内存空间。它可以看作是当前线程所执行的字节码的行号指示器。
作用：
程序计数器最大的作用就是记住下一条JVM指令的执行地址。用寄存器存放。字节码通过改变整个计数器的值来选取下一条执行的字节码指令。分支、循环、跳转、控制、异常处理、线程恢复等基础功能都需要依赖整个计数器来完成。
程序计数器的特点：

线程是私有的
是所有区域中唯一一个没有Out Of Memory Error（OOM）错误的区域。

2.Java虚拟机栈(JVM Stack)

虚拟机栈的生命周期与线程同步。线程创建，虚拟机栈就创建；线程死亡，虚拟机栈就死亡。虚拟机栈描述的是Java方法执行的线程内存模型：每个方法被执行的时候，Java虚拟机都会同步创建一个栈帧（stack frame）用于存储局部变量表、操作数栈、动态链接、方法出口等信息。每一个方法被调用直至执行完毕的过程，相当于一个栈帧在虚拟机栈中从入栈到出栈的过程。每个线程只能有1个活动栈帧，对应着当前执行哪个方法。
局部变量表：
存放了编译期可知的各种Java虚拟机基本数据类型（boolean、byte、char、short、int、float、long、double）、对象引用（reference类型，并不等同于对象本身，可能是一个指向对象起始地址的引用指针，也可能是指向一个代表对象的句柄或者其他于此对象相关的位置）和returnAddress类型（指向了一条字节码指令）。
这些数据类型在局部变量表中的存储空间以局部变量槽(slot)来表示。其中64位长度的long和double类型的数据会占用2两个变量槽，其余的数据类型只占1个。局部变量表所需要的空间在编译期已经确定，方法运行期间完全不会改变大小（这里指的是槽的大小，而一个变量槽到底多大，完全由具体的JVM虚拟机实现）。
栈内存溢出

栈帧过多或者栈帧过大，会抛出StackOverflowError
JVM容量可以动态伸展，当栈扩展到无法申请到足够的内存时会抛出OOM异常。
虚拟机栈也是线程私有的。

3.本地方法栈(Native Method Stack)

本地方法栈和虚拟机栈相似，区别只是为本地方法接口（c\c++）提供内存空间。是线程私有的。
栈内存溢出
与虚拟机栈相同，本地方法栈也会在栈深度溢出或者栈扩展失败时分别抛出StackOverflowError和OOM异常。

4.Java堆(Heap)

Java堆是虚拟机所管理的内存中最大的一块。堆是被线程共享的，在虚拟机启动时创建。Java中几乎所有的对象实例都在堆中分配内存。Java堆也是垃圾回收器管理的内存区域（关于垃圾回收器下一篇文章会细讲）。
Java堆可以处于物理上不连续的内存空间，但在逻辑上必须是连续的。堆既可以被实现成固定大小，也可以是扩展的，不过当前主流的虚拟机都是按照可拓展来实现的（通过参数-Xmx和-Xms设定）。如果在Java堆中没有内存完成实力分配，并且堆无法在扩展，Java将抛出OOM异常。

5.方法区(Method Area)

方法区和Java堆一样，是线程共享的区域，它用于存储已被虚拟机编译加载的类型信息、常量、静态变量、即时编译器编译后的代码缓存等数据。在虚拟机启动时创建。逻辑上是堆的组成部分。
在JDK7之前，JVM使用永久代来实现方法去。JDK7之后，已经把原来放在永久代的字符串常量池、静态变量等移出；而到了JDK8，正式废弃永久代的概念，改用元空间，把JDK7中还剩余的内容（主要是类型信息）全部移到元空间中。
实际上《Java虚拟机规范》对方法区的约束是非常宽松的，除了和Java堆一样不需要连续的内存和可以选择固定大小或者可拓展外，甚至可以不需要实现垃圾分类。相对而言，方法区的垃圾回收较少，主要是针对常量池的回收和对类型的卸载。一般来说效果都比较让人满意。
如果方法区无法满足新的内存分配需求时，将抛出OOM异常。
在这里插入图片描述

5.2 运行时常量池

运行时常量池（Runtime Constant Pool）是方法区的一部分。Class文件中除了有类的版本、字段、方法、接口等描述信息外，还有一项信息就是常量池表。用于存放编译期间生成的各种字面量与符号引用。这部分内容将在类加载后存放到方法区的运行时常量池中。
运行时常量池想读与Class文件常量池的另外一个重要特性就是具备动态性，Java语言并不要求常量一定只有编译期才能产生，也就是说，并非预置入Class文件中常量池的内容才能进入方法区运行时常量池，运行期间也可以将新的常量放入池中。譬如String类的intern()方法。
当常量池无法再申请到内存时会抛出OOM异常。

5.3 StringTable

以下的所有案例的为JDK8

用来放字符串对象且里面的元素不重复

public class StringTableStudy {
	public static void main(String[] args) {
		String a = "a"; 
		String b = "b";
		String ab = "ab";
	}
}

常量池中的信息，都会被加载到运行时常量池中，但这是a b ab 仅是常量池中的符号，还没有成为java字符串

0: ldc           #2                  // String a
2: astore_1
3: ldc           #3                  // String b
5: astore_2
6: ldc           #4                  // String ab
8: astore_3
9: return

当执行到 ldc #2 时，会把符号 a 变为 “a” 字符串对象，并放入串池中（hashtable结构不可扩容）

当执行到 ldc #3 时，会把符号 b 变为 “b” 字符串对象，并放入串池中

当执行到 ldc #4 时，会把符号 ab 变为 “ab” 字符串对象，并放入串池中

最终StringTable [“a”, “b”, “ab”]

注意：字符串对象的创建都是懒惰的，只有当运行到那一行字符串且在串池中不存在的时候（如 ldc #2）时，该字符串才会被创建并放入串池中。

使用拼接字符串变量对象创建字符串的过程

public class StringTableStudy {
	public static void main(String[] args) {
		String a = "a";
		String b = "b";
		String ab = "ab";
		//拼接字符串对象来创建新的字符串
		String ab2 = a+b; 
	}
}

反编译后的结果


	 Code:
      stack=2, locals=5, args_size=1
         0: ldc           #2                  // String a
         2: astore_1
         3: ldc           #3                  // String b
         5: astore_2
         6: ldc           #4                  // String ab
         8: astore_3
         9: new           #5                  // class java/lang/StringBuilder
        12: dup
        13: invokespecial #6                  // Method java/lang/StringBuilder."<init>":()V
        16: aload_1
        17: invokevirtual #7                  // Method java/lang/StringBuilder.append:(Ljava/lang/String
;)Ljava/lang/StringBuilder;
        20: aload_2
        21: invokevirtual #7                  // Method java/lang/StringBuilder.append:(Ljava/lang/String
;)Ljava/lang/StringBuilder;
        24: invokevirtual #8                  // Method java/lang/StringBuilder.toString:()Ljava/lang/Str
ing;
        27: astore        4
        29: return

通过拼接的方式来创建字符串的过程是：StringBuilder().append(“a”).append(“b”).toString()

最后的toString方法的返回值是一个新的字符串，但字符串的值和拼接的字符串一致，但是两个不同的字符串，一个存在于串池之中，一个存在于堆内存之中

String ab = "ab";
String ab2 = a+b;
//结果为false,因为ab是存在于串池之中，ab2是由StringBuffer的toString方法所返回的一个对象，存在于堆内存之中
System.out.println(ab == ab2);

在JDK11中，底层不再是用StringBuffer,而是采用nvokeDynamic #0:makeConcatWithConstants:

 0: ldc           #2                  // String a
         2: astore_1
         3: ldc           #3                  // String b
         5: astore_2
         6: ldc           #4                  // String ab
         8: astore_3
         9: aload_1
        10: aload_2
        11: invokedynamic #5,  0              // InvokeDynamic #0:makeConcatWithConstants:(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;

使用拼接字符串常量对象的方法创建字符串

public class StringTableStudy {
	public static void main(String[] args) {
		String a = "a";
		String b = "b";
		String ab = "ab";
		String ab2 = a+b;
		//使用拼接字符串的方法创建字符串
		String ab3 = "a" + "b";
	}
}

反编译后的结果

 	  Code:
      stack=2, locals=6, args_size=1
         0: ldc           #2                  // String a
         2: astore_1
         3: ldc           #3                  // String b
         5: astore_2
         6: ldc           #4                  // String ab
         8: astore_3
         9: new           #5                  // class java/lang/StringBuilder
        12: dup
        13: invokespecial #6                  // Method java/lang/StringBuilder."<init>":()V
        16: aload_1
        17: invokevirtual #7                  // Method java/lang/StringBuilder.append:(Ljava/lang/String
;)Ljava/lang/StringBuilder;
        20: aload_2
        21: invokevirtual #7                  // Method java/lang/StringBuilder.append:(Ljava/lang/String
;)Ljava/lang/StringBuilder;
        24: invokevirtual #8                  // Method java/lang/StringBuilder.toString:()Ljava/lang/Str
ing;
        27: astore        4
        //ab3初始化时直接从串池中获取字符串
        29: ldc           #4                  // String ab
        31: astore        5
        33: return

使用拼接字符串常量的方法来创建新的字符串时，因为内容是常量，javac在编译期会进行优化，结果已在编译期确定为ab，而创建ab的时候已经在串池中放入了“ab”，所以ab3直接从串池中获取值，所以进行的操作和 ab = “ab” 一致。
使用拼接字符串变量的方法来创建新的字符串时，因为内容是变量，只能在运行期确定它的值，所以需要使用StringBuilder来创建
intern方法 1.8
调用字符串对象的intern方法，会将该字符串对象尝试放入到串池中

如果串池中没有该字符串对象，则放入成功
如果有该字符串对象，则放入失败
无论放入是否成功，都会返回串池中的字符串对象

注意：此时如果调用intern方法成功，堆内存与串池中的字符串对象是同一个对象；如果失败，则不是同一个对象

例1

public class Main {
	public static void main(String[] args) {
		//"a" "b" 被放入串池中，str则存在于堆内存之中
		String str = new String("a") + new String("b");
		//调用str的intern方法，这时串池中没有"ab"，则会将该字符串对象放入到串池中，此时堆内存与串池中的"ab"是同一个对象
		String st2 = str.intern();
		//给str3赋值，因为此时串池中已有"ab"，则直接将串池中的内容返回
		String str3 = "ab";
		//因为堆内存与串池中的"ab"是同一个对象，所以以下两条语句打印的都为true
		System.out.println(str == st2);
		System.out.println(str == str3);
	}
}

例2

public class Main {
	public static void main(String[] args) {
        //此处创建字符串对象"ab"，因为串池中还没有"ab"，所以将其放入串池中
		String str3 = "ab";
        //"a" "b" 被放入串池中，str则存在于堆内存之中
		String str = new String("a") + new String("b");
        //此时因为在创建str3时，"ab"已存在与串池中，所以放入失败，但是会返回串池中的"ab"
		String str2 = str.intern();
        //false
		System.out.println(str == str2);
        //false
		System.out.println(str == str3);
        //true
		System.out.println(str2 == str3);
	}
}

练习案例：

public static void main(String[] args) {
        String s1 = "a";
        String s2 = "b";
        String s3 = "a" + "b";
        String s4 = s1 + s2;
        String s5 = "ab";
        String s6 = s4.intern();
        System.out.println(s3 == s4);
        System.out.println(s3 == s5);
        System.out.println(s3 == s6);
        System.out.println(s4 == s6);

        String x2 = new String("c") + new String("d");
        String x1 = "cd";
        x2.intern();
        System.out.println(x1 == x2);

        String x3 = new String("e") + new String("f");
        x3.intern();
        String x4 = "ef";
        System.out.println(x4 == x3);
    }

6.直接内存

直接内存并不是虚拟机运行时数据的一部分，也不是《Java虚拟机规范》定义的内存区域。但是这部分被频繁的使用，所以放在一起。常见于NIO操作，用于数据缓冲区分配回收成本较高，但读写性能高，不受JVM内存回收管理。
文件读写流程
在这里插入图片描述
使用了直接内存

直接内存是操作系统和Java代码都可以访问的一块区域，无需将代码从系统内存复制到Java堆内存，从而提高了效率

释放原理
直接内存的回收不是通过JVM的垃圾回收来释放的，而是通过unsafe.freeMemory来手动释放

通过

//通过ByteBuffer申请1M的直接内存
ByteBuffer byteBuffer = ByteBuffer.allocateDirect(_1M);
申请直接内存，但JVM并不能回收直接内存中的内容，它是如何实现回收的呢？

allocateDirect的实现

public static ByteBuffer allocateDirect(int capacity) {
    return new DirectByteBuffer(capacity);
}

DirectByteBuffer类

DirectByteBuffer(int cap) {   // package-private
   
    super(-1, 0, cap, cap);
    boolean pa = VM.isDirectMemoryPageAligned();
    int ps = Bits.pageSize();
    long size = Math.max(1L, (long)cap + (pa ? ps : 0));
    Bits.reserveMemory(size, cap);

    long base = 0;
    try {
        base = unsafe.allocateMemory(size); //申请内存
    } catch (OutOfMemoryError x) {
        Bits.unreserveMemory(size, cap);
        throw x;
    }
    unsafe.setMemory(base, size, (byte) 0);
    if (pa && (base % ps != 0)) {
        // Round up to page boundary
        address = base + ps - (base & (ps - 1));
    } else {
        address = base;
    }
    cleaner = Cleaner.create(this, new Deallocator(base, size, cap)); //通过虚引用，来实现直接内存的释放，this为虚引用的实际对象
    att = null;
}

这里调用了一个Cleaner的create方法，且后台线程还会对虚引用的对象监测，如果虚引用的实际对象（这里是DirectByteBuffer）被回收以后，就会调用Cleaner的clean方法，来清除直接内存中占用的内存

public void clean() {
       if (remove(this)) {
           try {
               this.thunk.run(); //调用run方法
           } catch (final Throwable var2) {
               AccessController.doPrivileged(new PrivilegedAction<Void>() {
                   public Void run() {
                       if (System.err != null) {
                           (new Error("Cleaner terminated abnormally", var2)).printStackTrace();
                       }
                       System.exit(1);
                       return null;
                   }
               });
           }

对应对象的run方法

public void run() {
    if (address == 0) {
        // Paranoia
        return;
    }
    unsafe.freeMemory(address); //释放直接内存中占用的内存
    address = 0;
    Bits.unreserveMemory(size, capacity);
}

直接内存的回收机制总结
使用了Unsafe类来完成直接内存的分配回收，回收需要主动调用freeMemory方法
ByteBuffer的实现内部使用了Cleaner（虚引用）来检测ByteBuffer。一旦ByteBuffer被垃圾回收，那么会由ReferenceHandler来调用Cleaner的clean方法调用freeMemory来释放内存