JVM篇之内存结构

已于 2023-03-01 18:22:52 修改
阅读量611 收藏 2
点赞数 1
分类专栏： JVM 文章标签： jvm java 内存结构
于 2023-02-25 01:42:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_66689823/article/details/129192652
版权

一.引言

1.什么是 JVM ？

1）定义：
Java Virtual Machine - java 程序的运行环境（java 二进制字节码的运行环境）

2）好处：

  • 一次编写，到处运行
  • 自动内存管理，垃圾回收功能
  • 数组下标越界检查
  • 多态

3）比较：
jvm jre jdk

在这里插入图片描述

2.常见的 JVM

在这里插入图片描述

3.学习路线

在这里插入图片描述
ClassLoader：Java 代码编译成二进制后，会经过类加载器，这样才能加载到 JVM 中运行。
Method Area：类是放在方法区中。
Heap：类的实例对象。
当类调用方法时，会用到 JVM Stack、PC Register、本地方法栈。
方法执行时的每行代码是有执行引擎中的解释器逐行执行，方法中的热点代码频繁调用的方法，由 JIT 编译器优化后执行，GC 会对堆中不用的对象进行回收。需要和操作系统打交道就需要使用到本地方法接口。

二.内存结构

1. 程序计数器

1）定义

Program Counter Register 程序计数器（寄存器）
作用，是记住下一条jvm指令的执行地址

特点：

  • 是线程私有的
  • 不会存在内存溢出

2）作用

0: getstatic #20 			// PrintStream out = System.out;
3: astore_1					// --
4: aload_1 					// out.println(1);
5: iconst_1 				// --
6: invokevirtual #26 		// --
9: aload_1 					// out.println(2);
10: iconst_2 				// --
11: invokevirtual #26 		// --
14: aload_1 				// out.println(3);
15: iconst_3 				// --
16: invokevirtual #26 		// --
19: aload_1 				// out.println(4);
20: iconst_4 				// --
21: invokevirtual #26 		// --
24: aload_1 				// out.println(5);
25: iconst_5 				// --
26: invokevirtual #26 		// --
29: return
  • 解释器会解释指令为机器码交给 cpu 执行，程序计数器会记录下一条指令的地址行号，这样下一次解释器会从程序计数器拿到指令然后进行解释执行。
  • 多线程的环境下，如果两个线程发生了上下文切换，那么程序计数器会记录线程下一行指令的地址行号，以便于接着往下执行。

2. 虚拟机栈

1）定义

  • 每个线程运行时所需要的内存，称为虚拟机栈
  • 每个栈由多个栈帧（Frame）组成，对应着每次方法调用时所占用的内存
  • 每个线程只能有一个活动栈帧，对应着当前正在执行的那个方法

问题辨析：

  1. 垃圾回收是否涉及栈内存？
    不会。栈内存是方法调用产生的，方法调用结束后会弹出栈。
  2. 栈内存分配越大越好吗？
    不是。因为物理内存是一定的，栈内存越大，可以支持更多的递归调用，但是可执行的线程数就会越少。
  3. 方法呢的局部变量是否线程安全
    • 如果方法内部的变量没有逃离方法的作用访问，它是线程安全的
    • 如果是局部变量引用了对象，并逃离了方法的访问，那就要考虑线程安全问题。

2）栈内存溢出

栈帧过大、过多、或者第三方类库操作，都有可能造成栈内存溢出 java.lang.stackOverflowError ，使用 -Xss256k 指定栈内存大小！

3）线程运行诊断

案例一：cpu 占用过多
解决方法：Linux 环境下运行某些程序的时候，可能导致 CPU 的占用过高，这时需要定位占用 CPU 过高的线程

  • top 命令，查看是哪个进程占用 CPU 过高
  • ps H -eo pid, tid（线程id）, %cpu | grep 刚才通过 top 查到的进程号 通过 ps 命令进一步查看是哪个线程占用 CPU 过高
  • jstack 进程 id 通过查看进程中的线程的 nid ，刚才通过 ps 命令看到的 tid 来对比定位，注意 jstack 查找出的线程 id 是 16 进制的，需要转换。

