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 中添加 aa = 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() 方法手动释放直接内存。

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

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

文心一言 v.s. ChatGPT：多角度对比测评“追赶者”能否超越？

文心一言 v.s. ChatGPT：多角度对比测评“追赶者”能否超越？

ChatGPT自发布以来就引发了关注热潮&#xff0c;如今国内大模型的发展也是如火如荼、百花齐放&#xff1a;比如百度的文心一言、阿里的通义千问、讯飞的星火大模型等等&#xff0c;那么作为后起之秀的国内大模型与ChatGPT相比哪个更好用呢&#xff1f;“追赶者”能否实现超越&a…
阅读更多...
2.服务拆分和远程调用

2.服务拆分和远程调用

2.服务拆分和远程调用 任何分布式架构都离不开服务的拆分&#xff0c;微服务也是一样。 2.1.服务拆分原则 这里我总结了微服务拆分时的几个原则&#xff1a; 不同微服务&#xff0c;不要重复开发相同业务微服务数据独立&#xff0c;不要访问其它微服务的数据库微服务可以将…
阅读更多...
合并K个升序链表（LeetCode 23）

合并K个升序链表（LeetCode 23）

文章目录 1.问题描述2.难度等级3.热门指数4.解题思路方法一&#xff1a;顺序合并方法二&#xff1a;分治合并方法三&#xff1a;使用优先队列合并 参考文献 1.问题描述 给你一个链表数组&#xff0c;每个链表都已经按升序排列。 请你将所有链表合并到一个升序链表中&#xff…
阅读更多...
代码随想录算法训练营第27天 | 39.组合总和 + 40.组合总和II + 131.分割回文串

代码随想录算法训练营第27天 | 39.组合总和 + 40.组合总和II + 131.分割回文串

今日任务 39. 组合总和 40.组合总和II 131.分割回文串 39.组合总和 - Medium 题目链接&#xff1a;力扣&#xff08;LeetCode&#xff09;官网 - 全球极客挚爱的技术成长平台 给你一个 无重复元素 的整数数组 candidates 和一个目标整数 target &#xff0c;找出 candidates 中…
阅读更多...
thinkphp+mysql高校跳蚤二手市场交易系统vue

thinkphp+mysql高校跳蚤二手市场交易系统vue

商品信息是卖家供应用户必不可少的一个部分。在跳蚤市场发展的整个过程中&#xff0c;商品担负着最重要的角色。为满足如今日益复杂的管理需求&#xff0c;各类管理系统程序也在不断改进。本课题所设计的普通高校网上跳蚤市场&#xff0c;使用Thinkphp5框架&#xff0c;php语言…
阅读更多...
防火墙路由模式简易拓扑

防火墙路由模式简易拓扑

拓扑如下 需求&#xff1a; 防火墙向下使用子接口分别对应生产区和办公区所有分区设备可以ping同网关 由于防火墙策略和NAT还没有学习&#xff0c;所以先实现简单需求 实验拓扑实现 IP地址规划&#xff1a; 生产区&#xff1a;10.0.1.0/24&#xff0c;网关10.0.1.1&#x…
阅读更多...
探针-LinkAgent

探针-LinkAgent

探针-LinkAgent
阅读更多...
0121-2-JavaScript高级程序设计1-10章

0121-2-JavaScript高级程序设计1-10章

前言 通过阅读这本书写下的一些笔记 《JavaScript高级程序设计》 第1章——什么是JavaScript DOM将整个页面抽象为一组分层节点。 BOM用于支持访问和操作浏览器的窗口。 第2章——HTML中的JavaScript 2.1 < script >元素 元素描述async立即开始下载脚本&#xff0…
阅读更多...
【Leetcode 144.二叉树的前序遍历】将二叉树每个节点的值以前序遍历的顺序存入数组中

【Leetcode 144.二叉树的前序遍历】将二叉树每个节点的值以前序遍历的顺序存入数组中

int* preorderTraversal( struct TreeNode*root, int* returnSize) { }解答代码&#xff1a; int TreeSize(struct TreeNode*root){return rootNULL?0:TreeSize(root->left)TreeSize(root->right)1;}void Prevorder(struct TreeNode*root,int*a,int*pi){if(rootNULL)re…
阅读更多...
透明拼接屏代工：专业制造与质量保证

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

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

深度学习-卷积神经网络

图像卷积运算 对图像矩阵与滤波器矩阵进行对应相乘再求和运算&#xff0c;转化得到新的矩阵。 作用&#xff1a;快速定位图像中某些边缘特征 英文&#xff1a;convolition 将图片与轮廓滤波器进行卷积运算&#xff0c;可快速定位固定轮廓特征的位置 卷积神经网络的核心 计算…
阅读更多...
代码随想录 Leetcode1047. 删除字符串中的所有相邻重复项

代码随想录 Leetcode1047. 删除字符串中的所有相邻重复项

题目&#xff1a; 代码(首刷自解 2024年1月21日&#xff09;&#xff1a; class Solution { public:string removeDuplicates(string s) {if (s.size() < 2) return s;stack<char> t;for (int i 0; i < s.size(); i) {if (t.empty()) t.push(s[i]);else {if (s[i…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023