关键词：
一、什么是JVM
定义
Java Virtual Machine，JAVA程序的运行环境（JAVA二进制字节码的运行环境）
好处
- 一次编写，到处运行
- 自动内存管理，垃圾回收机制
- 数组下标越界检查
比较
JVM JRE JDK的区别
二、内存结构
整体架构
1、程序计数器
作用
Program Counter Register程序计数器用于保存JVM中下一条所要执行的指令的地址
特点
- 线程私有：随着线程的创建而创建，随着线程的销毁而销毁
- CPU会为每个线程分配时间片，当当前线程的时间片使用完以后，CPU就会去执行另一个线程中的代码
- 程序计数器是每个线程所私有的，当另一个线程的时间片用完，又返回来执行当前线程的代码时，通过程序计数器可以知道应该执行哪一句指令
- 不会存在内存溢出
- 是一块较小的内存空间
2、虚拟机栈
2.1 定义
- 每个线程运行需要的内存空间，称为虚拟机栈
- 每个栈由多个栈帧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;
在控制台中可以看到，主类中的方法在进入虚拟机栈的时候，符合栈的特点
（顶部的就是活动栈帧）
问题辨析
- 垃圾回收是否涉及栈内存？
- 不需要。因为虚拟机栈中是由一个个栈帧组成的，在方法执行完毕后，对应的栈帧就会被弹出栈。所以无需通过垃圾回收机制去回收内存。
- 栈内存的分配越大越好吗？
- 不是。因为物理内存是一定的，栈内存越大，可以支持更多的递归调用，但是可执行的线程数就会越少。
- VM参数：
-Xss=256k可以指定栈大小
- 方法内的局部变量是否是线程安全的？
- 如果方法内局部变量没有逃离方法的作用范围，则是**线程安全(私有)**的，其他线程无法访问
- 如果如果局部变量引用了对象，并逃离了方法的作用范围（比如作为返回值返回），则需要考虑线程安全问题（可能多个线程共享）
2.2 内存溢出
Java.lang.stackOverflowError 栈内存溢出
发生原因
- 虚拟机栈中，栈帧过多（无限递归、循环引用@JsonIgnore）
- 每个栈帧所占用过大
线程运行诊断
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进制的**，需要转换
-
死锁：同样使用jstack
3、本地方法栈
一些带有native关键字的方法就是需要JAVA去调用本地的C或者C++方法，因为JAVA有时候没法直接和操作系统底层交互，所以需要用到本地方法
4、堆Heap
定义
通过new关键字创建的对象都会被放在堆内存
特点：
- 所有线程共享，堆内存中的对象都需要考虑线程安全问题
- 有垃圾回收机制
堆内存溢出
java.lang.OutofMemoryError：java heap space. 堆内存溢出
VM参数-Xmx=8m
堆内存诊断
-
jps：查看系统中有哪些Java进程 -
jmap -heap 进程id：查看堆内存占用情况 -
jconsole：图形界面的，多功能检测工具，可以连续检测
-
jvirsalvm：可以抓取堆的快照：例如：垃圾回收之后，内存占用依然很高（可以查找最大的堆对象）
5、方法区
结构
内存溢出
- 1.8以前会导致永久代PermGen space内存溢出
- 1.8以后会导致元空间内存溢出
//实例代码：-XX:MaxMetaspaceSize=8m 设置元空间大小
public static void main(String[] args)
int j = 0;
try
Demo1_8 test = new Demo1_8();
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);
常量池
二进制字节码的组成：类的基本信息、常量池、类的方法定义（包含了虚拟机指令）
通过反编译来查看类的信息
-
获得对应类的.class文件
-
在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 -
然后能在控制台看到反编译以后类的信息了
-
类的基本信息
-
常量池
-
虚拟机中执行编译的方法（框内的是真正编译执行的内容，#号的内容需要在常量池中查找）
-
运行时常量池
- 常量池
- 就是一张表（如上图中的constant pool），虚拟机指令根据这张常量表找到要执行的类名、方法名、参数类型、字面量信息
- 运行时常量池 run-time constant pool
- 常量池是*.class文件中的，当该类被加载以后，它的常量池信息就会放入运行时常量池，并把里面的符号地址变为真实地址
常量池与串池的关系
串池StringTable
特征
- 常量池中的字符串仅是符号，只有在被用到时才会转化为对象
- 利用串池的机制，来避免重复创建字符串对象
- 字符串变量拼接的原理是StringBuilder
- 字符串常量拼接的原理是编译器优化
- 可以使用intern方法，主动将串池中还没有的字符串对象放入串池中
- 注意：无论是串池还是堆里面的字符串，都是对象
用来放字符串对象且里面的元素不重复
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是由StringBuilder的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方法 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【str2返回的就是串池里的"ab"】
System.out.println(str2 == str3);
intern方法 1.6
调用字符串对象的intern方法，会将该字符串对象尝试放入到串池中
- 如果串池中没有该字符串对象，会将该字符串对象复制一份，再放入到串池中
- 如果有该字符串对象，则放入失败
无论放入是否成功，都会返回串池中的字符串对象
注意：此时无论调用intern方法成功与否，串池中的字符串对象和堆内存中的字符串对象都不是同一个对象
总结：
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); //false
System.out.println(s3 == s6); //true
String x2 = new String("c") + new String("d"); // new String("cd")
x2.intern(); // "cd"
String x1 = "cd";
// 问，如果调换了【最后两行代码】的位置呢，如果是jdk1.6呢
System.out.println(x1 == x2); //false
StringTable 垃圾回收
StringTable在内存紧张时，会发生垃圾回收
StringTable调优
-
因为StringTable是由HashTable实现的，所以可以适当增加HashTable桶的个数，来减少字符串放入串池所需要的时间
-XX:StringTableSize=xxxx -
考虑是否需要将字符串对象入池
可以通过intern方法减少重复入池
6、直接内存
- 属于操作系统，常见于NIO操作时，用于数据缓冲区
- 分配回收成本较高，但读写性能高
- 不受JVM内存回收管理
文件读写流程
使用了DirectBuffer
直接内存是操作系统和Java代码都可以访问的一块区域，无需将代码从系统内存复制到Java堆内存，从而提高了效率
释放原理
直接内存的回收不是通过JVM的垃圾回收来释放的，而是通过unsafe.freeMemory来手动释放
通过
//通过ByteBuffer申请1M的直接内存
ByteBuffer byteBuffer = ByteBuffer.allocateDirect(_1M);
申请直接内存，但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为虚引用的实际对象】
//在Deallocator里有unsafe.freeMemory(address);
att = null;
这里调用了一个Cleaner的create方法，且后台线程还会对虚引用的对象监测，如果虚引用的实际对象this（这里是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)
return;
unsafe.freeMemory(address); //释放直接内存中占用的内存
address = 0;
Bits.unreserveMemory(size, capacity);
直接内存的回收机制总结
- 使用了Unsafe类来完成直接内存的分配回收，回收需要主动调用freeMemory方法
- ByteBuffer的实现内部使用了
Cleaner（虚引用）来检测ByteBuffer。一旦ByteBuffer被垃圾回收，那么会由ReferenceHandler来调用Cleaner的clean方法调用freeMemory来释放内存
三、垃圾回收
1、如何判断对象可以回收
1.1 引用计数法
弊端：循环引用时，两个对象的计数都为1，导致两个对象都无法被释放
1.2可达性分析算法
- JVM中的垃圾回收器通过可达性分析来探索所有存活的对象
- 扫描堆中的对象，看能否沿着GC Root对象为起点的引用链找到该对象，如果找不到，则表示可以回收
- 可以作为GC Root的对象
- 虚拟机栈（栈帧中的本地变量表）中引用的对象。
- 方法区中类静态属性引用的对象
- 方法区中常量引用的对象
- 本地方法栈中JNI（即一般说的Native方法）引用的对象
- 被加锁的对象
1.3 五种引用
强引用
只有GC Root都不通过【强引用】引用该对象，改对象才能被垃圾回收
- 如上图B、C对象都不引用A1对象时，A1对象才会被回收
软引用SoftReference
当GC Root指向软引用对象时，在内存不足时，会回收软引用所引用的对象
- 如上图如果B对象不再引用A2对象且内存不足时，软引用所引用的A2对象就会被回收
软引用的使用
加载图片等比较大的资源，可以使用软引用，就不直接使用List去引用byte数组了List —> SoftReference —> byte[]
public static jvm笔记(代码片段)
一、什么是JVM定义JavaVirtualMachine，JAVA程序的运行环境（JAVA二进制字节码的运行环境）好处一次编写，到处运行自动内存管理，垃圾回收机制数组下标越界检查比较JVMJREJDK的区别二、内存结构整体架构1、程序... 查看详情
b站学习笔记之初探jvm学习笔记(代码片段)
写在前面本次笔记整理学习来源–>B站传送门–>【狂神说Java】JVM快速入门篇感谢狂神❤这位up的短视频知识点教学也很棒–>B站up主较真的度[程序员5分钟]白话JVM内存结构，死也忘不了;[程序员5分钟]带你认识java中jvm虚... 查看详情
java之jvm介绍（学习笔记入门）(代码片段)
为自己的学习笔记，图形说话java之所以这么强大是因为跨平台，最直接的就是jvm，每天我们都是写代码,CV大法。java->lcass-->jvm是如何演变呢？中间发生了啥？一、整个java的演变 图直观的看到如下：从... 查看详情
jvm内存管理笔记(代码片段)
郑重声明：本文属于个人学习笔记，严重参考姜新星大佬在拉勾教育平台的《Android工程师进阶34讲》。严重参考警告，侵删。JVM的运行时内存结构中一共有两个“栈”和一个“堆”，分别是：Java虚拟机栈和本... 查看详情
jvm内存管理笔记(代码片段)
郑重声明：本文属于个人学习笔记，严重参考姜新星大佬在拉勾教育平台的《Android工程师进阶34讲》。严重参考警告，侵删。JVM的运行时内存结构中一共有两个“栈”和一个“堆”，分别是：Java虚拟机栈和本... 查看详情
[jvm]螺丝刀学习笔记之——重学jvm概览(代码片段)
这里是螺丝刀本人在学习JVM专栏时，结合自己理解对一些重点概览做的提炼总结，为方便自己学习和记忆，也更加欢迎感兴趣的童鞋一起交流探讨。JVM是如何运行JAVA文件的？Java文件在打包成jar或者war后会变成Class... 查看详情
[jvm]螺丝刀学习笔记之——重学jvm概览(代码片段)
这里是螺丝刀本人在学习JVM专栏时，结合自己理解对一些重点概览做的提炼总结，为方便自己学习和记忆，也更加欢迎感兴趣的童鞋一起交流探讨。JVM是如何运行JAVA文件的？Java文件在打包成jar或者war后会变成Class... 查看详情
jvm学习笔记字节码指令集解析(代码片段)
一、class的文件结构1前端编译器 AOT效率较高，但只支持Linux平台。2透过字节码查看代码执行细节-1 源代码如下：publicclassTest publicstaticvoidmain(String[]args) Integerx=5; inty=5; System.out.println(x==y); Integ 查看详情
jvm学习笔记（自用）(代码片段)
1.jvm内存模型2.类加载器作用：加载Class文件类加载器分类：1.虚拟机自带的加载器2.启动类（根）加载器3.扩展类加载器4.应用程序（系统）加载器加载步骤：1.类加载器收到类加载的请求2.将这个请求向... 查看详情
《深入理解jvm3ed》读书笔记(代码片段)
...解JVM》出第三版了，遂买之更新JVM知识，本文为笔记，仅供个人Reviewch02.Java内存区域与内存溢出2.1运行时数据区域参考：JVM规范，MemoriesofaJavaRuntime堆：JVM启动时按-Xmx,-Xms大小创建的内存区域，用于分配... 查看详情
jvm学习笔记对象创建直接内存与执行引擎(代码片段)
一、对象的创建1对象实例化的几种方式2从字节码角度看对象的创建packagecom.spd.jvm;publicclassTest publicstaticvoidmain(String[]args) Objectobj=newObject(); 对应字节码：0new#2 //创建Object对象3dup //复制一份栈顶slot并压入栈中4invokes... 查看详情
jvm学习笔记类的加载过程(代码片段)
一、类的生命周期概述二、类的加载阶段Loading1加载完成的操作2二进制流的获取3类模型与class实例的位置 反射的使用：importjava.lang.reflect.Method;importjava.lang.reflect.Modifier;publicclassTest publicstaticvoidmain(String[]args) try Class&l 查看详情
jvm学习笔记类的加载过程(代码片段)
一、类的生命周期概述二、类的加载阶段Loading1加载完成的操作2二进制流的获取3类模型与class实例的位置 反射的使用：importjava.lang.reflect.Method;importjava.lang.reflect.Modifier;publicclassTest publicstaticvoidmain(String[]args) try Class&l 查看详情
b站狂神说java笔记-jvm快速入门篇(代码片段)
目录狂神视频地址JVM常问面试题1.JVM的位置2.JVM的体系结构3.类加载器4.双亲委派机制5.沙箱安全机制6.Native7.PC寄存器8.方法区9.栈10.三种JVM11.堆12.新生区、老年区13.永久区14.堆内存调优15.GC：垃圾回收机制15.1**垃圾回收=GC**15.... 查看详情
jvm笔记—java内存区域详解(代码片段)
JVM内存区域-常见面试题1.基本问题介绍下Java内存区域（运行时数据区）Java对象的创建过程（五步，必须能默写出来并且要知道每一步虚拟机做了什么）对象的访问定位的两种方式（句柄和直接指针两种方... 查看详情
jvm学习笔记超重点——字符串string(代码片段)
一、String的不可变性二、String底层的HashTable结构 1st，看一个例子：publicclassStringExr Stringstr=newString("good"); char[]ch=newchar[]'t','e','s','t'; public 查看详情
jvm垃圾回收阅读笔记(代码片段)
Java内存运行时区域的各个部分，其中程序计数器、虚拟机栈、本地方法栈3个区域随线程而生，随线程而灭，栈中的栈帧随着方法的进入和退出而有条不紊地执行着出栈和入栈操作。每一个栈帧中分配多少内存基本上是在类结构... 查看详情
jvm之方法区和堆的总结（学习笔记）(代码片段)
文章目录1、方法区1.1、方法区、永久代（`PermGenspace`）、`Metaspace`（元空间）的区别1.2、方法区的使用1.3、方法区和`字符串常量池存`的变化2、堆（heap）2.1、新生区（New/YoungGeneration&#x... 查看详情