JVM 基础(一)
参考文献
- 大白话带你认识 JVM - 掘金 (opens new window)
- 类加载过程详解 | JavaGuide (opens new window)
- 类加载器详解 | JavaGuide (opens new window)
- 【JVM 极简教程】2 小时快速学会 JVM,史上用时最短,效率最高!bilibili (opens new window)
# JVM 和 JMM
# Java 虚拟机
JVM 即 Java Virtual Machine,Java 虚拟机,是软件层面的对各类计算机功能的虚拟仿真模拟
相当于在操作系统上套了一层,他与操作系统交互,而不与硬件直接交互,调用 OS 系统功能向上提供统一的 Java 编程接口
JVM
↓ ↑
操作系统 OS
↓ ↑
硬件:磁盘、内存、CPU 等
2
3
4
5
参考容器技术的跨平台原理,所有软件跑在容器上,而非操作系统,从而实现跨操作系统的运行
Java 文件运行过程
需要注意的是,最后运行的一定是机器码
.java文本文件通过 javac 编译为.class字节码文件,而后在 JVM 中被解释为机器码并由 OS 执行- JVM 完成字节码到机器码的转换,这个字节码的翻译过程在各个操作系统上的 JVM 都是统一的,这是 Java 跨平台的核心逻辑
一句话说:JVM 是运行字节码的工具,Java 是一门编译型的语言,Java 编译器将文本文档编译为字节码,类似的字节码语言还有很多
JVM 的整体结构如下
# Java 内存模型
JMM(Java Memory Model),实际上是一套关于 Java 线程之间同步的约定
- 线程解锁前,必须把共享变量立刻同步刷回主存
- 在线程工作时,实际上是将主存中的变量拷贝一份到线程的工作内存中(值传递),对那份拷贝的变量进行操作
- 线程解锁前,必须将这份变量刷新回主存,使数据更新
- 线程加锁前,必须读取主存中的最新值到工作内存中
- 加锁和解锁必须使用同一把锁
关于线程、主内存、工作内存的八个操作
| 操作 | 解释 |
|---|---|
| lock | 锁定,作用域主内存的变量,把一个变量表示为线程独占状态 |
| unlock | 解锁,作用于主内存的变量,它把一个处于锁定状态的的变量释放出来,释放后的变量可以被其他线程锁定 |
| read | 读取,作用于主内存变量,它把一个变量的值从主内存传输到线程的工作内 |
| load | 载入,作用于工作内存的变量,它把 read 操作从主存中变量放入工作内存中 |
| use | 线程的执行引擎使用工作内存中的变量 |
| assignstore | 赋值,把执行引擎接受到的值重新赋给那个变量 |
| store | 把工作内存中的一个变量传送到主存中 |
| write | 把 store 操作从工作内存中得到的变量的值放入主存的变量中 |
JMM 对这八种指令的使用,制定了如下规则怪谈
- 不允许 read / load 和 store / write 操作之一单独出现,即 read 了必须 load ,store 了必须 write
- 不允许线程丢弃它最近的 assign 操作,即工作变量的数据改变了后必须告知主存
- 不允许一个线程将没有 assign 的数据从工作内存同步回主存
- 一个新变量必须从主存中诞生,不允许工作内存直接使用一个未被初始化的便改良,也就是说对变量实施 use、store 操作之前必须经过 load 和 assign 操作
- 一个变量同一时间只有一个线程能对其进行 lock,多次 lock 后,即重入锁后,必须执行相同次数的 unlcok 才能解锁
- 如果对同一变量进行 lock 操作,回清空所有工作内存中此变量的值,在执行引擎使用这个变量前,必须重新 load 或 assign 操作初始化变量的值
- 如果一个变量没有被 lock,就不同对其进行 unlock,也不能 unlock 一个被其他线程锁住的变量
- 对一个变量进行 unlock 操作之前,必须把此变量同步回主存
ThreadLocal 类:将数据与线程做绑定,类似于 Thread 的 Session,在多线程场景下做参数透传或数据流转
# Volatile 和原子类
对于以下代码
public class JMMTest {
private static volatile int num = 0;
public static void main(String[] args) {
//main线程
new Thread(()->{while(num==0){}}).start();
try {
TimeUnit.SECONDS.sleep(2);
num = 1;
System.out.println(num);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
当主存中变量更改后,线程的工作栈由于看不到这一改变,依旧在原来的基础上执行,即线程读入 num 为 0,导致线程一直卡死,即使在 2s 后 num 被主线程修改为 1 了,子线程依旧卡在这个 while 循环中
- 主线程对 num 的修改,子线程是“不可见的”
这个时候就要引入 volatile 关键字来解决这一问题,volatile 是 java 虚拟机提供的轻量级的同步机制
- 保证可见性
- 禁止指令重排
volatile 保证可见性:在上述代码中把 num 用 volatile 修饰后可解决线程对主存变量 num 的不可见性问题,当主线程修改 num 后,会同步到每一个读入了 num 的子线程
指令重排:什么是指令重排?我们写的程序,计算机并不是按照我们写的那样去一行行执行,它会经过编译器优化的重排 → 指令并行重排 → 内存系统重排 → 最后执行机器码
Volatile 禁止指令重排:禁止编译器对你所写代码的优化指令重排,在多线程场景下,例如某个线程中 a → b → c 和 a → c → b 的执行结果一样,但另一个线程依赖于 b 的中间状态,如果擅自的重排,可能导致复杂的错乱
但注意,Volatile 不保证原子性(事务性),在 Java 里,只有加锁能够保证代码执行的原子性
- 要么对 add 方法用 synchronized 修饰
- 要么用 lock 锁把 add 方法锁住
- 使用原子类解决原子性问题
加锁的方法不再赘述,我们来看看原子类(Atomic),这实际上是 JUC 的一个子包(java.util.concurrent.atomic.*),原子类的底层都直接和操作系统挂钩,通过 Unsafe 类直接调用的 C++ 实现的 Native 函数在内存中修改值,这是一个原子性的 +1
# CAS 和 ABA
CAS(compare and swap)是一种基于锁的操作(乐观锁),像 synchronized、Lock、ReadWriteLock 均为悲观锁,CAS 在操作数据前通过比较值来检查“是否可修改”,原子类就利用了 CAS 操作实现其原子性
但需要注意的是 Java 不能直接操作内存,但能直接操作 C++(navtive 方法),通过 C++ 来操作内存,C++ 是 Java 的后门,Unsafe 类即是 C++ 提供的一扇后门
点开 Unsafe 类可以发现其方法都是些 native 方法
compareAndSet
public class CASDemo {
public static void main(String[] args) {
//初始化 AtomicInteger
AtomicInteger atomicInteger = new AtomicInteger(2021);
//达到 expect 后 update 数值,即当atomicInteger为2021时更新其为2017,否则更新失败返回false
System.out.println(atomicInteger.compareAndSet(2021, 2017));
System.out.println(atomicInteger);
}
}
2
3
4
5
6
7
8
9
public final boolean compareAndSet(int expect, int update) {
return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}
2
3
public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);
getAndIncrement
import java.util.concurrent.atomic.AtomicInteger;
public class CASDemo {
public static void main(String[] args) {
//初始化 AtomicInteger
AtomicInteger atomicInteger = new AtomicInteger(2017);
//加一
atomicInteger.getAndIncrement();
System.out.println(atomicInteger);
}
}
2
3
4
5
6
7
8
9
10
11
public final int getAndIncrement() {
return unsafe.getAndAddInt(this, valueOffset, 1);
}
2
3
// 在 AtomicInteger 的 getAndIncrement 方法中 ——> var1=AtomicInteger.class(地址),var2=AtomicInteger.get()(当前值),var4=1
public final int getAndAddInt(Object var1, long var2, int var4) {
int var5;
//自旋锁
do {
//获取当前值:从地址上读取
var5 = this.getIntVolatile(var1, var2);
}
//与上类似,执行一个CAS(比较交换)函数:var1和var2确定当前值(地址+长度),var5为其先记录的当前值,当二者相同时,将自身替换为var5+var4(1)
while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
return var5;
}
2
3
4
5
6
7
8
9
10
11
12
13
缺点:循环会耗时;一次性只能保证一个共享变量的原子性;会引起 ABA 问题
ABA 问题:单纯的 CAS 会导致 ABA 问题,这是一种无感知的 A → B → A(把某次变更记录 amend 了,虽然最后的结果是一致的),在某些场景下是不被允许的(例如转账记录)
在以下情形,线程一并不会知道变量 A = 1 已经被线程二动过了(有一个 1 → 3 → 1 的过程),只会继续执行它的 CAS 操作,这样是不对的,因为线程一想操作的是原始的 1,而不是经过两次迭代回来的 1
原子引用:在 Java 中,为了解决上述问题,引入原子引用类AtomicStampedReference<V>,引入版本控制
该类用版本号的方式防止 ABA 问题,即每次 cas 操作后手动令版本号(stamp)加一,若线程中事先获得的版本号与当前类版本号不符,则无法实现 cas 操作
不符是指此处在线程 A 中事先记录的 stamp 与 atomicReference.getStamp() 不符,即版本号不符,无法进行 cas 操作
一个带上版本号的 CAS +1 操作,重的没边了
public class CASDemo02 {
public static void main(String[] args) throws InterruptedException {
AtomicStampedReference<Integer> atomicReference = new AtomicStampedReference<>(121, 0);
new Thread(()->{
int stamp = atomicReference.getStamp();
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(atomicReference.compareAndSet(121, 1, stamp, atomicReference.getStamp() + 1));
}, "A").start();
new Thread(()->{
System.out.println(atomicReference.compareAndSet(121, 95, atomicReference.getStamp(), atomicReference.getStamp() + 1));
System.out.println(atomicReference.compareAndSet(95, 121, atomicReference.getStamp(), atomicReference.getStamp() + 1));
}, "B").start();
TimeUnit.SECONDS.sleep(3);
System.out.println(atomicReference.getReference());
}
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# 类加载系统
# 类加载过程
众所周知,程序在内存中被执行(冯诺依曼机),当我们编写并编译好了字节码文件,到实际运行,还有一个内存加载的过程,这一过程由类加载子系统实现
从类被加载到虚拟机内存中开始,到释放内存总共有 5 个步骤:加载,链接,初始化,使用,卸载
- 其中链接包括:验证、准备和解析
类的加载指的是前三步:加载、链接和初始化
链接的三步走
- 验证:验证
.class文件格式 - 准备:给变量赋零值,在初始化时才会正式赋值
- 解析:将符号引用解析为直接引用,根据类名指定其在方法区的地址
# 类加载器
类加载器完成类的加载(加载、链接和初始化)
- 类加载器的主要作用就是动态加载 Java 类的字节码(
.class文件)到 JVM 中(在内存中生成一个代表该类的Class对象)
JVM 中内置了三个重要的ClassLoader(摘自 JavaGuide)
BootstrapClassLoader(启动类加载器):最顶层的加载类,由 C++实现,通常表示为 null,并且没有父级,主要用来加载 JDK 内部的核心类库(**%JAVA_HOME%/lib**目录下的rt.jar、resources.jar、charsets.jar等 jar 包和类)以及被-Xbootclasspath参数指定的路径下的所有类ExtensionClassLoader(扩展类加载器):主要负责加载**%JRE_HOME%/lib/ext目录下的 jar 包和类以及被java.ext.dirs系统变量所指定的路径下的所有类(现在是PlatformClassLoader**)AppClassLoader(应用程序类加载器):面向我们用户的加载器,负责加载当前应用**-classpath**下的所有 jar 包和类,如果是 SpringBoot 程序,这个目录将是target/classes,这个目录下所有的.class文件都会由 AppClassLoader 来进行加载
🌈 拓展一下
rt.jar:rt 代表“RunTime”,rt.jar是 Java 基础类库,包含 Java doc 里面看到的所有的类的类文件。也就是说,我们常用内置库java.xxx.*都在里面,比如java.util.*、java.io.*、java.nio.*、java.lang.*、java.sql.*、java.math.*- Java 9 引入了模块系统,并且略微更改了上述的类加载器。扩展类加载器被改名为平台类加载器(platform class loader)。Java SE 中除了少数几个关键模块,比如说
java.base是由启动类加载器加载之外,其他的模块均由平台类加载器所加载
以 JDK17 为例,从最上层的 ClassLoader 往下找(即 BootStrapClassLoader),先是 SecureClassLoader
- SecureClassLoader extends ClassLoader
- URLClassLoader extends SecureClassLoader
- BuiltinClassLoader extends SecureClassLoader
而后在jdk/internal/loader/ClassLoaders.java有(这个类很关键,维护了三个关键的类加载器)
- BootClassLoader extends BuiltinClassLoader
- PlatformClassLoader extends BuiltinClassLoader
- AppClassLoader extends BuiltinClassLoader
还找到一个 WebappClassLoader extends URLClassLoader,是 Tomcat 10.1.24 的启动器
加载器 Loader 以自顶向下的方式进行组织,每个 Loader 都会有一个 getParent 方法以获取其父类的加载器
- 注意:BootStrapClassLoader 的 getParent 将返回 null,因为其上层为 C++ 实现,并没有对应的 Java 类,而其余的 ClassLoader 均有双亲
# 双亲委派模型
向上委派,向下查找
双亲委派的作用
- 避免类的重复加载
- 防止核心 API 被篡改
类加载器有很多种,当我们想要加载一个类的时候,具体是哪个类加载器加载呢?这就需要提到双亲委派模型了,根据官网介绍
ClassLoader类使用委托模型来搜索类和资源,每个ClassLoader实例都有一个相关的父类加载器,需要查找类或资源时,ClassLoader实例会在试图亲自查找类或资源之前,将搜索类或资源的任务委托给其父类加载器虚拟机中被称为 "bootstrap class loader" 的内置类加载器本身没有父类加载器,但是可以作为
ClassLoader实例的父类加载器
用任意一个 Class 的 loadClass 方法,最终都会指向 ClassLoader 的 loadClass 方法,例如
public static void main(String[] args) throws ClassNotFoundException {
Class.class.getClassLoader().loadClass("cia.northboat.test.TreeTest");
}
2
3
一路 ctrl b loadClass 会指向 ClassLoader 的 loadClass 方法
- 在 567 行,首先会做一个 synchronized 的互斥,不允许同时加载同一个类
- 在 569 行,会做一个类是否被加载过的判断,这意味着类不会被重复加载
- 在 572-577 行,可以明确看到,每个 loadClass 都会去找其父类的 loadClass,直到找到 BootstrapClassLoader
这是一个递归调用,当找到 BootstrapClassLoader 后,由于其 parent 为 null,所以会执行 findBootstrapClassLoaderOrNull,其实现如下
static Class<?> findBootstrapClassOrNull(String name) {
if (!checkName(name)) return null;
return findBootstrapClass(name);
}
// return null if not found
private static native Class<?> findBootstrapClass(String name);
2
3
4
5
6
7
- 首先对要加载的类名进行检测
- 若通过,则调用 BootstrapClassLoader 的 native 方法 findBootstrapClass 去加载这个类
- 若未通过或 findBootstrapClass 加载失败,则会回到 BootstrapClassLoader 的上一级子类,执行 583-593 行代码,invoke 这个子类的 findClass 方法进行加载尝试
- 同理,若当前的 findClass 仍旧查找失败,c 仍旧返回 null,则会进一步到下一级 ClassLoader 进行 findClass
所谓向上委派,向下查找就是这个意思,这是一个递归的自顶向下的尝试加载的过程
这样能有效避免类的重复加载,即父类中加载过不为 null,子类就不会再尝试加载了,这样方法区里就只会保留一个类的一份信息
并且,由于自顶向下加载,所以 jdk 的核心类一定会先由顶层的 BootstrapClassLoader 来加载,类的加载是可控的,因为加载器的调用顺序被写死,你不可能跨过 BootstrapClassLoader 用一个下层的 XXXLoader 去加载 jre/lib 中的 class 文件
也就是说,jdk 可以指定一些类只能由 BootstrapClassLoader 加载,从而防止 jdk 的核心 API 被篡改
举一个简单的例子
public static void main(String[] args) throws ClassNotFoundException {
System.out.println(Class.class.getClassLoader());
System.out.println(String.class.getClassLoader());
System.out.println(EncryptedTree.class.getClassLoader());
}
2
3
4
5
以上将依次输出
null
null
jdk.internal.loader.ClassLoaders$AppClassLoader@63947c6b
2
3
这就说明,Class 类和 String 类(来自 jdk)都是由 BootstrapClassLoader 加载,而 EncryptedTree 由 AppClassLoader 加载
防止篡改的意思就是,这种底层类百分之一万是由 BootstrapClassLoader 加载的,你无法通过自定义的加载器加载,自然不可能加载进自定义的 String 类
# 自定义类加载器
Tomcat 为什么要用自定义加载器?
为了进行类的隔离,如果 Tomcat 直接使用 AppClassLoader 类加载类,那就会出现如下情况,假设同时有多个项目部署在 Tomcat 中
- 应用 A 中有一个 com.zhouyu.Hello.class
- 应用 B 中也有一个 com.zhouyu.Hello.class
- 虽然都叫做 Hello,但是具体的方法、属性可能不一样
- 如果 AppClassLoader 先加载了应用 A 中的 Hello.class
- 那么应用 B 中的 Hello.class 就不可能再被加载了,因为名字是一样
- 如果就需要针对应用 A 和应用 B 设置各自单独的类加载器,也就是 WebappClassLoader
- 这样两个应用中的 Hello.class 都能被各自的类加载器所加载,不会冲突
- 这就是 Tomcat 为什么用自定义类加载器的核心原因,为了实现类加载的隔离
- JVM 中判断一个类是否已经被加载的逻辑是:类名 + 对应的类加载器实例
也就是说,两个应用中的 Hello.class 对应的加载器实例是两个 WebappClassLoader 对象,以此供 JVM 来进行类的区分
# 运行时数据区
JVM 虚拟机的运行时数据区
- 方法区
- 虚拟机堆
- 虚拟机栈
- 本地方法栈
- 程序计数器
其中,方法区和堆属于线程共享区域,存在并发问题(蓝区);栈、本地方法栈和程序计数器属于线程独享区域,不存在线程安全问题(绿区);JVM 的调优主要就是围绕堆,栈两大块进行
- 例如:Student 类的信息将存储在方法区,Student 的一个实例对象 stu 存储在虚拟机堆中,stu 的 sayName() 方法和局部变量将存放在虚拟机栈
在类加载器中,类的加载,实际上就是把类的信息加载到方法区中
# 程序计数器
PC Register,程序计数寄存器
- 物理寄存器的抽象实现
- 用来记录待执行的下一跳指令的地址
- 程序控制流的指示器
- 解释器工作时通过程序计数器来获取下一条需要执行的字节码指令
- 唯一一个在 JVM 规范中没有规定任何 OutOfMemoryError 情况的区域(程序计数器不会出现内存溢出)
每个线程都会有一个程序计数器,只记录一个地址数字而已
# 方法区
方法区主要的作用技术存放类的元数据信息,常量和静态变量等等,当它存储的信息过大时,会在无法满足内存分配时报错
# 本地方法栈
本地方法,即 native method,例如 Thread 类的源码,其 start0 方法带有一个 native 关键字修饰,且不存在方法体,这种用 native 修饰的方法就是本地方法,这是底层 C++ 来实现,但在 Java 中定义的方法
和虚拟机栈一样,本地方法栈同样存储的是栈帧,只不过是本地方法调用过程中的栈帧,其同样是线程私有的,也可能出现 OOM 和 SOF
需要注意的是,如果执行的是 native 方法,程序计数器指针就不工作了
# 虚拟机栈
又称 Java 栈或 Java 方法栈,每个线程在创建时都会创建一个虚拟机栈,方法栈会保存一个个的栈帧,每个栈帧对应一个方法,其特点如下
- 虚拟机栈是线程私有的,生命周期和线程保持一致
- 一个方法开始执行栈帧入栈、方法执行完对应的栈帧就出栈,所以虚拟机栈不需要进行垃圾回收
- 虚拟机栈存在 OutOfMemoryError 和 StackOverflowError
- 线程太多,就可能会出现 OutOfMemoryError,线程创建时没有足够的内存去创建虚拟机栈了
- 方法调用层次太多,就可能会出现 StackOverflowError
- 可以通过 -Xss 指定参数来设置虚拟机栈的大小
栈帧结构
- 局部变量表:记录一个 Slot 变量数组,即局部变量的信息,包括局部变量的数量,地址和长度
- 操作数栈:执行字节码时,帮助进行计算的寄存器,类似于计算后缀表达式值时的操作数栈
以以下代码为例
public static void main(String[] args){
int a = 10, b = 20;
int c = a + b;
}
2
3
4
假设初始时,局部变量表为,其中数字标号表示变量的地址
| 局部变量表 | |
|---|---|
| 0(args) | |
| 1(a) | |
| 2(b) | |
| 3(c) |
其字节码大致如下
0: bipush 10
1: istore_1
2: bipush 20
3: istore_2
4: iload_1
5: iload_2
6: iadd
7: istore_3
8: return
2
3
4
5
6
7
8
9
操作数栈会经历以下步骤
- 压栈 10
- 弹栈,把 10 存入地址为 1 的变量,即 a
- 压栈 20
- 弹栈,把 20 存入地址为 2 的变量,即 b
- 从地址为 1 的内存取出值 10,压栈
- 从地址为 2 的内存取出值 20,压栈
- 执行加法指令,自动从操作数栈中取出两个值计算,并将结果 30 压栈
- 弹栈,把 30 存入地址为 3 的变量,即 c
最终,局部变量表将成为
| 局部变量表 | |
|---|---|
| 0(args) | |
| 1(a) | 10 |
| 2(b) | 20 |
| 3(c) | 30 |
# 虚拟机堆
堆是一个共享的内存区域,存储着所有 Java 对象和数组,程序中所使用的所有引用,都是按照地址从堆中获取
栈帧会随着方法的结束而消失,而方法中涉及到的对象不会立马被回收,因为对象和数组都存储在堆中,和虚拟机栈是相对独立的内存空间,只有在 JVM 后台执行 GC 后,对象才会被回收
堆的空间大小可以通过 Java 命令指定
- -Xms:ms 即 memory start,指定堆的初始化内存大小,等价于
-XX:InitialHeapSize - -Xmx:mx 即 memory max,指定堆的最大内存大小,等价于
-XX:MaxHeapSize
通常会把 -Xms 和 -Xmx 设为一样,这样在运行过程中,就不会在 GC 后去修改堆的大小,提高效率(这是建议的情况)
默认情况下(这是什么也不设置的情况)
- 初始化内存大小 = 物理内存大小 / 64
- 最大内存大小 = 物理内存大小 / 4
另外,可以通过`-XX: NewRatio``来配置新生代和老年代的比例,默认为 2,即
也就是说在整个堆中,新生代对象占 1/3,老年代对象占 2/3,一般情况下不需要手动调整,只有明确知道存活时间长的对象偏多,那么就要调大 NewRatio
在新生代中,又分为 Eden 区,Survivor0 区和 Survivor1 区,同样可以通过-XX: SurvivorRatio来进行调整,默认为8:1:1
- 其中 Survivor0 区又叫 S0 区,也叫 from 区
- Survivor1 区又叫 S1 区,也叫 to 区
S0 和 S1 区用来存放 MinorGC(YGC)后存在的对象
对象 A 在堆中各个区域的流转过程
- A 被创建后,首先待在 Eden 区,当 Eden 区满了,触发 GC,如果 A 仍存活,流转至 S0 区
- 经过不断的创建和 GC,S0 区也满了,同样触发 GC,此时 A 仍然存活,流转至 S1 区
- 经过不断的创建和 GC,S1 区也满了,触发 GC,A 仍存活,流转至 S0 区(对象将在 S0 和 S1 区来回交替)
- A 经过了 15 次 YGC(阈值)仍然存活在 S0/S1,又一次 GC,A 仍存活,则流转至老年代
除了上述进入老年代的情形,还有这样两种特殊情况
- 当 S0 和 S1 都放不下 Eden 区本次 GC 存活的对象 B,那么 B 会直接流转至老年代(直接从 Eden 区跳转到老年代)
- 还有一种情况,当创建了一个超大对象 C,整个 Eden 区都放不下,那么会直接把 C 放到老年代