【JVM】一篇通关JVM内存管理
视频链接： 黑马程序员JVM p1-p47
目录
- 1. 什么是JVM
- 2. 学习JVM有什么用
- 3. 常见的JVM
- 4. 学习路线
- 5. 内存结构
-
- 5-1. 程序计数器
- 5-2. 虚拟机栈
-
- 栈内存溢出
- 线程诊断
- 5-3. 本地方法栈
- 5-4. 堆
-
- 堆内存溢出
- 堆内存诊断
- 5-5. 方法区
-
- 方法区内存溢出
- 运行时常量池
- ★面试题StringTable
- StringTable位置
- StringTable 垃圾回收
- StringTable 性能调优
- 5-6. 直接内存
-
- 什么是直接内存
- 直接内存的内存溢出
- 直接内存释放原理
- 直接内存的回收机制总结
1. 什么是JVM
定义： Java Virtual Machine - java程序的运行环境 （java二进制字节码的运行环境）
好处：
- 一次编写，到处运行
- 自动内存管理，垃圾回收功能
- 数组下标越界检查
- 多态
比较： jvm jre jdk之间的联系
2. 学习JVM有什么用
- 面试
- 理解底层的实现原理
- 中高级程序员的必备技能
3. 常见的JVM
4. 学习路线
5. 内存结构
5-1. 程序计数器
作用： 记录下一条jvm指令的执行地址
实现： jvm在物理上是通过寄存器实现程序计数器的。寄存器是cup中读取速度最快的组件，而读取指令地址是非常频繁的操作。
特点：
- 线程私有，每个线程都有自己的程序计数器。即记录自己线程下一条指令的执行地址。
- 是jvm中唯一一个不会存在内存溢出
5-2. 虚拟机栈
虚拟机栈： 一个线程有一个栈，栈是每个线程运行需要的内存空间，里面存放的是栈帧。一个栈由多个栈帧组成
栈帧 每个方法调用时需要的内存，例如：参数、局部变量、返回地址等
- 每个线程
只能有一个活动栈帧，对应着当前正在执行的那个方法
演示栈帧
问题辨析
- 垃圾回收是否涉及栈内存？
- 垃圾回收回收的是堆内存，不涉及栈内存
- 线程栈内存分配越大越好吗？
- 可以通过运行代码时指定虚拟机参数设置栈内存，
但并不是越大越好。 线程栈内存越大，线程数反而变少。因为物理内存大小是一定的，假如一个线程使用1M内存，物理内存假设有500MB，理论上可以有500个线程同时运行。假如线程栈内存调为2M，那么理论就有250个线程同时运行。- 栈内存越大，可以有更多次方法递归调用，而不会增强运行效率
- 一般采用默认的栈内存大小就可以了。
- 可以通过运行代码时指定虚拟机参数设置栈内存，
个人理解：
-
每个线程都有自己的栈，其中栈内保存的是该线程中每个方法调用时需要的内存
-
物理内存假如固定500MB，每个线程的栈内存大小为1MB，则可以有500个线程同时运行
-
物理内存假如固定500MB，将栈内存调大，即每个线程的栈内存大小为2MB，则可以有250个线程同时运行
-
方法内的局部变量是否线程安全？
- 局部变量是基本数据类型，是线程安全的。
- 局部变量是引用类型
- 没有出现在方法参数或是在方法返回中，是线程安全的。
- 逃离了方法的作用范围，即出现在方法参数或是在方法返回中，不是线程安全的。
局部变量是基本数据类型
局部变量是引用类型
栈内存溢出
异常： java.lang.StackoverflowError
出现原因：
- 栈帧过多导致栈内存溢出
- 栈帧过大导致栈内存溢出
- 第三方类库操作也有可能造成栈内存溢出，比如在进行JSON格式化的时候，一直进行格式化。可以通过
@JsonIgnore忽略某个属性格式化
线程诊断
1. cpu占用高
Linux 环境下运行某些程序的时候，可能导致 CPU 的占用过高，这时需要定位占用 CPU 过高的线程
top查看进程对cpu、内存的使用情况。PID: 进程号
ps H -eo pid, tid, %cpu, | grep 32655查看32655这个进程下的进程号、线程号、cpu占用情况
jstack 进程id使用java提供的命令，查看对应进程下的所有线程
- 注意
ps H -eo pid, tid, %cpu, | grep 32655输出的线程号是十进制，jstack 进程id输出的线程号是十六进制。 - 32665 => 0x7f99
- 对应出问题的是thread1线程，而且它的状态是RUNNABLE，并且对应问题的类是Demo_16，第8行
5-3. 本地方法栈
定义：
- Java虚拟机调用本地方法时，分配的内存空间
本地方法：
- 不是由Java编写的代码，通常由C/C++编写的调用操作系统的代码
标识： native 关键字
例如： Object类中的 wait(), finalize(), hashCode(), notify() 等都是native方法
5-4. 堆
虚拟机栈、程序计数器、本地方法栈 都是线程私有的。
堆是线程共享的
定义：
- 通过
new关键字，创建的对象都会使用堆内存
特点：
- 它是线程共享的，堆中对象都需要考虑线程安全问题
- 有垃圾回收机制，堆中不再被引用的对象，会当成垃圾进行回收。从而释放内存
堆内存溢出
异常： java.lang.OutOfMemoryError ：java heap space. 堆内存溢出 （OOM）
实例演示 
堆内存的设置 -Xmx8m : 设置堆内存为8mb。如果堆内存设置的过大，则不容易发现堆内存溢出情况。所以可以把堆内存设置小一点，提前发现堆内存溢出情况。
堆内存诊断
- jps工具
- 查看当前系统中有哪些java进程
- jmap工具
- 查看堆内存占用情况
jmap -heap 进程id
- 查看堆内存占用情况
- jconsole工具
- 图形界面，多功能的检测工具，可以连续监测
5-5. 方法区
定义
- 方法区是
所有jvm线程共享的一个区域 - 方法区存储了类的结构相关的信息。例如：类的成员变量、方法、构造器等。
- 方法区在虚拟机启动时被创建
方法区是规范，永久代（jdk1.6）和元空间（jdk1.8，占用的是系统的内存）只是实现Xx: MaxMetaspaceSize=8m设置元空间内存为8m- 当方法区内存溢出时，1.8之后错误：
OutOfMemoryError: Metaspace
方法区内存溢出
- 1.8 之前会导致永久代内存溢出
- 使用
-XX:MaxPermSize=8m指定永久代内存大小
- 使用
- 1.8 之后会导致元空间内存溢出
- 使用
-XX:MaxMetaspaceSize=8m指定元空间大小
- 使用
方法区内存溢出可能出现的场景
- spring 使用了
cglib，用它来生成代理类，它是Aop的核心。 - mybatis 使用了
cglib，用它来生成mapper接口实现类。 - 以上2个框架都使用了动态类加载。即在运行期间动态生成类字节码，完成动态的类的加载
- 所以有可能造成方法区内存溢出
运行时常量池
上图的中的常量池就是运行时常量池，图中少写了运行时三个字
.java文件编译后生成.class二进制字节码。二进制字节码包含：类的基本信息、常量池、类方法定义（包含了虚拟机指令）
idea打开.class文件时，能够显示与.java相似文件，是因为IDEA自带了反编译插件 Java Bytecode Decompiler。
它可以反编译 .class 文件、.jar 文件。它内部实际使用了 Fernflower 来反编译
常量池
- 常量池就是一张表，虚拟机指令根据这张常量表找到要执行的类名、方法名、参数类型、字面量信息
运行时常量池
- 常量池是在 *.class 文件中的，当该类被加载以后，它的常量池信息就会放入运行时常量池，并把里面的符号地址变为真实地址
案例：反编译Demo.java文件
public class Demo{
public static void main(String[] args) {
System.out.println("Hello World!");
}
}
可以利用JDK提供的javap反编译工具，查看字节码信息
javap -v Demo.class
类的基本信息
常量池
类的方法定义
★面试题StringTable
public class Test{
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 因为串池已经有"cd"了。
// 补充：如果调换了x1, x2位置, 以下输出什么。如果是jdk1.6呢
System.out.println(x1 == x2); // 1.8 true, 成功把"cd"放入串池，x1指向串池中的对象。 1.6 false, 因为会复制一份"cd"放到串池，x1还是指向堆中对象
}
}
- 字面量等一些信息一开始存放在.class中的常量池中，文件运行时.class常量池信息则会被加载到运行时常量池中，这时a b ab都是运行时常量池中的符号，还没有变成java字符串对象。
StringTable的数据结构是哈希表，不能扩容。- 并不是一开始就把所有字符串对象放到StringTable中，而是执行到该代码处(懒加载)才放入。
- 并不是无脑放入，先查找，StringTable如果有则使用串池中的对象，如果没有则放入
字符串变量拼接
s3 == s4 输出false
编译器优化
s3 == s5 输出true
StringTable特性
- 常量池中的字符串仅是符号，只有在被用到时才会转化为对象。即执行
String s1 = "a"；才在堆中创建s1对象。 - 利用串池的机制，来避免重复创建字符串对象
- 字符串变量拼接的原理是StringBuilder
String s4 = s1 + s2; - 字符串常量拼接的原理是编译器优化
String s5 = "a" + "b"; - 可以使用intern方法，主动将串池中还没有的字符串对象放入串池中。
intern的返回永远是串池中的对象。- JDK1.8 intern方法是将这个字符串对象尝试放入串池，如果串池已经存在了这个对象，则不会放入。如果没有则会放入串池，方法返回串池中的对象。
- JDK1.6 intern方法是将这个字符串对象尝试放入串池，如果串池已经存在了这个对象，则不会放入。如果没有则会把此对象复制一份，放出串池中，方法返回串池中的对象。
public class Demo{
public static void main(String[] args) {
String s = new String("a") + new String(""b); // new StringBuilder().append("a").append("b").toString() => new String("ab")
//将s这个字符串对象尝试放入串池
// 如果串池已经存在了，则不会放入，s还是指向堆中的对象。
// 如果串池不存在，则会把s对象放入串池，此时s指向的是串池中的对象。
//intern()方法返回的结果最后一定是串池中的对象。
String s2 = s.intern();
System.out.println(s2 == "ab"); // true
System.out.println(s == "ab"); // true
}
}
StringTable位置
- JDK1.6 StringTable 位置是在永久代中
- JDK1.8 StringTable 位置是在堆中
StringTable 垃圾回收
- StringTable在内存紧张时，会发生垃圾回收
- StringTable的数据结构是HashTable
StringTable 性能调优
- 因为StringTable是由HashTable实现的，所以
可以适当增加HashTable桶的个数，来减少字符串放入串池所需要的时间。HashTable是由数组+链表实现，桶对应着数组中的每一个位置。如果桶的个数过少，hash碰撞的几率会增加。
-XX:StringTableSize=xxxx //最低为1009
- 考虑是否将字符串对象入池， 可以
通过intern方法减少重复入池，保证相同字符串对象在StringTable中只存储一份
5-6. 直接内存
什么是直接内存
- 属于操作系统，常见于NIO操作时，用于数据缓冲区
- 分配回收成本较高，但读写性能高
- 不受JVM内存回收管理
传统读取文件方式：文件首先被读取到系统缓冲区，之后再分块读取到Java堆内存中。
直接内存：是操作系统和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对象的allocateDirect()完成直接内存的分配，回收需要主动调用Unsafe对象的freeMemory() ByteBuffer的实现类内部，使用了Cleaner（虚引用）来监测 ByteBuffer 对象，一旦ByteBuffer 对象被垃圾回收，那么就会由ReferenceHandler线程通过 Cleaner 的 clean 方法调用freeMemory来释放直接内存