Java 虚拟机中的内存结构

最新推荐文章于 2024-04-27 09:13:51 发布
最新推荐文章于 2024-04-27 09:13:51 发布
阅读量870 收藏 21
点赞数 24
分类专栏： Java 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45364953/article/details/135161452
版权

1 内存结构

1.1 程序计数器

image-20231222142726484

1.1.1 定义

Program Counter Register 程序计数器（寄存器）

作用：是记住下一条 jvm 指令的执行地址

特点：

  • 是线程私有的（每个线程独有自己的一份）
  • 不会存在内存溢出

1.1.2 作用

记住下一条 jvm 指令的执行地址 (0,3,4,5,...)

image-20231222143054213

线程私有的：

每个线程都有一个自己的程序计数器，里面存储了自己线程运行到了哪条指令

image-20231222144028283

1.2 虚拟机栈

image-20231222144244229

1.2.1 定义

Java Virtual Machine Stacks (Java 虚拟机栈)

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

栈：线程运行需要的内存空间

栈中存储着多个栈帧，每个栈帧对应着一个调用过的方法，栈顶为活动栈帧，是当前正在运行的函数；当一个方法运行完成，这个方法对应的栈帧就会出栈

image-20231222144505865

问题辨析

  1. 垃圾回收是否涉及栈内存？

    不需要，每次方法结束时，栈内存就被回收掉了，不需要等待垃圾回收；垃圾回收是用来回收堆内存中的对象的

  2. 栈内存分配越大越好吗？

    • 可以用 -Xss size 指令设置栈内存的大小
    • Linux & macOS默认 1024 KB，Windows 依赖虚拟内存的大小

  3. 方法内的局部变量是否线程安全？

    • 如果方法内局部变量没有逃离方法的作用访问，是线程私有的，它是线程安全的

      image-20231222145641730

    • 如果是局部变量引用了对象，对象是共有的，并逃离方法的作用范围，需要考虑线程安全

      image-20231222145625818

/**
 * 局部变量的线程安全问题
 */

public class d1_local_var_safe {
    // 多个线程执行这个方法
    public static void method1(String[] args) {
        int x = 0;
        for (int i = 0; i < 5000; i++) {
            x++;
        }
        System.out.println(x);
    }
}

1.2.2 栈内存溢出

  • 栈帧过多导致栈内存溢出。例如方法的递归调用
image-20231222152256064
  • 栈帧过大导致栈内存溢出

1.2.3 线程运行诊断

案例一：CPU 占用过高

  • 可以用 top 命令定位哪个进程对 CPU 的占用过高

  • 找到进程后，我们想进一步的定位到具体的线程，可以用 ps 命令

    • ps H pid,tid,%cpu 可以把当前所有线程的 pid,tid,cpu的信息展示出来
    • 使用管道过滤出具体的进程号：ps h -eo pid,tid,%cpu | grep 32655

  • jstack 进程id 命令可以列出Java虚拟机中的所有的 Java 线程

    • 根据 ps 命令找到的线程号可以在 jstack 中找到对应的线程，里面给出该线程的状态和问题代码行号

案例二：程序运行很长时间没有结果

可能发生了死锁等等

使用 jstack 命令进行检查

1.3 本地方法栈

image-20231222154054304

我们可以通过本地方法调用一些用C/CPP写的更底层的方法，例如Object类中的clone , hashCode… 方法

1.4 堆

image-20231222154417878

1.4.1 定义

Heap 堆：

  • 通过 new 关键词创建对象会使用堆内存

特点：

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

1.4.2 堆内存溢出

不断的向堆中添加对象，且这些对象无法回收，一段时间后会导致堆内存溢出

1.4.3 堆内存诊断

package com.rainsun.d1_Java_memory_structure;
/**
 * 堆内存演示
 */
public class d2_heap_memory {
    public static void main(String[] args) throws InterruptedException {
        System.out.println("1.....");
        Thread.sleep(30000);
        byte[] array = new byte[1024 * 1024 * 10]; // 10Mb 空间
        System.out.println("2.....");
        Thread.sleep(30000);
        array = null;
        System.gc();
        System.out.println("3.....");
        Thread.sleep(100000L);
    }
}

查看堆内存信息：

  • jps 找到当前运行的线程id
  • jhsdb jmap --pid 线程id --heap 输出堆占用信息

1:

image-20231222160549701

2:

image-20231222160605952

