Java JVM内存结构 虚拟机栈 本地方法栈 方法区 直接内存

Java Virtual Machine ,Java 程序的运行环境(Java 二进制字节码的运行环境)。

image

常见的 JVM:

image

来源维基百科:https://en.wikipedia.org/wiki/Comparison_of_Java_virtual_machines

学习路线:

image

参考资料:https://www.javainterviewpoint.com/java-virtual-machine-architecture-in-java/

程序计数器

Program Counter Register 程序计数器(是通过寄存器实现的),用于保存JVM中下一条所要执行的指令的地址。

PC 寄存器用来存储指向下一条指令的地址,即将要执行的指令代码。由执行引擎读取下一条指令。

image

左边是二进制字节码,右边是Java编译后的代码,程序计数器就是用于记住下一条jvm指令的执行地址,比如现在是“0”,那他就会记住“3”,因为“3”在“0”的下面,而JVM会将指令 交给 解释器,解释器再将转为 机器码,交于CPU执行。

特点:

  • 是线程私有的
    • CPU会为每个线程分配时间片,当当前线程的时间片使用完以后,CPU就会去执行另一个线程中的代码
    • 程序计数器是每个线程所私有的,当另一个线程的时间片用完,又返回来执行当前线程的代码时,通过程序计数器可以知道应该执行哪一句指令
  • 不会存在内存溢出

虚拟机栈

Java Virtual Machine Stacks (Java 虚拟机栈),栈:先入后出

  • 每个线程运行需要的内存空间,称为虚拟机栈
  • 每个栈由多个栈帧组成,对应着每次方法调用时所占用的内存空间(参数、局部变量、返回地址)
  • 每个线程只能有一个活动栈帧,对应当前正在执行的那个方法

IDEA中的虚拟机栈:

image

常见问题

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

不需要。因为虚拟机栈中是由一个个栈帧组成的,在方法执行完毕后,对应的栈帧就会被弹出栈。所以无需通过垃圾回收机制去回收内存。

  1. 栈内存分配越大越好吗?

不是。因为物理内存是一定的,栈内存越大,可以支持更多的递归调用,但是可执行的线程数就会越少。

使用 -Xss 可以设置栈内存大小,比如物理内存是100Mb,当栈内存为1Mb时,可以同时有100个线程,而当栈内存为2Mb时,最多同时只有50个线程了。

  1. 方法内的局部变量是否线程安全?

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

如果是局部变量引用了对象,并逃离方法的范围,需要考虑线程安全问题

public class main1 {
    public static void main(String[] args) {

    }
    //下面各个方法会不会造成线程安全问题?

    //不会
    public static void m1() {
        StringBuilder sb = new StringBuilder();
        sb.append(1);
        sb.append(2);
        sb.append(3);
        System.out.println(sb.toString());
    }

    //会,可能会有其他线程使用这个对象
    public static void m2(StringBuilder sb) {
        sb.append(1);
        sb.append(2);
        sb.append(3);
        System.out.println(sb.toString());
    }

    //会,其他线程可能会拿到这个线程的引用
    public static StringBuilder m3() {
        StringBuilder sb = new StringBuilder();
        sb.append(1);
        sb.append(2);
        sb.append(3);
        return sb;
    }
}

栈内存溢出

Java.lang.stackOverflowError:栈内存溢出

导致栈内存溢出的情况:

  • 栈帧过多导致栈内存溢出
  • 栈帧过大导致栈内存溢出

image

线程运行诊断

Linux环境下运行某些程序的时候,可能导致CPU的占用过高,使用 top 命令可以查看CPU的使用情况:

image

ps H -eo pid,tid,%cpu | grep 进程id ,刚才通过top查到的进程号,用ps命令进一步定位是哪个线程引起的cpu占用过高:

image

jstack 进程id ,通过ps命令看到的tid来对比定位,注意jstack查找出的线程id是16进制的,需要转换

这样就知道那个线程占用过多的CPU了,进一步定位到问题代码的源码行数

还可以展示出死锁的信息

image

本地方法栈

Native Method Stacks

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

