参考资料
本笔记是基于黑马程序员的课件以及视频资料所做。所涉及的资料可在下面的度盘链接找到：
链接：https://pan.baidu.com/s/1JtV0zFS5yFa7edGxSqQYeQ
提取码：i6vv
1. JVM定义
Java Virtual Machine，JAVA程序的运行环境（JAVA二进制字节码的运行环境）
1.1 好处
- 一次编写，到处运行
- 自动内存管理，垃圾回收机制
- 数组下标越界检查
1.2 比较
JVM JRE JDK的区别
1.3 常见的 JVM
1.4 学习模块
2. 内存结构
2.1 程序计数器
Program Counter Register 程序计数器（寄存器）。
- 作用，是记住下一条jvm指令的执行地址
- 特点
-
是线程私有的；
- CPU会为每个线程分配时间片，当当前线程的时间片使用完以后，CPU就会去执行另一个线程中的代码
- 程序计数器是每个线程所私有的，当另一个线程的时间片用完，又返回来执行当前线程的代码时，通过程序计数器可以知道应该执行哪一句指令
-
不会存在内存溢出
-
2.2 虚拟机栈
2.2.1 定义
Java Virtual Machine Stacks （Java 虚拟机栈）
-
每个线程运行需要的内存空间，称为虚拟机栈
-
每个栈由多个栈帧（Frame)组成，对应着每次调用方法时所占用的内存
-
每个线程只能有一个活动栈帧，对应着当前正在执行的方法
-
示例
public class JVMStack { public static void main(String[] args) { m1(); } public static void m1(){ int c= m2(1,2); System.out.println(c); } public static int m2(int a,int b){ return a+b; } }
通过打断点的方式一步一步运行，在控制台中可以看到，主类中的方法在进入虚拟机栈的时候，符合栈的特点
2.2.2 问题辨析
-
垃圾回收是否涉及栈内存？
不涉及。因为虚拟机栈中是由一个个栈帧组成的，在方法执行完毕后，对应的栈帧就会被弹出栈。所以无需通过垃圾回收机制去回收内存。
-
栈内存的分配越大越好吗？
不是。因为物理内存是一定的，栈内存越大，可以支持更多的递归调用，但是可执行的线程数就会越少。
-
方法内的局部变量是否是线程安全的？
-
如果方法内局部变量没有逃离方法的作用范围，则是线程安全的
-
如果局部变量引用了对象，并逃离了方法的作用范围，则需要考虑线程安全问题
-
示例
public class ThreadSafe { public static void main(String[] args) { StringBuilder sb = new StringBuilder(); sb.append(4); sb.append(5); sb.append(6); new Thread(()->{ m2(sb); }).start(); } 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.2.3 栈内存溢出
Java.lang.stackOverflowError 栈内存溢出。
原因：
-
栈帧过多导致栈内存溢出（例如无限递归）
/** * 演示栈内存溢出 java.lang.StackOverflowError * -Xss256k */ public class Demo1 { private static int count; public static void main(String[] args) { try { method1(); } catch (Throwable e) { e.printStackTrace(); System.out.println(count); } } private static void method1() { count++; method1(); } } -
栈帧过大导致栈内存溢出
2.2.4 线程运行诊断
-
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进制的，需要转换
2.3. 本地方法栈
一些带有native关键字的方法（不是由java代码编写的）就是需要JAVA去调用本地的C或者C++方法，因为JAVA有时候没法直接和操作系统底层交互，所以需要用到本地方法
2.4 堆
2.4.1 定义
通过new关键字创建的对象都会被放在堆内存
2.4.2 特点
- 线程共享，堆内存中的对象都需要考虑线程安全问题
- 有垃圾回收机制
2.4.3 堆内存溢出
java.lang.OutofMemoryError ：java heap space. 堆内存溢出
/**
* 演示堆内存溢出 java.lang.OutOfMemoryError: Java heap space
* -Xmx8m
*/
public class Demo3 {
public static void main(String[] args) {
int i = 0;
try {
List<String> list = new ArrayList<>();
String a = "hello";
while (true) {
list.add(a); // hello, hellohello, hellohellohellohello ...
a = a + a; // hellohellohellohello
i++;
}
} catch (Throwable e) {
e.printStackTrace();
System.out.println(i);
}
}
}
2.4.4 堆内存诊断
ubuntu下终端命令
-
jps
查看当前系统中有哪些 java 进程 -
jmap工具
查看堆内存占用情况：jmap - heap 进程id -
jconsole
图形界面的，多功能的监测工具，可以连续监测
jvirsalvm
2.5 方法区
2.5.1 定义
2.5.2 结构
2.5.3 内存溢出
- 1.8以前会导致永久代内存溢出
- 1.8以后会导致元空间内存溢出
设置元空间内存大小步骤：/** * 演示元空间内存溢出 java.lang.OutOfMemoryError: Metaspace * 将MaxMetaspaceSize设置为8m：-XX:MaxMetaspaceSize=8m */ public class Demo5 extends ClassLoader { // 可以用来加载类的二进制字节码 public static void main(String[] args) { int j = 0; try { Demo5 test = new Demo5(); 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); } } }
2.5.4 运行时常量池
1. 常量池
- 常量池，就是一张表，虚拟机指令根据这张常量表找到要执行的类名、方法名、参数类型、字面量等信息
演示：通过反编译来查看类的信息
// 二进制字节码（类基本信息，常量池，类方法定义，包含了虚拟机指令）
public class HelloWorld {
public static void main(String[] args) {
System.out.println("hello world");
}
}
-
运行完上述代码后，在终端进入所生成的class文件的目录
-
运行
javap -v HelloWorld.class然后能在终端看到反编译以后类的信息了
虚拟机中执行编译的方法（框内的是真正编译执行的内容，#号的内容需要在常量池中查找）如下所示：
2. 运行时常量池
- 运行时常量池，常量池是
*.class文件中的，当该类被加载，它的常量池信息就会放入运行时常量池，并把里面的符号地址变为真实地址
2.5.5 串池StringTable
1. 特征
-
常量池中的字符串仅是符号，只有在被用到时才会转化为对象
-
利用串池的机制，来避免重复创建字符串对象
-
字符串变量拼接的原理是
StringBuilder -
字符串常量拼接的原理是
编译器优化 -
可以使用
intern方法，主动将串池中还没有的字符串对象放入串池中java1.8 将这个字符串对象尝试放入串池，如果有则并不会放入，如果没有则放入串池， 会把串
池中的对象返回java1.6 将这个字符串对象尝试放入串池，如果有则并不会放入，如果没有会把此对象复制一份，
放入串池， 会把串池中的对象返回 -
注意：无论是串池还是堆里面的字符串，都是对象
2. 分析
-
声明字符串
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）时，该字符串才会被创建并放入串池中。 -
使用拼接字符串变量对象创建字符串的过程：
public class StringTableStudy { public static void main(String[] args) { String a = "a"; String b = "b"; String ab = "ab"; //拼接字符串对象来创建新的字符串 String ab2 = a+b; } }反编译后的结果
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通过拼接的方式来创建字符串的过程是：
StringBuilder().append(“a”).append(“b”).toString()
最后的toString方法的返回值是一个新的字符串，但字符串的值和拼接的字符串一致，一个存在于串池之中，一个存在于堆内存之中String ab = "ab"; String ab2 = a+b; //结果为false,因为ab是存在于串池之中，ab2是由StringBuffer的toString方法所返回的一个对象，存在于堆内存之中 System.out.println(ab == ab2); -
使用拼接字符串常量对象的方法创建字符串
public class StringTableStudy { public static void main(String[] args) { String a = "a"; String b = "b"; String ab = "ab"; String ab2 = a+b; //使用拼接字符串的方法创建字符串 String ab3 = "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-
使用拼接字符串常量的方法来创建新的字符串时，因为内容是常量，javac在编译期会进行优化，结果已在编译期确定为ab，而创建ab的时候已经在串池中放入了“ab”，所以ab3直接从串池中获取值，所以进行的操作和 ab = “ab” 一致。
-
使用拼接字符串变量的方法来创建新的字符串时，因为内容是变量，只能在运行期确定它的值，所以需要使用
StringBuilder来创建
-
-
intern方法 (java1.8)
调用字符串对象的intern方法，会将该字符串对象尝试放入到串池中
- 如果串池中没有该字符串对象，则放入成功
- 如果有该字符串对象，则放入失败
无论放入是否成功，都会返回串池中的字符串对象
注意：此时如果调用intern方法成功，堆内存与串池中的字符串对象是同一个对象；如果失败，则不是同一个对象
示例1：
@Test public void test01(){ //"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：
@Test public void test02(){ //此处创建字符串对象"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方法成功与否，串池中的字符串对象和堆内存中的字符串对象都不是同一个对象
3. 面试题
public static void main(String[] args) {
String s1 = "a";
String s2 = "b";
String s3 = "a" + "b";//常量拼接ab
String s4 = s1 + s2;//变量拼接new String("ab")
String s5 = "ab";
String s6 = s4.intern();//主动将串池中还没有的字符串对象放入串池中
// 问
System.out.println("s3 == s4: "+(s3 == s4));
System.out.println("s3 == s5: "+(s3 == s5));
System.out.println("s3 == s6: "+(s3 == s6));
String x2 = new String("c") + new String("d");
String x1 = "cd";
x2.intern(); //常量池中已经有cd，所以不会再将x2放入。
// 问，如果调换了【最后两行代码】的位置呢，如果是jdk1.6呢
System.out.println("x1 == x2: "+(x1 == x2));
}
在JDK1.8运行下，答案为：
4. StringTable 垃圾回收
StringTable在内存紧张时，会发生垃圾回收
5. StringTable调优
-
因为StringTable是由HashTable实现的，所以可以适当增加HashTable桶的个数，来减少字符串放入串池所需要的时间
-XX:StringTableSize=桶个数 -
考虑是否需要将字符串对象入池
可以通过intern方法减少重复入池
6. StringTable所在位置
2.6 直接内存
2.6.1 定义
Direct Memory
- 属于操作系统，常见于
NIO操作时，用于数据缓冲区 - 分配回收成本较高，但读写性能高
- 不受JVM内存回收管理
2.6.2 文件读写流程
使用了DirectBuffer
直接内存是操作系统和Java代码都可以访问的一块区域，无需将代码从系统内存复制到Java堆内存，从而提高了效率
2.6.3 释放原理
直接内存的回收不是通过JVM的垃圾回收来释放的，而是通过unsafe.freeMemory来手动释放
/**
* 直接内存分配的底层原理：Unsafe
*/
public class Demo7 {
static int _1Gb = 1024 * 1024 * 1024;
public static void main(String[] args) throws IOException {
Unsafe unsafe = getUnsafe();
// 分配内存
long base = unsafe.allocateMemory(_1Gb);
unsafe.setMemory(base, _1Gb, (byte) 0);
System.in.read();
// 释放内存
unsafe.freeMemory(base);
System.in.read();
}
public static Unsafe getUnsafe() {
try {
Field f = Unsafe.class.getDeclaredField("theUnsafe");
f.setAccessible(true);
Unsafe unsafe = (Unsafe) f.get(null);
return unsafe;
} catch (NoSuchFieldException | IllegalAccessException e) {
throw new RuntimeException(e);
}
}
}
//通过ByteBuffer申请1M的直接内存
ByteBuffer byteBuffer = ByteBuffer.allocateDirect(_100M);
申请直接内存，但JVM并不能回收直接内存中的内容，它是如何实现回收的呢？
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);
}
2.6.4 分配和回收原理
-
使用了Unsafe类来完成直接内存的分配回收，回收需要主动调用freeMemory方法
-
ByteBuffer的实现类内部，使用了Cleaner（虚引用）来检测ByteBuffer对象。一旦ByteBuffer被垃圾回收，那么会由ReferenceHandler线程来调用Cleaner的clean方法调用freeMemory来释放内存
7550
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