3:没有G1 Heap了

  • jconsole 工具

    图形界面的，多功能的监测工具，可以连续监测

1.5 方法区

image-20231222161551426

方法区是线程共享的，存储类相关的信息（方法，构造器，特殊方法，运行时常量池等等）

Chapter 2. The Structure of the Java Virtual Machine (oracle.com)

image-20231222161731756

JDK1.6中的结构：

使用 PermGen 永久代实现

image-20231222161942216

JDK1.8中的结构：

元空间实现，使用操作系统中的本地内存实现：

image-20231222162115139

1.5.4 运行时常量池

  • 常量池，就是一张表，虚拟机指令根据这张常量表找到要执行的类名、方法名、参数类型、字面量等信息
  • 运行时常量池：
    • 常量池是 *.class 文件中的；
    • 当程序运行的时候，每个被加载的类，它的.class文件中常量池信息就都会放入运行时常量池，运行时常量池保存了所有被加载了的类中的常量池信息
    • 并把里面的符号地址变为真实地址

1.5.5 StringTable

public static void main(String[] args) {
    String s1 = "a";
    String s2 = "b";
    String s3 = "a" + "b";
    String s4 = s1 + s2;
}

反编译：

  • 常量池中的信息，都会被加载到运行时常量池中，这时 a , b 都是常量池中的符号，还没有变成 Java 字符串对象
  • ldc #2 会把 a 符号变为 “a” 字符串对象，并把 “a” 放入 StringTable 中，如果没有则加入新的，有则不加入新的

s1，s2，s3 字符串对象的产生是发生在字符串常量池的 StringTable 中的

s4 字符串对象的产生是通过调用两次 makeConcatWithConstants 方法将常量池中的 “a” ，“b” 进行拼接，在堆中创建了一个新的字符串变量，最后存入临时变量 s4中的。

image-20231222174240646

这是 JDK 21 反编译的结果，JDK 8 不一样，可能是 append.append.toString

StringTable 特性：

  • 常量池中的字符串仅是符号，第一次用到时才变为对象
  • 利用串池的机制，来避免重复创建字符串对象
  • 字符串变量拼接的原理是 StringBuilder （1.8）
  • 字符串常量拼接的原理是编译期优化
  • 可以使用 intern 方法，主动将串池中还没有的字符串对象放入串池
public static main(String[] args){
    String s = new String("a") + new String("b");
}

StringTable 中创建了字符串对象 [“a”，“b”]

在堆中产生了字符串对象，因为使用了 new 来创建 “a”，“b” ，“ab”

intern:

将字符串对象放入 StringTable，如果table中有则不会放入，没有则放入，并把 table 中的对象返回

String s2 = s.intern(); // 堆中的 "ab" 被放入了 StringTable中了, 并将table中的ab返回

public class d3_stringTable {
    // 常量池中的信息，都会被加载到运行时常量池中，这时 a , b 都是常量池中的符号，还没有变成 Java 字符串对象
    // ldc #2 会把 a 符号变为 "a" 字符串对象，并把 "a" 放入 StringTable 中，如果没有则加入新的，有则不加入新的
    public static void main(String[] args) {
        String s1 = "a";
        String s2 = "b";
        String s3 = "a" + "b"; //javac在编译期间的优化，变成了 "ab"，结果在编译期就已经确定了
        String s4 = s1 + s2; // 堆中的ab: new String("ab")

        String s5 = "ab"; // == s3 在table中的ab
        String s6 = s4.intern(); // table中ab已经有了，返回table中的ab

        System.out.println(s3 == s4); //false
        System.out.println(s3 == s5); // true
        System.out.println(s3 == s6); // true

        String x2 = new String("c") + new String("d");
        String x1 = "cd";
        x2.intern();  // table中 cd 已经存在了，x2放不进去table，x2还是堆中的cd
        System.out.println(x1 == x2); // false

        /** 最后两行代码的位置调换：
         * String x2 = new String("c") + new String("d");
         * x2.intern(); // table 中 cd 不存在，x2放入table，x2 变成了table中的cd
         * String x1 = "cd"; // x1 用的是table中的cd
         * System.out.println(x1 == x2); // true
         */
    }
}

1.5.6 StringTable 位置

image-20231222200203414

1.6 中的StringTable在PermGen永久代中实现，它的回收时机比较晚，容易造成永久代的内存空间不足

在1.8中就将StringTable放入堆Heap中实现，它的垃圾回收时机触发比较早，可以更快回收不用的字符串空间