Heap (堆),通过new关键字创建的对象都会使用堆内存

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

堆内存溢出

java.lang.OutofMemoryError :java heap space :堆内存溢出

设置堆空间大小: -Xmx2m

/**
 * 演示堆内存溢出 java.lang.OutOfMemoryError: Java heap space
 * -Xmx8m ,最大堆空间的jvm虚拟机参数,默认是4g
 */
public class main1 {
    public static void main(String[] args) {
        int i = 0;
        try {
            ArrayList<String> list = new ArrayList<>();// new 一个list 存入堆中
            String a = "hello";
            while (true) {
                list.add(a);// 不断地向list 中添加 a
                a = a + a;
                i++;
            }
        } catch (Throwable e) {// list 使用结束,被jc 垃圾回收
            e.printStackTrace();
            System.out.println(i);
        }
    }
}

堆内存诊断

jps 工具

查看当前系统中有哪些 java 进程

image

jmap 工具

查看堆内存占用情况 jmap - heap 进程id

image

jconsole 工具

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

image

jvisualvm 工具

可视化的展示虚拟机的内容

image

方法区

方法区(Method Area) 是各个线程共享的内存区域,它用于存储已被虚拟机加载的类信息(比如class文件)、常量、静态变量、即时编译器编译后的代码等数据。(什么是类信息:类版本号、方法、接口。)

官方对于方法区的定义:https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-2.html

  • 1.6是永久代实现,使用的堆内存
  • 1.8是元空间实现,使用的本地内存

image

image

方法区内存溢出

  • 1.8以前会导致永久代内存溢出 java.lang.OutOfMemoryError: PermGen space
    • -XX:MaxPermSize=8m
  • 1.8以后会导致元空间内存溢出 java.lang.OutOfMemoryError: Metaspace
    • -XX:MaxMetaspaceSize=8m
/**
 * 演示元空间内存溢出 java.lang.OutOfMemoryError: Metaspace
 * -XX:MaxMetaspaceSize=8m
 */
public class Demo1_8 extends ClassLoader { // 可以用来加载类的二进制字节码
    public static void main(String[] args) {
        int j = 0;
        try {
            Demo1_8 test = new Demo1_8();
            for (int i = 0; i < 10000; i++, j++) {
                // ClassWriter 作用是生成类的二进制字节码
                ClassWriter cw = new ClassWriter(0);
                // 版本号, public, 类名, 包名, 父类, 接口
                cw.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, "Class" + i, null, "java/lang/Object", null);
                // 返回 byte[]
                byte[] code = cw.toByteArray();
                // 执行了类的加载
                test.defineClass("Class" + i, code, 0, code.length); // Class 对象
            }
        } finally {
            System.out.println(j);
        }
    }
}

运行时常量池

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

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

通过使用 javap 命令反编译 class 文件后,可以得到类的一些信息:

常量池:

image

HelloWorld 方法:

image

系统会在HelloWorld方法反编译后得到的指令,去常量池中查找,比如第0条指令,后面是 #2 ,则会在常量池中寻找,而常量池中的 #2 后面还有 #6.#20 也会依次寻找 #6#20

StringTable

  • 常量池中的字符串仅是符号,第一次用到时才变为对象
  • 利用串池的机制,来避免重复创建字符串对象
  • 字符串变量拼接的原理是 StringBuilder(1.8)
  • 字符串常量拼接的原理是编译期优化
  • 可以使用 intern 方法,主动将串池中还没有的字符串对象放入串池
    • 1.8 将这个字符串对象尝试放入串池,如果有则并不会放入,如果没有则放入串池, 会把串池中的对象返回
    • 1.6 将这个字符串对象尝试放入串池,如果有则并不会放入,如果没有会把此对象复制一份,放入串池,会把串池中的对象返回
常量池与串池的关系

常量池中的信息,都会被加载到运行时常量池中,这时的 a b ab 都还是常量池中的符号(没有成为java对象),只有在被用到的时候(类似懒加载机制),并且**串池(hashtable结构 不可扩容)**中不存在,才会被存入串池中。