3.本地方法栈

一些带有 native 关键字的方法就是需要 JAVA 去调用本地的C或者C++方法，因为 JAVA 有时候没法直接和操作系统底层交互，所以需要用到本地方法栈，服务于带 native 关键字的方法。

4.堆

1）定义

Heap 堆

  • 通过new关键字创建的对象都会被放在堆内存

特点

  • 它是线程共享，堆内存中的对象都需要考虑线程安全问题
  • 有垃圾回收机制

2）堆内存溢出

java.lang.OutofMemoryError ：java heap space. 堆内存溢出
可以使用 -Xmx8m 来指定堆内存大小。

3）堆内存诊断

  1. jps 工具
    查看当前系统中有哪些 java 进程
  2. jmap 工具
    查看堆内存占用情况 jmap - heap 进程id
  3. jconsole 工具
    图形界面的，多功能的监测工具，可以连续监测
  4. jvisualvm 工具

5.方法区

1）定义

Java 虚拟机有一个在所有 Java 虚拟机线程之间共享的方法区域。方法区域类似于用于传统语言的编译代码的存储区域，或者类似于操作系统进程中的“文本”段。它存储每个类的结构，例如运行时常量池、字段和方法数据，以及方法和构造函数的代码，包括特殊方法，用于类和实例初始化以及接口初始化方法区域是在虚拟机启动时创建的。尽管方法区域在逻辑上是堆的一部分，但简单的实现可能不会选择垃圾收集或压缩它。此规范不强制指定方法区的位置或用于管理已编译代码的策略。方法区域可以具有固定的大小，或者可以根据计算的需要进行扩展，并且如果不需要更大的方法区域，则可以收缩。方法区域的内存不需要是连续的！

2）组成

Hotspot 虚拟机 jdk1.6 1.7 1.8 内存结构图
在这里插入图片描述

3）方法区内存溢出

  • 1.8 之前会导致永久代内存溢出
    • 使用 -XX:MaxPermSize=8m 指定永久代内存大小
  • 1.8 之后会导致元空间内存溢出
    • 使用 -XX:MaxMetaspaceSize=8m 指定元空间大小

4）运行时常量池

二进制字节码包含（类的基本信息，常量池，类方法定义，包含了虚拟机的指令）
首先看看常量池是什么，编译如下代码：

public class Test {

    public static void main(String[] args) {
        System.out.println("Hello World!");
    }
    
}

然后使用 javap -v Test.class 命令反编译查看结果。

在这里插入图片描述

每条指令都会对应常量池表中一个地址，常量池表中的地址可能对应着一个类名、方法名、参数类型等信息。

在这里插入图片描述

常量池：
就是一张表，虚拟机指令根据这张常量表找到要执行的类名、方法名、参数类型、字面量信息

运行时常量池：
常量池是 *.class 文件中的，当该类被加载以后，它的常量池信息就会放入运行时常量池，并把里面的符号地址变为真实地址

5）StringTable

  • 常量池中的字符串仅是符号，只有在被用到时才会转化为对象
  • 利用串池的机制，来避免重复创建字符串对象
  • 字符串变量拼接的原理是StringBuilder
  • 字符串常量拼接的原理是编译器优化
  • 可以使用intern方法，主动将串池中还没有的字符串对象放入串池中

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

6）StringTable 的位置

jdk1.6 StringTable 位置是在永久代中，1.8 StringTable 位置是在堆中。

7）StringTable 垃圾回收

-Xmx10m 指定堆内存大小
-XX:+PrintStringTableStatistics 打印字符串常量池信息
-XX:+PrintGCDetails
-verbose:gc 打印 gc 的次数，耗费时间等信息

