【JVM】内存结构
文章目录
- JVM-内存结构
-
- 1.程序计数器
-
- 1-1 定义
- 1-2 作用
- 1-3 特点
- 2.虚拟机栈
-
- 2-1 定义
- 2-2 演示
- 2-3 常见问题
- 2-4 栈内存溢出
- 2-5 线程运行诊断
- 3.本地方法栈
- 4.堆
-
- 4-1 定义
- 4-2 特点
- 4-3 堆内存溢出
- 4-4 堆内存诊断
- 5.方法区
-
- 5-1 定义
- 5-2 结构
- 5-3 方法区内存溢出
- 5-4 通过反编译来查看类的信息
- 5-5 运行时常量池
- 5-6 常量池与串池StringTable的关系
- 5-7 StringTable 位置
- 5-8 StringTable 垃圾回收
- 5-9 StringTable 性能调优
- 6.直接内存
-
- 6-1 定义
- 6-2 分配和回收原理
JVM-内存结构
本文章参考：黑马程序员JVM
整体架构：
1.程序计数器
1-1 定义
Program Counter Register 程序计数器（寄存器）
1-2 作用
用于保存JVM中下一条所要执行的指令的地址。
PC 寄存器用来存储指向下一条指令的地址，即将要执行的指令代码。由执行引擎读取下一条指令。
1-3 特点
- 是线程私有的
- CPU会为每个线程分配时间片，当当前线程的时间片使用完以后，CPU就会去执行另一个线程中的代码
- 程序计数器是每个线程所私有的，当另一个线程的时间片用完，又返回来执行当前线程的代码时，通过程序计数器可以知道应该执行哪一句指令
- 不会存在内存溢出
2.虚拟机栈
2-1 定义
- 每个线程运行需要的内存空间，称为虚拟机栈
- 每个栈由多个栈帧组成，对应着每次方法调用时所占用的内存空间
- 每个线程只能有一个活动栈帧，对应当前正在执行的那个方法
2-2 演示
public class main1 {
public static void main(String[] args) {
method1();
}
public static void method1() {
method2(1, 2);
}
public static int method2(int a, int b) {
int c = a + b;
return c;
}
}
2-3 常见问题
-
垃圾回收是否涉及栈内存？
不需要。因为虚拟机栈中是由一个个栈帧组成的，在方法执行完毕后，对应的栈帧就会被弹出栈。所以无需通过垃圾回收机制去回收内存。
-
栈内存分配越大越好吗？
不是。因为物理内存是一定的，栈内存越大，可以支持更多的递归调用，但是可执行的线程数就会越少。
-
方法内的局部变量是否线程安全？
- 如果方法内部局部变量没有逃离方法的作用访问，它是线程安全的
- 如果是局部变量引用了对象，并逃离方法的范围，需要考虑线程安全问题
例如：
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; } }
2-4 栈内存溢出
Java.lang.stackOverflowError 栈内存溢出
导致栈内存溢出的情况：
- 栈帧过多导致栈内存溢出
- 栈帧过大导致栈内存溢出
设置虚拟机栈内存大小：
2-5 线程运行诊断
案例：CPU占用过高
Linux环境下运行某些程序的时候，可能导致CPU的占用过高，这时需要定位占用CPU过高的线程
- 用
top定位哪个进程对cpu的占用过高 ps H -eo pid,tid,%cpu | grep 进程id，刚才通过top查到的进程号，用ps命令进一步定位是哪个线程引起的cpu占用过高jstack 进程id，通过查看进程中的线程的nid，刚才通过ps命令看到的tid来对比定位，注意jstack查找出的线程id是16进制的，需要转换
3.本地方法栈
一些带有native关键字的方法就是需要JAVA去调用本地的C或者C++方法，因为JAVA有时候没法直接和操作系统底层交互，所以需要用到本地方法。
4.堆
4-1 定义
通过new关键字创建的对象都会使用堆内存
4-2 特点
- 它是线程共享的，堆中对象都需要考虑线程安全的问题
- 有垃圾回收机制
4-3 堆内存溢出
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);
}
}
}
结果：
java.lang.OutOfMemoryError: Java heap space
at java.util.Arrays.copyOf(Arrays.java:3332)
at java.lang.AbstractStringBuilder.ensureCapacityInternal(AbstractStringBuilder.java:124)
at java.lang.AbstractStringBuilder.append(AbstractStringBuilder.java:448)
at java.lang.StringBuilder.append(StringBuilder.java:136)
at com.itcast.itheima.xpp.main1.main(main1.java:14)
22
4-4 堆内存诊断
-
jps 工具
查看当前系统中有哪些 java 进程
-
jmap 工具
查看堆内存占用情况
jmap - heap 进程id -
jconsole 工具
图形界面的，多功能的监测工具，可以连续监测
5.方法区
5-1 定义
方法区是各个线程共享的内存区域，它用于**存储已被虚拟机加载的类信息(比如class文件)、常量、静态变量、即时编译器编译后的代码等数据。（**什么是类信息：类版本号、方法、接口。）
5-2 结构
- 永久代用的堆内存
- 元空间用的本地内存
5-3 方法区内存溢出
- 1.8以前会导致永久代内存溢出
java.lang.OutOfMemoryError: PermGen space - 1.8以后会导致元空间内存溢出
java.lang.OutOfMemoryError: Metaspace
案例：
调整虚拟机参数：
/**
* 演示元空间内存溢出: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
5-4 通过反编译来查看类的信息
-
获得对应类的.class文件，
javac xxx.java-
在JDK对应的bin目录下运行cmd，也可以在IDEA控制台输入
-
输入 javac 对应类的绝对路径
F:\JAVA\JDK8.0\bin>javac F:\Thread_study\src\com\nyima\JVM\day01\Main.java输入完成后，对应的目录下就会出现类的.class文件
-
-
在控制台输入
javap -v 类的绝对路径javap -v F:\Thread_study\src\com\nyima\JVM\day01\Main.class -
然后能在控制台看到反编译以后类的信息了
-
类的基本信息
-
常量池
-
虚拟机中执行编译的方法（框内的是真正编译执行的内容，#号的内容需要在常量池中查找）
-
5-5 运行时常量池
- 常量池：就是一张表，虚拟机指令根据这张常量表找到要执行的类名、方法名、参数类型、字面量等信息
- 运行时常量池：常量池是 *.class 文件中的，当该类被加载，它的常量池信息就会放入运行时常量池，并把里面的符号地址变为真实地址
5-6 常量池与串池StringTable的关系
StringTable 特性
- 常量池中的字符串仅是符号，只有在被用到时才会转化为对象
- 利用串池的机制，来避免重复创建字符串对象
- 字符串变量拼接的原理是StringBuilder
- 字符串常量拼接的原理是编译器优化
- 可以使用intern方法，主动将串池中还没有的字符串对象放入串池中
- 1.8 将这个字符串对象尝试放入串池，如果有则并不会放入，如果没有则放入串池，会把串池中的对象返回
- 1.6 将这个字符串对象尝试放入串池，如果有则并不会放入，如果没有会把此对象复制一份，放入串池，会把串池中的对象返回
栗子1：
public class StringTableStudy {
public static void main(String[] args) {
String a = "a";
String b = "b";
String ab = "ab";
}
}
常量池中的信息，都会被加载到运行时常量池中，但这是a b ab 仅是常量池中的符号，还没有成为java字符串
0: ldc #2 // String a
2: astore_1
3: ldc #3 // String b
5: astore_2
6: ldc #4 // String ab
8: astore_3
9: return
当执行到 ldc #2 时，会把符号 a 变为 “a” 字符串对象，并放入串池中（hashtable结构 不可扩容）
当执行到 ldc #3 时，会把符号 b 变为 “b” 字符串对象，并放入串池中
当执行到 ldc #4 时，会把符号 ab 变为 “ab” 字符串对象，并放入串池中
最终StringTable [“a”, “b”, “ab”]
注意：字符串对象的创建都是懒惰的，只有当运行到那一行字符串且在串池中不存在的时候（如 ldc #2）时，该字符串才会被创建并放入串池中。
栗子2：使用拼接字符串变量对象创建字符串的过程
public class HelloWorld {
public static void main(String[] args) {
String s1 = "a";
String s2 = "b";
String s3 = "ab";
String s4=s1+s2;//new StringBuilder().append("a").append("2").toString() new String("ab")
System.out.println(s3==s4);//false
//结果为false,因为s3是存在于串池之中，s4是由StringBuffer的toString方法所返回的一个对象，存在于堆内存之中
}
}
反编译后的结果
Code:
stack=2, locals=5, args_size=1
0: ldc #2 // String a
2: astore_1
3: ldc #3 // String b
5: astore_2
6: ldc #4 // String ab
8: astore_3
9: new #5 // class java/lang/StringBuilder
12: dup
13: invokespecial #6 // Method java/lang/StringBuilder."":()V
16: aload_1
17: invokevirtual #7 // Method java/lang/StringBuilder.append:(Ljava/lang/String
;)Ljava/lang/StringBuilder;
20: aload_2
21: invokevirtual #7 // Method java/lang/StringBuilder.append:(Ljava/lang/String
;)Ljava/lang/StringBuilder;
24: invokevirtual #8 // Method java/lang/StringBuilder.toString:()Ljava/lang/Str
ing;
27: astore 4
29: return
- 通过拼接的方式来创建字符串的过程是：
StringBuilder().append(“a”).append(“b”).toString() - 最后的toString方法的返回值是一个新的字符串，但字符串的值和拼接的字符串一致，但是两个不同的字符串，一个存在于串池之中，一个存在于堆内存之中
栗子3：使用拼接字符串常量对象的方法创建字符串
public class HelloWorld {
public static void main(String[] args) {
String s1 = "a";
String s2 = "b";
String s3 = "ab";
String s4=s1+s2;//new StringBuilder().a|ppend("a").append("2").toString() new String("ab")
String s5="a"+"b";
System.out.println(s5==s3);//true
}
}
反编译后的结果
Code:
stack=2, locals=6, args_size=1
0: ldc #2 // String a
2: astore_1
3: ldc #3 // String b
5: astore_2
6: ldc #4 // String ab
8: astore_3
9: new #5 // class java/lang/StringBuilder
12: dup
13: invokespecial #6 // Method java/lang/StringBuilder."":()V
16: aload_1
17: invokevirtual #7 // Method java/lang/StringBuilder.append:(Ljava/lang/String
;)Ljava/lang/StringBuilder;
20: aload_2
21: invokevirtual #7 // Method java/lang/StringBuilder.append:(Ljava/lang/String
;)Ljava/lang/StringBuilder;
24: invokevirtual #8 // Method java/lang/StringBuilder.toString:()Ljava/lang/Str
ing;
27: astore 4
//ab3初始化时直接从串池中获取字符串
29: ldc #4 // String ab
31: astore 5
33: return
- 使用拼接字符串常量的方法来创建新的字符串时，因为内容是常量，javac在编译期会进行优化，结果已在编译期确定为ab，而创建ab的时候已经在串池中放入了“ab”，所以s5直接从串池中获取值，所以进行的操作和 s3= “ab” 一致。
- 使用拼接字符串变量的方法来创建新的字符串时，因为内容是变量，只能在运行期确定它的值，所以需要使用StringBuilder来创建
intern方法 1.8：
调用字符串对象的intern方法，会将该字符串对象尝试放入到串池中
- 如果串池中没有该字符串对象，则放入成功
- 如果有该字符串对象，则放入失败
无论放入是否成功，都会返回串池中的字符串对象
例子：
public class HelloWorld {
public static void main(String[] args) {
String x = "ab";
String s = new String("a") + new String("b");
String s2 = s.intern();//将这个字符串对象尝试放入串池，如果有则并不会放入，如果没有则放入串池，这两种情况都会把串池中的对象返回
System.out.println(s2 == x);//true
System.out.println(s == x);//false
}
}
intern方法 1.6：
调用字符串对象的intern方法，会将该字符串对象尝试放入到串池中
- 如果串池中没有该字符串对象，会将该字符串对象复制一份，再放入到串池中
- 如果有该字符串对象，则放入失败
无论放入是否成功，都会返回串池中的字符串对象
面试题（1.8）：
package com.itcast.itheima.xpp;
public class main {
public static void main(String[] args) {
String s1="a";
String s2="b";
String s3="a"+"b";
String s4=s1+s2;
String s5="ab";
String s6=s4.intern();
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();
System.out.println(x1==x2);//false
String x4=new String("e")+new String("f");
x4.intern();
String x3="ef";
System.out.println(x3==x4);//true
}
}
5-7 StringTable 位置
- JDK1.6 时，StringTable是属于常量池的一部分。
- JDK1.8 以后，StringTable是放在堆中的。
5-8 StringTable 垃圾回收
StringTable在内存紧张时，会发生垃圾回收
5-9 StringTable 性能调优
-
因为StringTable是由HashTable实现的，所以可以适当增加HashTable桶的个数，来减少字符串放入串池所需要的时间
-XX:StringTableSize=xxxx //最低为1009 -
考虑是否将字符串对象入池
可以通过intern方法减少重复入池，保证相同的地址在StringTable中只存储一份
6.直接内存
6-1 定义
- 属于操作系统，常见于NIO操作时，用于数据缓冲区
- 分配回收成本较高，但读写性能高
- 不受JVM内存回收管理
6-2 分配和回收原理
文件读写过程：
使用了DirectBuffer：
直接内存是操作系统和Java代码都可以访问的一块区域，无需将代码从系统内存复制到Java堆内存，从而提高了效率
直接内存也会导致内存溢出
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 来释放直接内存最后喜欢的小伙伴别忘了一键三连哦