String s1 = "a"; 
String s2 = "b";
String s3 = "ab";

image

所以当这三行代码都执行了之后,**串池(StringTable)**中的数据应该为:["a", "b", "ab"]

字符串变量拼接(1.8)

字符串变量之间的拼接,底层使用的StringBuilder类

String s4 = s1 + s2;   // new StringBuilder().append("a").append("b").toString()  new String("ab")
System.out.println(s3 == s4);   // false

image

StringBuilder类的toString方法底层使用的是 new String(xxx) ,所以产生的对象是在堆中,而s3对象在串池中,所以 s3 和 s4 不相等。

编译期优化
String s5 = "a" + "b";  // javac 在编译期间的优化,结果已经在编译期确定为ab
System.out.println(s3 == s5);    // ture

这里也能看到 s3 和 s5 指向的都是 #4,因为 "a" + "b" 是确定的,编译的时候会直接变成 "ab"

字符串加载延迟
System.out.println();  // 字符串个数 2256
System.out.print("1"); // 字符串个数 2257
System.out.print("2"); // 字符串个数 2258
System.out.print("3"); // 字符串个数 2259
System.out.print("4"); // 字符串个数 2260
System.out.print("1"); // 字符串个数 2260
System.out.print("2"); // 字符串个数 2260
System.out.print("3"); // 字符串个数 2260
System.out.print("4"); // 字符串个数 2260

字符串只有在被执行的时候,才会进入串池,如果串池中已经有了,就不会新添加。

intern方法(1.8)

将字符串对象尝试放入串池,如果有则并不会放入,如果没有则放入串池,会把串池中的对象返回。

  • 如果串池中没有这个字符串,将字符串对象放入串池,也就是说,放入的和返回的是同一个对象
  • 如果串池中有这个字符串,就直接返回串池中的对象,准备放入串池的对象和返回的不是同一个对象
String x = "ab";
String s = new String("a") + new String("b");
// 串池:ab,  a,  b
// 堆:new String("a"),  new String("b"),  new String("ab")

String s2 = s.intern();    // 因为ab已经在串池了,s对象放入串池失败,返回的s2是串池中的对象
System.out.println(s2 == x); // true
System.out.println(s == x);  // false

// 如果没有x变量,则 "ab" = s = s2
intern方法(1.6)

将这个字符串对象尝试放入串池,如果有则并不会放入,如果没有会把此对象复制一份,放入串池,会把串池中的对象返回。

复制的对象和原对象不是同一个对象

  • 如果串池中没有这个字符串,将字符串对象复制一份,复制的对象和原来的对象内存地址值是不一样的,放入的和返回的不是同一个对象
  • 如果串池中有这个字符串,就直接返回串池中的对象,准备放入串池的对象和返回的不是同一个对象
String s = new String("a") + new String("b");
// 串池:a,  b
// 堆:new String("a"),  new String("b"),  new String("ab")

String s2 = s.intern();   // s 拷贝一份,放入串池
String x = "ab";          // x 拿到的是串池中的对象

System.out.println(s2 == x);    // false
System.out.println(s == x);     // false

// 如果是jdk1.8,则不会拷贝, s = s2 = x
StringTable位置
  • JDK1.6,StringTable是属于常量池的一部分。
  • JDK1.8,StringTable是放在中的。
StringTable垃圾回收

StringTable在内存紧张时,会触发垃圾回收,回收那些没有被引用的字符串。

StringTable性能调优

串池的底层用的是HashTable,数组+链表的数据结构

使用 -XX:+PrintStringTableStatistics 参数可以打印串池的信息:

StringTable statistics:
Number of buckets       :     60013 =    480104 bytes, avg   8.000
Number of entries       :    481491 =  11555784 bytes, avg  24.000
Number of literals      :    481491 =  29750584 bytes, avg  61.788
Total footprint         :           =  41786472 bytes
Average bucket size     :     8.023
Variance of bucket size :     8.084
Std. dev. of bucket size:     2.843
Maximum bucket size     :        23

可以看到,默认的数组大小为 60013 个,串池中的字符串的数量为 481491 个。