/**
 * 演示 StringTable 垃圾回收
 * -Xmx10m -XX:+PrintStringTableStatistics -XX:+PrintGCDetails -verbose:gc
 */
public class Code_05_StringTableTest {

    public static void main(String[] args) {
        int i = 0;
        try {
            for(int j = 0; j < 10000; j++) { // j = 100, j = 10000
                String.valueOf(j).intern();
                i++;
            }
        }catch (Exception e) {
            e.printStackTrace();
        }finally {
            System.out.println(i);
        }
    }

}

8）StringTable 性能调优

因为StringTable是由HashTable实现的，所以可以适当增加HashTable桶的个数，来减少字符串放入串池所需要的时间

-XX:StringTableSize=桶个数（最少设置为 1009 以上）

考虑是否需要将字符串对象入池，可以通过 intern 方法减少重复入池

6.直接内存

1）定义

Direct Memory

  • 常见于 NIO 操作时，用于数据缓冲区
  • 分配回收成本较高，但读写性能高
  • 不受 JVM 内存回收管理

2）使用直接内存的好处

文件读写流程：

在这里插入图片描述

因为 java 不能直接操作文件管理，需要切换到内核态，使用本地方法进行操作，然后读取磁盘文件，会在系统内存中创建一个缓冲区，将数据读到系统缓冲区， 然后在将系统缓冲区数据，复制到 java 堆内存中。缺点是数据存储了两份，在系统内存中有一份，java 堆中有一份，造成了不必要的复制。

使用了 DirectBuffer文件读取流程

在这里插入图片描述
直接内存是操作系统和 Java 代码都可以访问的一块区域，无需将代码从系统内存复制到 Java 堆内存，从而提高了效率。

3）直接内存回收原理

public class Code_06_DirectMemoryTest {

    public static int _1GB = 1024 * 1024 * 1024;

    public static void main(String[] args) throws IOException, NoSuchFieldException, IllegalAccessException {
//        method();
        method1();
    }

    // 演示 直接内存 是被 unsafe 创建与回收
    private static void method1() throws IOException, NoSuchFieldException, IllegalAccessException {

        Field field = Unsafe.class.getDeclaredField("theUnsafe");
        field.setAccessible(true);
        Unsafe unsafe = (Unsafe)field.get(Unsafe.class);

        long base = unsafe.allocateMemory(_1GB);
        unsafe.setMemory(base,_1GB, (byte)0);
        System.in.read();

        unsafe.freeMemory(base);
        System.in.read();
    }

    // 演示 直接内存被 释放
    private static void method() throws IOException {
        ByteBuffer byteBuffer = ByteBuffer.allocateDirect(_1GB);
        System.out.println("分配完毕");
        System.in.read();
        System.out.println("开始释放");
        byteBuffer = null;
        System.gc(); // 手动 gc
        System.in.read();
    }

}

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

第一步：allocateDirect 的实现

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

底层是创建了一个 DirectByteBuffer 对象。

第二步：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为虚引用的实际对象, 第二个参数是一个回调，实现了 runnable 接口，run 方法中通过 unsafe 释放内存。
    att = null;
}

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

 public void clean() {
    if (remove(this)) {
        try {
        // 都用函数的 run 方法, 释放内存
            this.thunk.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;
                }
            });
        }

    }
}

可以看到关键的一行代码， this.thunk.run()，thunk 是 Runnable 对象。run 方法就是回调 Deallocator 中的 run 方法，

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

可以看到关键的一行代码， this.thunk.run()，thunk 是 Runnable 对象。run 方法就是回调 Deallocator 中的 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 来释放内存

注意：

/**
* -XX:+DisableExplicitGC 显示的
*/
private static void method() throws IOException {
    ByteBuffer byteBuffer = ByteBuffer.allocateDirect(_1GB);
    System.out.println("分配完毕");
    System.in.read();
    System.out.println("开始释放");
    byteBuffer = null;
    System.gc(); // 手动 gc 失效
    System.in.read();
}

