内存结构
程序计数器
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TGivmdmR-1648738783843)(C:\Users\maybe3032\AppData\Roaming\Typora\typora-user-images\image-20220314214305600.png)]
定义
Program Counter Register 程序计数器 （寄存器）
-
作用，是记住下一条jvm指令的执行地址
-
特点
- 是线程私有的
- CPU会为每个线程分配时间片，当当前线程的时间片使用完后，CPU就会去执行另一个线程中的代码
- 程序计数器是每个线程所私有的，当另一个线程的时间片用完，又返回来执行当前线程的代码时，通过程序计数器可以知道应该执行哪一句指令
- 不会存在内存溢出
补充：
- 是一块较小的内存空间
- 线程私有，随着线程创建而创建，随着线程销毁而销毁
- 是线程私有的
作用
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bMAnLWlO-1648738783844)(C:\Users\maybe3032\AppData\Roaming\Typora\typora-user-images\image-20220314215247384.png)]
虚拟机栈
Java Virtual Machine Stacks (Java虚拟机栈)
定义
- 每个线程运行时所需要的内存空间，称为虚拟机栈
- 每个栈由多个栈帧（Frame）组成，对应着每次方法调用时所占用的内存
- 每个线程只能有一个活动栈帧，对应着当前正在执行的那个方法
- 指的就是处于栈顶正在执行的那个方法
代码
public class Main {
public static void main(String[] args) {
method1();
}
private static void method1() {
method2(1, 2);
}
private static int method2(int a, int b) {
int c = a + b;
return c;
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FafydueV-1648738783845)(C:\Users\maybe3032\AppData\Roaming\Typora\typora-user-images\image-20220314222417535.png)]
· 在控制台中可以看到，主类中的方法在进入虚拟机栈的时候，符合栈的特点（先进后出）
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jp1Im2ge-1648738783845)(C:\Users\maybe3032\AppData\Roaming\Typora\typora-user-images\image-20220314221222747.png)]
问题辨析
-
垃圾回收是否涉及栈内存
- 不需要。因为虚拟机栈中是由一个个栈帧组成的，在方法执行完毕后，对应的栈帧就会被弹出栈。所以无需通过垃圾回收机制去回收内存
-
栈内存的分配越大越好吗？
- 不是，因为物理内存是一定的，栈内存越大，可以支持更多的递归调用，但是可执行的线程就会更少
-
方法内的局部变量是否线程安全？
- 如果方法内局部变量没有逃离方法的作用范围，则是线程安全的
public static void m1{ StringBuilder sb =new StringBuilder(); sb.append(1); sb.append(2); sb.append(3); System.out.println(sb.toString()); // sb局部变量并没有逃离方法，线程安全 }- 如果如果局部变量引用了对象，并逃离了方法的作用范围，则需要考虑线程安全问题
public static void m3{ StringBuilder sb =new StringBuilder(); sb.append(1); sb.append(2); sb.append(3); return sb; // sb逃离了方法的作用范围,可能出现线程安全问题 }
栈内存溢出
-
栈帧过多导致栈内存溢出（无线递归）
/** *演示栈内存溢出 java.lang.StackOverflowError * Xss256K :通过虚拟机参数设置栈内存大小 */ public static void main(String[] args){ try{ method1(); }catch (Throwable e){ e.rpintStackTrace(); System.out.println(count) } } private static void method1(){ count++; method1(); }[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MKLKqQjB-1648738783846)(C:\Users\maybe3032\AppData\Roaming\Typora\typora-user-images\image-20220314225355405.png)]
-
栈帧过大导致栈内存溢出（比较少出现）
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0LBoEGmP-1648738783847)(C:\Users\maybe3032\AppData\Roaming\Typora\typora-user-images\image-20220314225418673.png)]
线程运行诊断
案例一：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进制的，需要转换
案例二：程序运行很长时间没有结果
- 死锁
本地方法栈
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xfN9mU3W-1648738783848)(C:\Users\maybe3032\AppData\Roaming\Typora\typora-user-images\image-20220321222424277.png)]
- 一些带有native关键字的方法就是需要JAVA去调用本地的C或者C++方法，因为JAVA有时候没法直接和操作系统底层交互，所以需要用到本地方法
- java虚拟机调用本地方法的时候，给本地方法提供的内存空间
- 本地方法：native method，不是由java代码编写的代码。（例如Object类中有很多的本地方法）
Heap 堆
定义
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jf7mCKlQ-1648738783848)(C:\Users\maybe3032\AppData\Roaming\Typora\typora-user-images\image-20220321222819624.png)]
- 通过new关键字，创建对象都会使用堆内存
特点
- 它是线程共享的，堆中对象都需要考虑线程安全的问题
- 有垃圾回收机制
堆内存溢出
- java.lang.OutofMemoryError ：java heap space. 堆内存溢出
/**
* 演示堆内存溢出 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进程
- jmap工具
- 查看堆内存占用情况 jmap - heap 进程id
- jconsole工具
- 图形界面的，多功能的检测工具，可以连续监测
案例：
- 垃圾回收后，内存占用仍然很高
- jvisualvm
方法区
定义
- 方法区是各个线程共享的内存区域，它用于**存储已被虚拟机加载的类信息(比如class文件)、常量、静态变量、即时编译器编译后的代码等数据。（**什么是类信息：类版本号、方法、接口。）
结构
- 永久代用的堆内存，
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PGncLlOa-1648738783848)(C:\Users\maybe3032\AppData\Roaming\Typora\typora-user-images\image-20220322213521118.png)]
- 元空间用的本地内存，StringTable被放入了Heap堆中
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-h5Imykm6-1648738783849)(C:\Users\maybe3032\AppData\Roaming\Typora\typora-user-images\image-20220322213537936.png)]
方法区内存溢出
-
1.8以前会导致永久代内存溢出
-
演示永久代内存溢出 java.lang.OutOfMemoryError: PermGen space
-
-XX: MaxPermSize=8m
-
-
1.8后会导致元空间内存溢出
- 演示元空间内存溢出:java.lang.OutOfMemoryError: Metaspace
- -XX:MaxMetaspaceSize=8m
- 调整虚拟机参数
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-M1xUFhzt-1648738783849)(C:\Users\maybe3032\AppData\Roaming\Typora\typora-user-images\image-20220322214737449.png)]
/**
* 演示元空间内存溢出:java.lang.OutOfMemoryError: Metaspace
* -XX:MaxMetaspaceSize=8m
*/
public class main1 extends ClassLoader {//可以用来加载类的二进制字节码
public static void main(String[] args) {
int j = 0;
try {
main1 test = new main1();
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);
}
} finally {
System.out.println(j);
}
}
}
//-----------------------------------------------------------------------------------
Exception in thread "main" java.lang.OutOfMemoryError: Metaspace
at java.lang.ClassLoader.defineClass1(Native Method)
at java.lang.ClassLoader.defineClass(ClassLoader.java:763)
at java.lang.ClassLoader.defineClass(ClassLoader.java:642)
at com.itcast.itheima.xpp.main1.main(main1.java:26)
4865
Process finished with exit code 1
场景
- spring
- mybatis
运行时常量池
-
通过反编译来查看类的信息
-
获得对应类的.class文件，
javac xxx.java -
在JDK对应的bin目录下运行cmd，也可以在IDEA控制台输入
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OSUvOwzP-1648738783850)(C:\Users\maybe3032\AppData\Roaming\Typora\typora-user-images\image-20220322215908410.png)]
- 输入 javac 对应类的绝对路径
C:\JAVA\JDK8.0\bin>javac C:\xxx\src\com\xxx\xxx\xxx\Main.java- 输入完成后，对应的目录下就会出现类的.class文件
- 在控制台输入
javap -v 类的绝对路径
javap -v C:\xxx\src\com\xxx\xxx\xxx\Main.java- 然后能在控制台看到反编译以后类的信息了
-
-
类的基本信息
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3CKPe0eU-1648738783850)(C:\Users\maybe3032\AppData\Roaming\Typora\typora-user-images\image-20220322220119895.png)]
- 常量池
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WnDVMMqe-1648738783851)(C:\Users\maybe3032\AppData\Roaming\Typora\typora-user-images\image-20220322220136920.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GJazo772-1648738783851)(C:\Users\maybe3032\AppData\Roaming\Typora\typora-user-images\image-20220322220143924.png)]
- 虚拟机中执行编译的方法（框内的是真正编译执行的内容，#号的内容需要在常量池中查找）
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-g3iPxZ4C-1648738783852)(C:\Users\maybe3032\AppData\Roaming\Typora\typora-user-images\image-20220322220207427.png)]
- 常量池：就是一张表，虚拟机指令根据这张常量表找到要执行的类名、方法名、参数类型、字面量等信息
- 运行时常量池：常量池是 *.class 文件中的，当该类被加载，它的常量池信息就会放入运行时常量池，并把里面的符号地址变为真实地址
StringTable
StringTable面试题
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eA4bfFTf-1648738783852)(C:\Users\maybe3032\AppData\Roaming\Typora\typora-user-images\image-20220322220547244.png)]
// StringTable ["a","b","ab"] hashtable结构，不能扩容
public class StringTableStudy {
//常量池中的信息，都会被加载到运行常量池中，这时a，b，ab都常量池中的符号，还没有变为java字符串对象
//ldc #2 会把 a符号变为"a"字符串对象
//ldc #3 会把 b符号变为"b"字符串对象
//ldc #4 会把 ab符号变为"ab"字符串对象
public static void main(String[] args) {
String s1 = "a"; //懒惰机制，会先访问一次StringTable，发现没有后才会添加字符串对象
String s2 = "b";
String s3 = "ab";
String s4= s1+s2; //new StringBuilder().append("a").append("b").toString()-->new String("ab"), s1和s2是变量，只可能会发生变化
String s5= "a" + "b";//javac在编译间的优化，结果已经在编译期确认为ab了。s5在StringTable找到了“ab”，不需要再添加
String s6=s4.intern();//将这个字符串对象尝试放入串池，如果有则不会放入，如果没有则放入串池，会把串池的对象返回
System.out.println(s3 == s4 )//答案是false, s4 new出来的对象是放在堆中的，s3放入堆中的在串池中的。存的是对象的地址值，它们引用不同的对象，地址不同，所以是false
System.out.println(s3 == s5 )//true，s5使用的就是常量池中的元素，所以它们的地址都是一样的
System.out.println(s3 == s6 )//true,s4.intern()返回的是常量池的中的元素，所以地址都是一样的
String x2 = new String("c")+new String("d");// new String("cd"),堆中的元素
String x1="cd"; //储存于常量池中
x2.intern();//因为"cd"已经存储在常量池中了，所以无法存储进常量池
x3=x2.intern();//如果是x3的话，则会返回常量池的元素
System.out.println(x1 == x2 )//false，一个存储在常量池中，一个存储在堆中，地址不同
//如果String x1="cd";和x2.intern();调换了位置的，则是true，因为x2的cd被放入了常量池中，所以x1不会再放入常量池
//更换顺序后，如果是jdk1.6的话，还是false，x2.intern创建的是副本，而x2还是存放在堆中的，地址不同
}
}
字符串延迟加载
/**
*演示字符串字面量也是【延迟】成为对象的
*/
public class TestString{
public static void main(String[] args){
int x = args.length;
System.out.println(); //字符串个数 2275
System.out.println(1);
System.out.println(2);
System.out.println(3);
System.out.println(4);
System.out.println(5);
System.out.println(6);
System.out.println(7);
System.out.println(8);
System.out.println(9);
System.out.println(0);
System.out.println(1); //字符串个数 2285
System.out.println(2);
System.out.println(3);
System.out.println(4);
System.out.println(5);
System.out.println(6);
System.out.println(7);
System.out.println(8);
System.out.println(9);
System.out.println(0);
System.out.println(x); //字符串个数 2285,因为常量池已经添加了，所以不会再添加
}
}
StringTable特性
- 常量池的字符串仅是符号，第一次用到时才会变成对象
- 利用串池的机制，来避免重新创建字符串对象
- 字符串变量拼接的原理是StringBuilder（1.8）
- 字符串常量拼接的原理是编译期优化
- 可以使用intern方法，主动将串池中还没有的字符串对象放入串池
- 1.8将这个字符串对象尝试放入串池，如果有则并不会放入，如果没有则放入串池，会把串池中的对象返回
- 1.6将这个字符串对象尝试放入串池，如果有则并不会放入，如果没有会把此对象复制一份，放入串池，会把串池中的对象返回
public class Demo{
//{"ab","a","b"}
public static void main(String[] args) {
String x = "ab";
String s = new String("a")+new String("b");
// 堆 new String("a") new String("b") new String("ab")
String s2=s.intern();//将这个字符串对象尝试放入串池，如果有则不会放入，如果没有则放入串池，会把串池的对象返回
System.out.println(s2 == x);// true, 字符串对象已经有了，所以不会被放入，s2返回的是串池中的对象，所以它们都是相同的
System.out.println(s == x);// false，s指的是new String("b")放入的地址
}
}
StringTable位置
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-o43vXt9W-1648738783853)(C:\Users\maybe3032\AppData\Roaming\Typora\typora-user-images\image-20220323212743803.png)]
- JDK1.6 时，StringTable是属于常量池的一部分，占用的永久代空间。
- 会出现java.lang.OutOfMemoryError: PermGen spcae
- JDK1.8 以后，StringTable是放在堆中的。
- 会出现java.lang.OutOfMemoryError: Java heap space
StringTable 垃圾回收
StringTable在内存紧张时，会发生垃圾回收
StringTable 性能调优
- 因为StringTable是由HashTable实现的，所以可以适当增加HashTable桶的个数，来减少字符串放入串池所需要的时间，减少哈希碰撞
-XX:StringTableSize=xxxx
//最低为1009
- 考虑将字符串对象是否放入池
- 可以通过intern方法减少重复入池，保证相同的地址在StringTable中只存储一份
直接内存
定义
-
Direct Memory
- 常见于NIO操作时，用于数据缓冲区
- 分配回收成本较高，但读写性能高
- 不受JVM内存回收管理
- 操作系统的内存
-
文件读取过程：
- 会先从系统缓存区再到java 缓冲区byte[]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AoKqInaW-1648738783853)(C:\Users\maybe3032\AppData\Roaming\Typora\typora-user-images\image-20220323221224532.png)]
-
使用了DirectBuffer
- 直接内存是操作系统和Java代码都可以访问的一块区域，无需将代码从系统内存复制到Java堆内存，从而提高了效率
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jlbFo2BV-1648738783854)(C:\Users\maybe3032\AppData\Roaming\Typora\typora-user-images\image-20220323221307942.png)]
内存溢出
- 直接内存也会导致内存溢出
public class Main {
static int _100MB = 1024 * 1024 * 100;
public static void main(String[] args) throws IOException {
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);
}
}
}
/**输出：--------------------------------------------------------------------------------
2
Exception in thread "main" java.lang.OutOfMemoryError: Direct buffer memory 内存溢出
at java.nio.Bits.reserveMemory(Bits.java:694)
at java.nio.DirectByteBuffer.<init>(DirectByteBuffer.java:123)
at java.nio.ByteBuffer.allocateDirect(ByteBuffer.java:311)
at main.Main.main(Main.java:19)
*/
释放原理
- 直接内存的回收不是通过JVM的垃圾回收来释放的，而是通过
unsafe.freeMemory来手动释放 - 通过申请直接内存，但JVM并不能回收直接内存中的内容，它是如何实现回收的呢？
//通过ByteBuffer申请1M的直接内存
ByteBuffer byteBuffer = ByteBuffer.allocateDirect(_1M);
- 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 来释放直接内存
-
一般我们会将java代码中的显示回收关闭
-XX: +DisableExplicitGc 显式的 System.gc();//显式的垃圾回收，Full GC不推荐使用 -
建议使用unsafe.freeMemory(address)
372
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