如果系统中字符串用到的比较多的话,可以适当的将串池的数组长度调大:

-XX:StringTableSize=桶个数

桶个数应在1009以上。

当桶的个数变多时,Hash碰撞的几率就变小,链表的长度会变短,因为HashTable中的值是不重复的,链表变短后,校验字符串是否重复的时间会变短,从而提升效率。

可以通过intern方法减少重复入池,保证相同的字符串在StringTable中只存储一份:

List<String> address = new ArrayList<>();
for (int i = 0; i < 10; i++) {
    try (BufferedReader reader = new BufferedReader(/* 此处读取文件... */)) {
        String line;
        while (true) {
            line = reader.readLine();
            if (line == null) {
                break;
            }
            address.add(line/*.intern()*/);
        }
    }
}

在这种情况下使用intern方法,占用内存的大小会比不使用intern方法占用内存的大小 小得多。

追溯到readLine底层,使用的是new String来构建字符串的,所以直接是存放在堆内存中,如果不使用intern方法,则所有的字符串对象都在堆内存中,而使用后剩余9次循环添加到集合的对象则是串池中的对象,理论上节约了十分之九的内存。

直接内存

Direct Memory

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

普通的IO:

读入文件会先将文件放入系统的内存,再将文件放入Java的堆内存,Java才能读取,比较浪费时间、浪费性能。

image

NIO:

开辟一块系统和Java都能访问到的内存区域,无需将文件再次缓冲到Java的堆内存当中,提高效率。

image

直接内存也会导致内存溢出,比如运行下面的代码:

static int _100Mb = 1024 * 1024 * 100;
public static void main(String[] args) {
    List<ByteBuffer> list = new ArrayList<>();
    int i = 0;
    try {
        while (true) {
            ByteBuffer byteBuffer = ByteBuffer.allocateDirect(_100Mb);
            list.add(byteBuffer);
            i++;
        }
    } finally {
        System.out.println(i);
    }
}

可以看到下面的结果:

image

分配和回收原理

直接内存的回收不是通过JVM的垃圾回收来释放的,而是通过 unsafe.freeMemory() 方法来手动释放

import sun.misc.Unsafe;

Unsafe unsafe = getUnsafe();    // Java内部使用的对象,可以通过反射获取对象
// 分配内存 1Gb = 1024 * 1024 * 1024
long base = unsafe.allocateMemory(_1Gb);
unsafe.setMemory(base, 1024 * 1024 * 1024, (byte) 0);
// 释放内存
unsafe.freeMemory(base);

而NIO中的ByteBuffer类就是用到了该原理:

  1. 在DirectByteBuffer类(ByteBuffer的子类)的构造器中,使用了 unsafe.allocateMemory(size) 来获取内存空间
  2. ByteBuffer的实现类内部,使用了Cleaner(虚引用类型)对象来监测ByteBuffer对象是否被回收
  3. 如果被回收,则会触发Cleaner对象的 clean() 方法
  4. clean() 方法又会调用创建Cleaner时传入的Deallocator对象(该对象实现了Runnable接口,是一个单独的线程,用来调用 unsafe.freeMemory(address) 方法)

Demo:

ByteBuffer byteBuffer = ByteBuffer.allocateDirect(1024 * 1024 * 1024);
System.out.println("分配完毕...");
System.out.println("开始释放...");
byteBuffer = null;
System.gc(); // 显式的垃圾回收,把byteBuffer对象回收掉,然后会自动触发Cleaner的clean()方法
System.in.read();

禁用显式回收对直接内存的影响

可以使用 -XX:+DisableExplicitGC 命令来显式的禁用代码中的 System.gc() 作用(使用该方法影响性能,不光要回收新生代,还有老年代)。

但是如果禁用掉,上面的Demo中的ByteBuffer对象则会长时间存在,程序占用的1Gb的直接内存也不会释放。

此时,建议使用Unsafe类的 freeMemory() 方法手动释放直接内存。

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:/a/340695.html

如若内容造成侵权/违法违规/事实不符,请联系我们进行投诉反馈qq邮箱809451989@qq.com,一经查实,立即删除!