一般用 jvm 调优时，会加上下面的参数：

-XX:+DisableExplicitGC  // 静止显示的 GC

意思就是禁止我们手动的 GC，比如手动 System.gc() 无效，它是一种 full gc，会回收新生代、老年代，会造成程序执行的时间比较长。所以我们就通过 unsafe 对象调用 freeMemory 的方式释放内存。

本文借鉴：http://t.csdn.cn/kbIeT

Jm呀
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
JVM的内存结构
m0_38142121的博客
03-31 76
一、JVM的内存结构 先上一副网图说明JVM内存布局： JVM的内存结构主要有三大块：堆内存、方法区和栈。 堆由年轻代和和老年代组成，而年轻代又分成三个部分，Eden空间、From Survivor空间、To Survivor空间，默认情况下，年轻代按照8:1:1的比例来分配。 对于这些内存空间的大小，可通过一些虚...
JVM-内存结构
qq_39356280的博客
03-11 90
JVM-内存结构总结程序计数器定义作用虚拟机栈定义栈内存溢出线程运行诊断本地方法栈堆定义堆内存溢出演示堆内存诊断 总结 方法区：类（class） 堆：根据类所创建的实例，也就是对象 而对象在调用方法的时候，就会用到虚拟机栈，程序计数器，本地方法栈 方法执行时，是由执行引擎中的解释器来进行逐行执行 方法中的热点代码，也就是被频繁执行的代码，会由即时编译器进行编译，可理解为优化后的执行 GC（垃圾回收）：可以对堆中不再引用的对象进行垃圾回收。 本地方法接口：调用操作系统底层所提供的一些方法。 程序计数器
jvm内存结构
m0_63463465的博客
03-11 168
1、栈是线程运行时需要的内存空间。2、每个栈由多个栈帧组成，对应着每次方法调用所占的内存。3、每个线程只有一个活动的栈帧，对应着正在执行的那个方法。
JVM内存结构
weixin_41812379的博客
04-07 1万+
JVM内存结构 JVM的内存结构大致分为五个部分，分别是程序计数器、虚拟机栈、本地方法栈、堆和方法区。除此之外，还有由堆中引用的JVM外的直接内存。 下面将展开讲解这五个部分。 程序计数器 程序计数器(Program Counter Register)，用于记录下一条JVM指令的执行地址（如果正在执行的是本地方法则为空）。例如下图中的JVM指令，当我执行到地址为0的指令时，程序计数器就会存下下一条指令的地址，也就是地址3。 要注意的是，程序计数器时线程私有的，每一个线程都有一个程序计数器，只有这么设计，
深度解析JVM世界：JVM内存结构
最新发布
知道的越多 不知道的就越多
03-25 1176
本文全面剖析了java虚拟机的内容结构，包括方法区、堆内存、栈内存等关键组件。通过理解jva内存结构，读者可有效的管理java应用程序的使用，提升程序的稳定性。
jvm内存结构和内存模型
HelloWorld_Joe的博客
09-04 4411
JVM内存结构 《深入理解Java虚拟机（第2版）》中的描述是下面这个样子的： JVM的内存结构大概分为： 堆（Heap）：线程共享。所有的对象实例以及数组都要在堆上分配。回收器主要管理的对象。 方法区（Method Area）：线程共享。存储类信息、常量、静态变量、即时编译器编译后的代码。 虚拟机栈（JVM Stack）：线程私有。存储局部变量表、操作栈、动态链接、方法出口，对象指...
JVM详解——内存结构
eyes++的博客
02-08 3285
JVM是Java Virtual Machine(Java虚拟机)的缩写，JVM是一种用于计算设备的规范，具体实现有很多，以下内容如果不额外声明，默认是HotSpot JVM。JVM它是一个虚构出来的计算机，是通过在实际的计算机上仿真模拟各种计算机功能来实现的。Java虚拟机包括一套字节码指令集、一组寄存器、一个栈、一个垃圾回收堆和一个存储方法域。JVM屏蔽了与具体操作系统平台相关的信息，使Java程序只需生成在Java虚拟机上运行的目标代码(字节码)，就可以在多种平台上不加修改地运行。
JVM内存结构划分实例解析
08-25
JVM内存结构划分实例解析 JVM 内存结构划分实例解析是 Java 虚拟机（JVM）中的一种内存管理机制，它将内存...JVM 内存结构划分实例解析对大家的学习或者工作具有一定的参考学习价值，需要的朋友可以参考下这篇文章。
一文搞懂JVM内存结构
09-22
一文搞懂JVM内存结构。 一篇文章带你快速了解！
从JVM内存模型谈线程安全
01-27
等赶明写一篇文章就叫做”我是个假程序员”来谈谈这些有趣的事儿.话不多说,今天要谈的主题是相对较深,较广,但我努力的让他看起来清晰明了.对于开发者来说,存储器的层次结构应该是非常熟悉的,大体如下:其中寄存器,L1,...
JVM--内存与垃圾回收篇1
08-03
Java虚拟机（JVM）是Java程序运行的核心，它的内存管理和垃圾回收机制对于程序的高效运行至关重要。在本文中，我们将深入探讨JVM的类加载子系统及其在内存管理中的作用。 类加载子系统，也被称为Class Loader ...
JVM内存模型和结构
Liarboy
08-26 3018
在虚拟机的概念模型里（仅是概念模型，各种虚拟机可能会通过一些更高效的方式去实现），字节码解释器工作时就是通过改变这个计数器的值来选取下一条需要执行的字节码指令，分支、循环、跳转、异常处理、线程恢复等基础功能都需要依赖这个计数器来完成。如果线程正在执行的是一个Java方法，这个计数器记录的是正在执行的虚拟机字节码指令的地址；方法区的内存回收目标主要是针对常量池的回收和对类型的卸载，一般来说这个区域的回收“成绩”比较难以令人满意，尤其是类型的卸载，条件相当苛刻，但是回收确实是有必要的。...
JVM之内存结构详解
热门推荐
程序新视界
10-18 2万+
对于开发人员来说，如果不了解Java的JVM，那真的是很难写得一手好代码，很难查得一手好bug。同时，JVM也是面试环节的中重灾区。今天开始，《JVM详解》系列开启，带大家深入了解JVM相关知识。 我们不能为了面试而面试，但是学习会这些核心知识你必定会成为面试与工作中“最亮的一颗星”。本系列首发于微信公众号“程序新视界”。下面，开启我们的第一篇文章《JVM之内存结构详解》。 学习也是要讲究方式方法...
JVM——JVM内存结构
庄小焱
10-05 1032
我们可以使用参数-Xss选项来设置线程的最大栈空间，栈的大小直接决定了函数调用的最大可达深度。方法区与Java堆一样， 是各个线程共享的内存区域， 它用于存储已被虚拟机加载的类信息、 常量、 静态变量、 即时编译器编译后的代码等数据。作用：主管java程序的运行，它保存方法的局部变量（8种基本数据类型、对象的引用地址）、部分结果，并参与方法的调用和返回。由于跨平台性的设计，java的指令都是根据栈来设计的。在jvm规范中，每个线程都有它自己的程序计数器，是线程私有的，生命周期与线程的生命周期保持一致。
JVM8的内存结构图
07-27
JVM8的内存结构图如下所示：\[1\] - 程序计数器 - 虚拟机栈（JVM Stack） - 本地方法栈 - 元空间（MetaSpace） - Java堆（Heap） 其中，程序计数器用于记录当前线程执行的字节码指令的地址；虚拟机栈用于存储方法...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Jm呀

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值