1. 什么是JVM
- 定义：Java Virtual Machine，JAVA程序的运行环境（JAVA二进制字节码的运行环境）
- 好处：
- 一次编写，到处运行
- 自动管理内存，垃圾回收机制
- 数组下标越界检查
- 多态
- 比较
- JVM ：屏蔽java代码和底层操作系统之间的差异
- JRE ：在JVM基础上添加了基础类库
- JDK：在JRE基础上添加编译开发工具
2. 内存结构
2.1 程序计数器
Program Counter Register 程序计数器（寄存器）
2.1.1 作用
java源代码经过一次编译，编译成二进制字节码，也就是jvm指令，堆所有平台一致，这些指令经过解释器变成机器码，机器码交给CPU进行执行。程序计数器作用就是保存JVM中下一条所要执行的指令的地址。程序计数器是通过寄存器实现的，寄存器是CPU里读取速度最快的单元。
2.1.2 特点
- 线程私有
- CPU会为每个线程分配时间片，当当前线程的时间片使用完以后，CPU就会去执行另一个线程中的代码，每个线程都有自己的程序计数器
- 程序计数器是每个线程所私有的，当另一个线程的时间片用完，又返回来执行当前线程的代码时，通过程序计数器可以知道应该执行哪一句指令
- 唯一一个不会存在内存溢出的区域
2.2 虚拟机栈
2.2.1 定义
-
每个线程运行需要的内存空间，称为虚拟机栈
-
每个栈由多个栈帧组成，对应着每次调用方法时所占用的内存
-
每个线程只能有一个活动栈帧，对应着当前正在执行的方法
2.2.2 代码示例
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;
}
}
2.2.3 问题辨析
-
垃圾回收是否涉及栈内存？
不需要。因为虚拟机栈中是由一个个栈帧组成的，在方法执行完毕后，对应的栈帧就会被弹出栈。所以无需通过垃圾回收机制去回收内存。
-
栈内存的分配越大越好吗？
不是。因为物理内存是一定的，栈内存越大，可以支持更多的递归调用，但是可执行的线程数就会越少。栈内存的大小可以通过 -Xss 设置，win系统根据虚拟内存决定大小，其他的系统都是1024kb
-
方法内的局部变量是否是线程安全的？
- 如果方法内局部变量没有逃离方法的作用范围，则是线程安全的
- 如果传入的参数和返回的参数存在变量，逃离了方法的作用范围，则需要考虑线程安全问题
2.2.4 栈内存溢出
Java.lang.stackOverflowError
- 虚拟机栈中，栈帧过多（无限递归）
- 每个栈帧所占用过大
2.2.5 线程运行诊断
- 案例一，CPU占用过高（Linux环境）
- top命令，查看是哪个进程占用CPU过高（定位不到线程）
ps H -eo pid, tid, %cpu | grep [进程id]刚才通过top查到的进程号 通过ps命令进一步查看是哪个线程占用CPU过高，-eo指定显示信息jstack [进程id]通过查看进程中的线程的nid，刚才通过ps命令看到的tid来对比定位，注意jstack查找出的线程id是16进制的，需要转换
- 案例二，程序运行长时间得不到结果
- 还是使用 jstack 查看，最后输出显示 deadlock （死锁）定位出问题的源码
2.3 本地方法栈
一些带有native关键字的方法（本地方法，数量非常多）就是需要JAVA去调用本地的C或者C++方法，因为JAVA有时候没法直接和操作系统底层交互，所以需要用到本地方法
举例：Object类中的clone方法，hashcode方法，wait方法
2.4 堆
2.4.1 定义
- 通过new关键字创建的对象都会被放在堆内存
2.4.2 特点
- 所有线程共享，堆内存中的对象都需要考虑线程安全问题
- 有垃圾回收机制
2.4.3 堆内存溢出
java.lang.OutofMemoryError ：java heap space，-Xmx 堆空间最大值参数
- 堆内存诊断工具
- jps：查看当前系统中有哪些java进程
- jmap：查看某一时刻堆内存使用情况。
jmap -heap [进程id] - jconsole：图形界面，多功能监测工具，可以连续监测
- 案例：垃圾回收以后，内存占用仍然很高
- jvirsalvm：可视化展示虚拟机内容
- 堆dump，获取某一时刻堆内存的快照
2.5 方法区
2.5.1 定义
jvm1.8版本中对方法区的定义:
- 方法区是所有java虚拟机线程共享的区，这块区域中存储了跟类的结构相关的信息，包括成员变量，方法数据，成员方法，构造器方法代码，运行时常量池，特殊方法（主要指的是类的构造器）。
- 方法区在虚拟机启动时被创建，他逻辑上是堆的一个组成部分
- orcle hotspot jdk1.8 以前，他的实现叫永久代，就是使用了堆内存的一部分作为方法区。但是1.8以后，永久代被移除，换为元空间实现，不再使用堆的内存，而是使用本地内存，就是操作系统的内存，不再由jvm管理他的内存结构。方法区是规范，永久代和元空间都是他的一种实现。
- 内存溢出：方法区申请内存发现不足时，抛出 OutOfMemoryError错误
2.5.2 方法区的内存溢出
- 1.8以前会导致永久代内存溢出，java.lang.OutofMemoryError ：PermGen space（-XX:MaxPerSize）
- 1.8以后会导致元空间内存溢出，java.lang.OutofMemoryError ：Metaspace（-XX:MaxMetaspaceSize）
spring，mybatis等框架在使用过程中加载了大量的类，容易内存溢出
2.5.3 运行时常量池
- 二进制字节码的组成：类的基本信息、常量池、类的方法定义（包含了虚拟机指令）
- 通过 javap -v 类的绝对路径显示反编译后的详细信息
- 类的基本信息：类的文件路径，最后修改时间，签名访问修饰符，包名，类名，版本，父类，接口
- 常量池：地址+符号
- 类的方法定义：构造方法（无参构造，默认构造），main方法，参数类型，虚拟机指令。框内的是真正编译执行的内容，井号的内容需要在常量池中查找
2.5.4 运行时常量池
-
常量池
- 就是一张表（如上图中的constant pool），虚拟机指令根据这张常量表找到要执行的类名、方法名、参数类型、字面量信息
-
运行时常量池
- 常量池是*.class文件中的，当该类被加载以后，它的常量池信息就会放入运行时常量池，并把里面的**符号地址变为真实地址*
2.5.5 StringTable 特性
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uI6rbdha-1654543352034)(F:\1111yjs\笔记\JVM.assets\image-20220605205114955.png)]
-
看一个例子
常量池中的信息，都会被加载到运行时常量池中，但这是a，b，ab 仅是常量池中的符号，还没有成为java字符串
当执行到 ldc #2 时，会把符号 a 变为 “a” 字符串对象，并放入串池中（hashtable结构 不可扩容）
当执行到 ldc #3 时，会把符号 b 变为 “b” 字符串对象，并放入串池中
当执行到 ldc #4 时，会把符号 ab 变为 “ab” 字符串对象，并放入串池中
最终StringTable [“a”, “b”, “ab”]
注意：字符串对象的创建都是懒惰的，只有当运行到那一行字符串且在串池中不存在的时候（如 ldc #2）时，该字符串才会被创建并放入串池中，每个取值不同的对象在字符串池中唯一。
public class StringTableStudy {
public static void main(String[] args) {
String a = "a";
String b = "b";
String ab = "ab";
}
}
反编译结果：
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
- 字符串拼接
- 首先创建了一个StringBuilder对象
- 调用无参构造
- 把参数s1加载进来，作为.append方法的参数
- 把参数s2加载进来，作为.append方法的参数
- 执行StringBuilder对象的toString()方法
- 存入堆中
public class StringTableStudy {
public static void main(String[] args) {
String s1 = "a";
String s2 = "b";
String s3 = "ab";
//拼接字符串对象来创建新的字符串
String s4 = a+b; // 先创建了一个StringBuilder对象
}
}
反编译后的结果：
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."<init>":()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
- 拼接字符串常量对象
- 使用拼接字符串常量的方法来创建新的字符串时，因为内容是常量，javac在编译期会进行优化，结果已在编译期确定为ab，而创建ab的时候已经在串池中放入了“ab”
- 使用拼接字符串变量的方法来创建新的字符串时，因为内容是变量，只能在运行期确定它的值，所以需要使用StringBuilder来创建
public class StringTableStudy {
public static void main(String[] args) {
String s1 = "a";
String s2 = "b";
String s3 = "ab";
String s4 = a+b;
//使用拼接字符串的方法创建字符串
String s5 = "a" + "b";
}
}
反编译后的结果：
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."<init>":()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
-
intern方法 1.8
调用字符串对象的intern方法，会将该字符串对象尝试放入到串池中
- 如果串池中没有该字符串对象，则放入成功
- 如果有该字符串对象，则放入失败
无论放入是否成功，都会返回串池中的字符串对象
注意：此时如果调用intern方法成功，堆内存与串池中的字符串对象是同一个对象；如果失败，则不是同一个对象
// 例1 public class Main { public static void main(String[] args) { //"a" "b" 被放入串池中，str则存在于堆内存之中 String str = new String("a") + new String("b"); //调用str的intern方法，这时串池中没有"ab"，则会将该字符串对象放入到串池中，此时堆内存与串池中的"ab"是同一个对象 String st2 = str.intern(); //给str3赋值，因为此时串池中已有"ab"，则直接将串池中的内容返回 String str3 = "ab"; //因为堆内存与串池中的"ab"是同一个对象，所以以下两条语句打印的都为true System.out.println(str == st2); System.out.println(str == str3); } }// 例2 public class Main { public static void main(String[] args) { //此处创建字符串对象"ab"，因为串池中还没有"ab"，所以将其放入串池中 String str3 = "ab"; //"a" "b" 被放入串池中，str则存在于堆内存之中 String str = new String("a") + new String("b"); //此时因为在创建str3时，"ab"已存在与串池中，所以放入失败，但是会返回串池中的"ab" String str2 = str.intern(); //false System.out.println(str == str2); //false System.out.println(str == str3); //true System.out.println(str2 == str3); } } -
intern方法 1.6
调用字符串对象的intern方法，会将该字符串对象尝试放入到串池中
- 如果串池中没有该字符串对象，会将该字符串对象复制一份，再放入到串池中
- 如果有该字符串对象，则放入失败
无论放入是否成功，都会返回串池中的字符串对象
注意：此时无论调用intern方法成功与否，串池中的字符串对象和堆内存中的字符串对象都不是同一个对象
-
面试题
String s1 = "a";
String s2 = "b";
String s3 = "a" + "b"; // ab
String s4 = s1 + s2; // new Stirng
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();
// 问，如果调换了【最后两行代码】的位置呢(true)，如果是jdk1.6呢(false)
System,out.println( x1 == x2 ); // false
2.5.6 StringTable 位置
1.8之前，存放在永久代中，永久代中垃圾回收效率不高。1.8之后在堆空间
2.5.7 StringTable 垃圾回收
StringTable 底层实现类似 hashtable，数组加链表的结构，数组的个数称之为桶（buckets），默认桶个数60013，键值对（entries）数量1754，字符串常量个数（literals）1754。什么都没做就有1754对象了。
一直往里面放字符串，就会触发垃圾回收。
2.5.8 StringTable 性能调优
-
因为StringTable是由HashTable实现的，所以可以适当增加HashTable桶的个数，来减少字符串放入串池所需要的时间
-XX:StringTableSize=xxxxCopy -
考虑是否需要将字符串对象入池
可以通过intern方法减少重复入池
2.6 直接内存
2.6.1 定义
- 属于操作系统，常见于NIO操作时，用于数据缓冲区
- 分配回收成本较高，但读写性能高
- 不受JVM内存回收管理
2.6.2 文件读写流程
不使用DirectBuffer
使用DirectBuffer
直接内存是操作系统和Java代码都可以访问的一块区域，无需将代码从系统内存复制到Java堆内存，从而提高了效率
2.6.3 分配和回收
-
DirectByteBuffer源码
-
这里调用了一个Cleaner的create方法，且后台线程还会对虚引用的对象监测，如果虚引用的实际对象（这里是DirectByteBuffer）被回收以后，就会调用Cleaner的clean方法，来清除直接内存中占用的内存
-
总结
-
使用了Unsafe类来完成直接内存的分配回收，回收需要主动调用freeMemory方法
-
ByteBuffer的实现内部使用了Cleaner（虚引用）来检测ByteBuffer。一旦ByteBuffer被垃圾回收，那么会由ReferenceHandler来调用Cleaner的clean方法调用freeMemory来释放内存
public static ByteBuffer allocateDirect(int capacity) { return new DirectByteBuffer(capacity); } 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; }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; } }); } -
2501
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