相关文章

141基于matlab的齿轮系统非线性动力学特性分析

基于matlab的齿轮系统非线性动力学特性分析&#xff0c;综合考虑齿侧间隙、时变啮合刚度、综合啮合误差等因素下&#xff0c;参数阻尼比变化调节下&#xff0c;输出位移、相图、载荷、频率幅值结果。程序已调通&#xff0c;可直接运行。 141 matlab齿轮非线性动力学 (xiaohongs…

基于Altium Designer 10设计双层印刷电路板的详细步骤

基于Altium Designer 10设计双层印刷电路板的详细步骤 一、基于Altium Designer 10设计双层印刷电路板总纲二、、基于Altium Designer 10设计双层印刷电路原理图三、制作集成库(包括原理图、PCB封装库、PCB 3D库)1、新建集成库2、新建原理图库3、绘制原理图库(1)、手工绘制…

网络数据传输过程

先验知识&#xff1a;OSI模型 OSI网络模型实际上是参考模型&#xff0c;在实际中并不使用&#xff0c;在网络出现问题的时候&#xff0c;可以从一个宏观的整体去分析和解决问题&#xff0c;而且搭建网络的时候并不需要划分为7层&#xff0c;当今互联网广泛使用的是TCP/IP网络模…

【Linux驱动】休眠与唤醒 | POLL机制 | 异步通知 | 阻塞与非阻塞 | 软件定时器

&#x1f431;作者&#xff1a;一只大喵咪1201 &#x1f431;专栏&#xff1a;《Linux驱动》 &#x1f525;格言&#xff1a;你只管努力&#xff0c;剩下的交给时间&#xff01; 目录 &#x1f3d3;休眠与唤醒&#x1f3f8;内核函数&#x1f3f8;驱动框架及编程 &#x1f3d3;…

《WebKit 技术内幕》学习之五(1): HTML解释器和DOM 模型

第五章 HTML 解释器和 DOM 模型 1.DOM 模型 1.1 DOM标准 DOM &#xff08;Document Object Model&#xff09;的全称是文档对象模型&#xff0c;它可以以一种独立于平台和语言的方式访问和修改一个文档的内容和结构。这里的文档可以是 HTML 文档、XML 文档或者 XHTML 文档。D…

java数组ArrayList(存对象)