image-20231222162115139

1.5.7 StringTable 垃圾回收

那些没有用到的字符串常量会被垃圾回收

package com.rainsun.d1_Java_memory_structure;

/**
 * 演示 StringTable垃圾回收
 * -Xmx10m
 * -XX:+PrintStringTableStatistics : 打印 StringTable 信息
 * -XX:+PrintGCDetails -verbose:gc ：打印垃圾回收信息
 */
public class d4_stringTable_GC {
    public static void main(String[] args) {
        int i = 0;
        try {
            for (int j = 0; j < 100000; j++) {
                String.valueOf(j).intern();
                i++;
            }
        }catch (Throwable e){
            e.printStackTrace();
        }finally {
            System.out.println(i);
        }
    }
}

image-20231222202328823

1.5.8 StringTable 调优

  1. -XX:StringTableSize=桶个数 可以设置String Table 中桶的个数，类似于一个哈希表，当表越大，每个桶中链表的长度就越小，查找的速度就越快
  2. 考虑将字符串对象是否入池
    • 如果字符串大量重复可以让字符串入池，减少重复字符串存在在heap中

1.6 使用操作系统中的直接内存

1.6.1 Direct Memory

  • 常见于 NIO 操作，用于数据缓冲区
  • 分配回收成本较高，但读写性能高
  • 不受 JVM 内存回收管理
  • 传统的阻塞式 IO 读取数据的方式：

CPU从Java的用户态转为系统的内核态，这样可以读取磁盘中的文件到系统的缓冲区，但是系统的缓冲区 Java 无法获取，所以还需要将系统缓冲区中的数据传给Java缓冲区

image-20231222203852847

  • 使用直接内存进行文件读取：

会产生一块 direct memory的区域，操作系统和Java都可以读取

image-20231222204121083

内存溢出问题

当direct memory占用太大会抛出内存溢出异常

1.6.2 分配和回收原理

  • 使用了 Unsafe 对象完成直接内存的分配回收，并且回收需要主动调用 freeMemory 方法

    package com.rainsun.d1_Java_memory_structure;

import sun.misc.Unsafe;

import java.io.IOException;
import java.lang.reflect.Field;

public class d5_direct_memory {
    static int _1Gb = 1024*1024*1024;
    public static void main(String[] args) throws IOException {
        Unsafe unsafe = getUnsafe();
        // 分配内存
        long base = unsafe.allocateMemory(_1Gb);
        unsafe.setMemory(base, _1Gb, (byte) 0);
        System.in.read();

        // 释放内存
        unsafe.freeMemory(base);
        System.in.read();
    }

    public static Unsafe getUnsafe() {
        try {
            Field f = Unsafe.class.getDeclaredField("theUnsafe");
            f.setAccessible(true);
            Unsafe unsafe = (Unsafe) f.get(null);
            return unsafe;
        } catch (NoSuchFieldException | IllegalAccessException e) {
            throw new RuntimeException(e);
        }
    }
}

  • ByteBuffer 的实现类内部，使用了 Cleaner （虚引用）来监测 ByteBuffer 对象，一旦 ByteBuffer 对象被垃圾回收，那么就会由 ReferenceHandler 线程通过 Cleaner 的 clean 方法调用 freeMemory 来释放直接内存

    测试：

    public class d6_direct_byteBuffer {
    static int _1Gb = 1024*1024*1024;
    public static void main(String[] args) throws IOException {
        ByteBuffer byteBuffer = ByteBuffer.allocateDirect(_1Gb);
        System.out.println("分配完毕");
        System.in.read();
        System.out.println("开始释放");
        byteBuffer = null;
        System.gc();
        System.in.read();
    }
}

    原理：

    // 分配内存后：
public static ByteBuffer allocateDirect(int capacity) {
    return new DirectByteBuffer(capacity);
}

DirectByteBuffer(int cap) { 
    super(-1, 0, cap, cap, null);
    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;
    }
    try { // Cleaner检测this对象(ByteBuffer)是否被垃圾回收，如果被回收了就会调用clean方法调用 Deallocator 中的 run 方法 释放内存
        cleaner = Cleaner.create(this, new Deallocator(base, size, cap));
    } catch (Throwable t) {
        // Prevent leak if the Deallocator or Cleaner fail for any reason
        UNSAFE.freeMemory(base);
        Bits.unreserveMemory(size, cap);
        throw t;
    }
    att = null;
}
// 实现 Runnable 接口
private static class Deallocator implements Runnable {
    private long address;
    private long size;
    private int capacity;

