前言
已知导致可见性的原因是缓存,导致有序性的原因是编译优化,那解决可见性、有序性最直接的办法就是禁用缓存
和编译优化
。但是,这样问题虽然解决了,我们程序的性能可就堪忧了。
合理的方案应该是按需禁用缓存
以及编译优化
。而 Java 内存模型规范了 JVM 如何提供按需禁用缓存和编译优化的方法。
Java 内存模型(Java Memory Model
),简称 JMM,它是一种抽象的概念,并不真实存在,它描述的一组规则或规范,通过这组规范定义了程序中各个变量的访问方式。
关键字 synchronized
在 Java 中,对基本数据类型的变量的读取和赋值操作是原子性操作,即这些操作是不可被中断的,要么执行,要么不执行。
Java 内存模型只保证了基本读取和赋值是原子性操作,如果要实现更大范围操作的原子性,可以通过对于 32 位系统来说,long 类型数据和 double 类型数据,它们的读写并非原子性的,也就是说如果存在两条线程同时对 long 类型或者 double 类型的数据进行读写,是存在相互干扰的。因为对于 32 位虚拟机来说,每次原子读写是 32 位,而 long 和 double 都是 64 位的存储单元,这样会导致一个线程 A 在写时,操作完成前 32 位的原子操作后,轮到线程 B 读取时,恰好只读取来后 32 位的数据,这样可能会读取到一个即非原值又不是线程修改值的变量,它可能是“半个变量”的数值,即 64 位数据被两个线程分成了两次读取。
synchronized
和 Lock
来实现。由于 synchronized
和 Lock
能够保证任一时刻只有一个线程执行该代码块,那么自然就不存在原子性问题了,从而保证了原子性。Java 语言提供的
synchronized
关键字,就是锁的一种实现。synchronized
它并不能改变 CPU 时间片切换的特点,只是当其他线程要访问这个资源时,发现锁还未释放,所以只能在外面等待,在释放锁之前会将对变量的修改刷新到主存当中。因此可以保证可见性。synchronized
关键字可以用来修饰方法,也可以用来修饰代码块,基本使用示例如下所示:class X {
// 修饰非静态方法
synchronized void say() {
// 临界区
}
// 修饰静态方法
synchronized static void eat() {
// 临界区
}
// 修饰代码块
Object obj = new Object();
void fly() {
synchronized(obj) {
// 临界区
}
}
}
注意:当修饰静态方法的时候,锁定的是当前类的 Class 对象,在上面的例子中就是 Class X;当修饰非静态方法的时候,锁定的是当前实例对象 this。
关键字 volatile
JVM 启动之后,操作系统会为 JVM 进程分配一定的内存空间,这部分内存空间就称为“主内存”。另外 Java 程序的所有工作都由线程来完成,而每个线程都会有一小块内存,称为“工作内存”,Java 中的线程在执行的过程中,会先将数据从主内存中复制到线程的工作内存,然后再执行计算,执行计算之后,再把计算结果刷新到“主内存”中。
这种工作内存与主内存同步延迟现象就会造成可见性问题,对此,Java 提供了关键字 volatile
来保证可见性。
关键字 volatile 的意义就是禁用 CPU 缓存。当一个共享变量被 volatile 修饰时,它会保证修改的值会立即被更新到主存,当有其他线程需要读取时,它会去内存中读取新值。
关键字 final
当你使用关键字 final
修饰某个类时,此类就不能被继承;修饰某个方法时,此方法可以被重载。
在 JDK 1.5 以后 Java 内存模型对 final 类型变量的重排进行了约束。只要我们提供正确构造函数没有“逸出”,就不会出问题了。
this 逸出
虽然 final
域写重排序规则可以确保我们在使用一个对象引用的时候该对象的 final
域已经在构造函数被初始化过了。但有一个前提条件的,也就是:在构造函数,不能让这个被构造的对象被其他线程可见,也就是说该对象引用不能在构造函数中“溢出”。
举个例子:在构造函数里面,变量 x 和变量 test 之间并没有数据依赖关系,它们的初始化顺序就可能被重排序:可能先初始化 test 再初始化 x。而将 this 赋值给了全局变量 test,这就是“逸出”,多线程通过 test 读取 x 是有可能读到 0 的。
public class FinalReferenceEscapeTest {
private final int x;
private FinalReferenceEscapeTest test;
// 错误的构造函数
public FinalReferenceEscapeTest() {
x = 1;
// 此处就是讲 this 逸出
test = this;
}
public void write(){
new FinalReferenceEscapeTest();
}
public void read(){
// 线程可能读取到 test == null
if(test != null){
// 有可能读取到 x 为 0
int y = test.x;
}
}
}
Happens-Before 原则
除了可以用关键字 synchronized
和 volatile
来保证有序性与可见性。除此之外,Java 还提供了 Happens-Before 规则。Happens-Before,直接翻译“先行发生”,但它不是说前面一个操作发生在后续操作的前面,它真正要表达的是:前面一个操作的结果对后续操作是可见的。
程序的顺序性规则
这条规则是指在一个线程中,按照程序顺序,前面的操作 Happens-Before 于后续的任意操作。
public class Example {
int x = 0;
/**
* 告诉编译器,对这个变量的读写,不能使用 CPU 缓存,必须从内存中读取或者写入
*/
volatile boolean v = false;
public void writer() {
x = 42;
// 更新 v 为 true
v = true;
}
public void reader() {
if (v == true) {
System.out.println("此时的 x 为:" + x);
}
}
}
按照程序的顺序,第 9 行代码 “x = 42;” Happens-Before 于第 11 行代码 “v = true;”,这比较符合单线程里面的思维:程序前面对某个变量的修改一定是对后续操作可见的。
在一个线程内,按照程序代码顺序,书写在前面的操作先行发生于书写在后面的操作。准确地说,应该是控制流顺序而不是程序代码顺序,因为要考虑分支、循环等结构。
volatile 变量规则
这条规则是指对一个 volatile 变量的写操作, Happens-Before 于后续对这个 volatile 变量的读操作。
管程中锁定规则
这条规则是指对一个锁的解锁 Happens-Before 于后续对这个锁的加锁。一个 unlock 操作先行发生于后面对同一个锁的 lock 操作。这里必须强调的是同一个锁,而"后面"是指时间上的先后顺序。
关键字 synchronized
是 Java 语言对管程的实现。管程中的锁在 Java 里是隐式实现的,例如下面的代码,在进入同步块之前,会自动加锁,而在代码块执行完会自动释放锁,加锁以及释放锁都是编译器帮我们实现的。
synchronized (this) { //此处自动加锁
// x 是共享变量,初始值为 10
if (this.x < 2021) {
this.x = 2021;
}
} //此处自动解锁
假设 x 的初始值是 10,线程 A 执行完代码块后 x 的值会变成 2021(执行完自动释放锁),线程 B 进入代码块时,能够看到线程 A 对 x 的写操作,也就是线程 B 能够看到 x==2021。
线程的启动规则
它是指主线程 A 启动子线程 B 后,子线程 B 能够看到主线程在启动子线程 B 前的操作。换句话说就是,如果线程 A 调用线程 B 的 start() 方法(即在线程 A 中启动线程 B),那么该 start() 操作 Happens-Before 于线程 B 中的任意操作。
Thread B = new Thread(()->{
// 主线程调用 B.start()之前
// 所有对共享变量的修改,此处皆可见
// 此例中,num==2233
});
// 此处对共享变量 num 修改
num = 2233;
// 主线程启动子线程
B.start();
线程的等待规则
这条是关于线程等待的。它是指主线程 A 等待子线程 B 完成(主线程 A 通过调用子线程 B 的 join() 方法实现),当子线程 B 完成后(主线程 A 中 join() 方法返回),主线程能够看到子线程的操作。当然所谓的“看到”,指的是对共享变量的操作。
换句话说就是,如果在线程 A 中,调用线程 B 的 join() 并成功返回,那么线程 B 中的任意操作 Happens-Before 于该 join() 操作的返回。
Thread B = new Thread(()->{
// 此处对共享变量var修改
var = 66;
});
// 例如此处对共享变量修改,
// 则这个修改结果对线程B可见
// 主线程启动子线程
B.start();
B.join()
// 子线程所有对共享变量的修改
// 在主线程调用 B.join() 之后皆可见
// 此例中,var==66
线程的中断规则
对线程 interrupt()
方法的调用先行发生于被中断线程的代码检测到中断事件的发生,可以通过 Thread.interrupted() 方法检测到是否有中断发生。
对象的终结规则
一个对象的初始化完成(构造函数执行结束)先行发生于它的 finalize()
方法的开始。
传递性规则
这条规则是指如果 A Happens-Before B,且 B Happens-Before C,那么 A Happens-Before C。就如同 10 > 9 且 9 > 8,那么 10 > 8。
参考
知乎专栏 - Java内存模型(JMM)总结
Java 全栈知识体系 - Java内存模型详解
2023年3月23日 06:49
2cwpgm