1、dade文件 package model;public class dade {private int id;private String name;public dade() {}public dade(int id, String name) {this.id id;this.name name;}public int getId() {return id;}public void setId(int id) {this.id id;}public String getName() {…

透明拼接屏代工:专业制造与质量保证

透明拼接屏代工是指专业的代工厂家根据客户的需求&#xff0c;为其生产透明拼接屏产品。随着透明拼接屏市场的不断扩大&#xff0c;越来越多的企业选择通过代工方式快速进入市场。尼伽小编将深入探讨透明拼接屏代工的优势、选择合适的代工厂家以及质量保证等方面的内容。 一、透…

枚举算法(穷举法)(暴力法)

1.什么是枚举 枚举是指在一定范围内将所有情况一一列举&#xff0c;再通过条件判断得到自己想要的答案&#xff1b; 2.枚举核心 3.使用枚举的基本步骤 4.例题 4.1.我国古代数学家张丘建在他的《算经》一书中提出了著名的“百钱买百鸡”问题:鸡翁一值钱五;鸡母一值钱三;鸡雏三…

数组A[m+n]中存放了两个线性表(a1,a2,.....am)和(b1,b2.....bn),将数组中的两个线性表的位置互换,要求空间复杂度为1

要求空间复杂度为O(1)&#xff0c;那么不可以借助辅助数组来完成此操作 算法思路&#xff1a;可先将此数组逆置变成bn,......b1,am,....,a1&#xff0c;然后分别逆转两个线性表的数据元素 算法实现 1、定义一个函数&#xff0c;该函数的功能是可以对一个数组的任意连续的部分进…

【Web前端开发基础】CSS的结构伪类选择器、伪元素、浮动

CSS的浮动 目录 CSS的浮动一、学习目标二、文章内容2.1 结构伪类选择器2.2 伪元素2.3 标准流2.4 浮动2.5 清除浮动2.6 拓展&#xff08;BFC&#xff09; 三、综合案例3.1 小米模块案例3.2 网页导航案例 一、学习目标 能够使用结构伪类选择器在HTML中选元素能够说出标准流元素的…

03-常用编程概念

上一篇&#xff1a;02-编程猜谜游戏 本章介绍几乎所有编程语言中都会出现的概念&#xff0c;以及它们在 Rust 中的工作原理。许多编程语言的核心都有许多共同点。本章介绍的概念都不是 Rust 独有的&#xff0c;但我们会在 Rust 的上下文中讨论这些概念&#xff0c;并解释使用这…

Java封装字符串的类和异常

1.API 1.1 API概述-帮助文档的使用 什么是API API (Application Programming Interface) &#xff1a;应用程序编程接口 java中的API 指的就是 JDK 中提供了各种功能的 Java类&#xff0c;这些类将底层的实现封装了起来&#xff0c;我们不需要关心这些类是如何实现的&#xf…

深入剖析 Git 对象底层原理

一、引言 在我们日常使用 Git 时&#xff0c;通常的操作是&#xff1a; 在写完一段代码后&#xff0c;执行 git add命令&#xff0c;将这段代码添加到暂存区中然后再执行 git commit和 git push 命令&#xff0c;将 本地 Git 版本库中的提交同步到服务器中的版本库中 Git 在…

10分钟快速上手LLM大模型Python前端开发(三)之显示模块(二)

【计划昵称全网统一&#xff0c;代码随想随记&#xff0c;知乎无法立即修改&#xff0c;&#xff0c;】 微信公众号&#xff1a;leetcode_algos_life&#xff0c;代码随想随记 小红书&#xff1a;412408155 CSDN&#xff1a;https://blog.csdn.net/woai8339?typeblog &#xf…

服务器管理平台(5)- 数据展示

数据展示 Grafana导入MySQL数据源进行定制化数据展示&#xff0c;包括品牌分类饼图&#xff0c;详细数据列表等LayUI为开源前端框架&#xff0c;对系统概览、登录日志等信息&#xff0c;划分不同页面使用表格展示详细数据 1、Grafana 对品牌、CPU型号、内存等数据使用饼图展示…

力扣hot100 分割等和子集 变形01背包 滚动数组优化

Problem: 416. 分割等和子集 文章目录 思路&#x1f496; 01背包复杂度Code &#x1f496; 滚动数组优化复杂度Code 思路 &#x1f468;‍&#x1f3eb; 参考地址 &#x1f496; 01背包 复杂度 时间复杂度: O ( n m ) O(nm) O(nm)&#xff1a; m m m为数组元素和的一半 空…

支付宝:多线程事务怎么回滚?说用 @Transactional 可以回去等通知了!

1&#xff0c;最近有一个大数据量插入的操作入库的业务场景&#xff0c;需要先做一些其他修改操作&#xff0c;然后在执行插入操作&#xff0c;由于插入数据可能会很多&#xff0c;用到多线程去拆分数据并行处理来提高响应时间&#xff0c;如果有一个线程执行失败&#xff0c;则…

【Android】TypedArray的使用

介绍 看电池电量组件BatteryMeterView的时候看到的。 Array是个数组&#xff0c;所有TypedArray也是个容器&#xff0c;基本是用于自定义View里面的&#xff08;至少我目前见过的全部都在自定义View里面&#xff09;。 使用 1.自定义View public class RoundSeekbarView e…

vivado 预设文件、IP设置(_P)、用户参数、以太网时钟处理、GT位置限制、当前可识别板的IP列表

了解预设文件 预设文件有助于在特定配置中自定义IP核心。PS7、axi_emc和当linear_flash或DDR3_SDRAM 界面是在Vivado IP集成商的Board选项卡中选择的。预设文件使用XML格式。preset_file是为特定的Board文件定义的&#xff0c;可以是用于将预设应用于多个IP。 <ip_presets…