    private Deallocator(long address, long size, int capacity) {
        assert (address != 0);
        this.address = address;
        this.size = size;
        this.capacity = capacity;
    }
    // Deallocator 中的 run 释放了内存
    public void run() {
        if (address == 0) {
            // Paranoia
            return;
        }
        UNSAFE.freeMemory(address); // 释放内存
        address = 0;
        Bits.unreserveMemory(size, capacity);
    }

}

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

1.6.3 禁用显示垃圾回收

-XX:+DisableExplicitGC 禁用显式的垃圾回收

显示垃圾回收写法：

System.gc();

这种垃圾回收都是 Full GC的，回收比较满，常用于性能调优

这可能会对Direct memory 的内存回收有影响，因为这里的Direct memory的内存回收是需要Java中的对象被回收时才会被触发的；

例如这里是ByteBuffer对象被回收，触发了分配的直接内存的回收。

所以还是用Unsafe对象手动的调用 freeMemory 进行回收比较好

xiongyuqing
关注
  • 24
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java虚拟机的内存结构
10-04
java虚拟机的内存结构，关于内存的相关介绍等，想要了解更多JVM的
一文读懂 -Java虚拟机的内存结构（图详解）
辰兮要努力
05-19 4093
JVM中的堆啊、栈啊、方法区什么的，是Java虚拟机的内存结构，Java程序启动后，会初始化这些内存的数据。 内存结构就是上图中内存空间这些东西，而Java内存模型，完全是另外的一个东西。 Java中的内存分配： Java程序在运行时，需要在内存中的分配空间。为了提高运算效率，就对数据进行了不同空间的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。 具体划分为如下5个内存空间： 栈：存放局部变量 堆：存放所有new出来的东西 方法区：被虚拟机加载的类信息、常量、静态常量等。 程序计数器(和系统
Java虚拟机的内存结构
QAQ123666的博客
11-04 253
文章目录1.Java虚拟机的内存结构1.程序计数器2.Java虚拟机栈3.本地方法栈4.Java堆5.方法区 1.Java虚拟机的内存结构 Java虚拟机的内存结构，在《Java 虚拟机规范》中叫“运行时数据区” 根据《Java 虚拟机规范》中的说法，Java 虚拟机的内存结构可以分为公有和私有两部分。公有指的是所有线程都共享的部分，指的是 堆、方法区、常量池。私有指的是每个线程的私有数据，包括：...
《Java 虚拟机》 基本概念与内存结构
华仔仔的博客
04-01 2487
JVM 基本概念与内存模型1. JVM 基本概念2. JVM 内存模型2.1 程序计数器2.2 虚拟机栈2.3 本地方法栈2.4 堆2.5 方法区2.6 直接内存 1. JVM 基本概念 定义：Java Virtual Machine，Java 程序的运行环境（Java 二进制字节码的运行环境）。 优点： 一次编写，到处运行 自动管理内存，具有垃圾回收的功能 数组下标越界检查 多态 JVM、JRE、JDK、JavaSE 和 JavaEE 之间比较： 2. JVM 内存模型 整体架构 2.1 程序计数
Java虚拟机之内存结构
修理男爵的博客
12-20 345
JVM内存模型(运行时数据区) 程序计数器 (线程私有) Program Counter Register 并非广义上所指的物理寄存器，而是对物理PC寄存器的一种抽象模拟。 用来存储执行下一条要执行的指令的地址，也就是将要执行的指令代码， 由执行引擎读取下一条指令。 是一块很小的内存空间，小到可以忽略不计 线程私有，生命周期也和线程保持一致 任何时间，一个线程只有一个方法在执行，叫做当前方法。程序计数器会存储当前线程执行的方法的JVM指令地址；或者如果执行的是native方法，则是未指定值..
Java虚拟机--内存结构
weixin_39124328的博客
07-30 2944
1.JVM是什么? 　　JVM:Java Virtual Mechinal(Java虚拟机).它是一个虚构的计算机,是通过在实际的计算机上模拟各种功能来实现的。JVM的主要工作是解释自己的指令集（字节码，如java源码编译成class文件在虚拟机上运行）并映射到本地的CPU指令集或OS的系统调用。Java语言跨平台的本质就是不同的操作系统使用不同的JVM映射规则，使其与操作系统无关，从而实现跨平...
JVM（java虚拟机）内存结构
YD_162031的博客
08-29 167
jvm的内存结构是jvm在执行字节码的时候所需要的内存区域。 图不想插了，手动画个图： -------------------------------------- 堆 | java栈 | 方法区 | 本地方法栈 | | 程序计数器 | ---------...
Java虚拟机（内存结构）1
08-08
Java虚拟机（内存结构）1
Java虚拟机内存优化实践
12-22
前面一篇文章介绍了Java虚拟机的体系结构和内存模型，既然提到内存，不得不说到内存泄露。众所周知，Java是从C++的基础上发展而来的，而C++程序的很大的一个问题是内存泄露难以解决，尽管Java的JVM有一套自己的垃圾...
2_Java虚拟机（ 内存结构）.pdf
03-08
Java虚拟机（ 内存结构），可以深入了解JVM虚拟机的内存结构，对于Java虚拟机需要有深入了解的人员可以下载。
浅谈Java的虚拟机结构以及虚拟机内存的优化
09-02
主要介绍了Java的虚拟机结构以及虚拟机内存的优化,讲到了JVM的堆和栈空间及GC垃圾回收等重要知识,需要的朋友可以参考下
mybatisPlus使用MetaObjectHandler对字段进行更新
m0_56356631的博客
04-23 759
都是符合我们的预期的。
java方法重写（重点讲），方法重载
最新发布
weixin_46281068的博客
04-27 830
一、方法重载定义：一个类中，出现多个方法的名称相同，但是它们的形参列表是不同的，那么这些方法就称为方法重载了。注意：一个类中，只要一些方法的名称相同、形参列表不同，那么它们就是方法重载了，其它的都不管（如:修饰符，返回值类型是否一样都无所谓）。形参列表不同指的是:形参的个数、类型、顺序不同，不关心形参的名称。应用场景：开发中我们经常需要为处理一类业务，提供多种解决方案，此时用方法重载来设计是很专业的。
string模拟实现
m0_73969414的博客
04-23 1748
c++中string的模拟实现，面试必会知识点
实现自定义注解、实现自定义幂等性注解
qq_44721738的博客
04-23 1030
添加 Spring AOP 依赖。创建自定义注解。创建一个新的 Java 注解类，通过@interface关键字来定义，并可以添加元注解以及属性。@Target(ElementType.METHOD) //表示作用于方法上@Retention(RetentionPolicy.RUNTIME) // 表示这个注解在运行时是可见的，这样 AOP 代理才能在运行时读取到这个注解编写 AOP 拦截（自定义注解）的逻辑代码。@Aspect@Component// 方法执行前的处理。
PageHelper实现分页查询
m0_63849044的博客
04-24 1070
这行代码是在使用 MyBatis Generator (MBG) 或类似的 MyBatis 工具生成的代码来构建查询条件。（可能是MyBatis的Mapper接口）来执行基于前面定义的查询条件的查询，并获取结果列表。实例之后会被用来设置各种查询条件，如字段的等于、不等于、大于、小于、模糊查询等。实体类生成的辅助类，它通常包含了一些静态内部类和方法，用于构建查询条件。在MyBatis中，这样的对象通常用于构建查询条件。对象，可能用于作为查询条件）。的一个内部类，用于定义查询的具体条件。
虚拟机栈(JVM Stack)
07-12
虚拟机栈（JVM Stack）是Java虚拟机（JVM）在运行时用来存储方法调用和局部变量的数据结构。每个线程在运行时都会有一个独立的虚拟机栈。 虚拟机栈以栈帧（Stack Frame）为单位，每个栈帧对应一个方法的调用。当一个方法被调用时，会在虚拟机栈中创建一个新的栈帧，栈帧包含了方法的参数、局部变量、操作数栈等信息。 虚拟机栈以LIFO（Last-In-First-Out）的顺序进行操作，即最后进入的栈帧最先被执行和销毁。当方法执行完成或者抛出异常时，对应的栈帧会被销毁。 虚拟机栈的大小是固定的，并且在JVM启动时就被确定。如果虚拟机栈的空间不足，会抛出StackOverflowError异常。而如果动态扩展时无法申请到足够的内存，或者在创建线程时无法申请到足够的内存，则会抛出OutOfMemoryError异常。 虚拟机栈是Java程序运行过程中重要的一部分，通过管理方法调用和局部变量，提供了程序运行的基础支持。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值