java 中的 volatile 关键字通过插入内存屏障(memory barrier)来禁止特定类型的指令重排序,从而保证可见性和有序性。具体做法是在变量读写操作前后插入不同类型的屏障:写操作后插入 storestore 和 storeload 屏障,读操作前插入 loadload 和 loadstore 屏障。这确保了 volatile 变量的写操作在语义上先于后续的任何读或写操作完成,且其后的读操作不会与前面的写操作重排。

volatile 写操作如何阻止后续读写的重排?
volatile 的写操作会在其后插入 StoreStore 和 StoreLoad 内存屏障。StoreStore 屏障确保该 volatile 写之前的所有普通写操作都不会被重排序到该 volatile 写之后;StoreLoad 屏障确保该 volatile 写之后的所有读写操作都不会被重排序到该 volatile 写之前。这意味着,一旦一个线程完成了对 volatile 变量的写,其他线程随后对该变量的读就能看到这次写入的结果,且该写操作不会被“推后”到后续代码执行完毕后再生效。

public class VolatileWriteExample {
private volatile boolean flag = false;
private int data = 0;
public void writer() {
data = 42; // 普通写
flag = true; // volatile 写
// 此处隐含 StoreStore 和 StoreLoad 屏障
}
public void reader() {
if (flag) { // volatile 读
System.out.println(data);
}
}
}
在上述代码中,data = 42 是普通写,flag = true 是 volatile 写。JMM 保证 data = 42 不会重排序到 flag = true 之后。如果重排序发生,其他线程可能在 data 尚未赋值时就看到 flag 为 true 并读取 data,导致读到脏数据。StoreStore 屏障防止了这种重排。
volatile 读操作如何阻止前面读写的重排?
volatile 的读操作会在其前插入 LoadLoad 和 LoadStore 内存屏障。LoadLoad 屏障确保该 volatile 读之后的所有读操作都不会被重排序到该 volatile 读之前;LoadStore 屏障确保该 volatile 读之后的所有写操作都不会被重排序到该 volatile 读之前。这保证了在读取 volatile 变量时,能看到之前所有 volatile 写操作的最新结果,且该读操作不会被“提前”到前面的代码执行完毕前就执行。
使用 Husky 将 pre-commit、pre-push 和 commit-msg 检查集成到仓库中,以便代理和开发人员在更改离开工作站之前运行相同的本地防护措施。

public class VolatileReadExample {
private volatile boolean flag = false;
private int data = 0;
public void writer() {
data = 42;
flag = true;
}
public void reader() {
if (flag) { // volatile 读
// 此处隐含 LoadLoad 和 LoadStore 屏障
System.out.println(data);
}
}
}
在 reader 方法中,if (flag) 是 volatile 读。LoadLoad 屏障确保 System.out.println(data) 中的读 data 不会重排序到 flag 的读之前。如果没有这个屏障,编译器或处理器可能将 data 的读取提前,导致在 flag 尚未确认为 true 时就读取了旧的 data 值。LoadStore 屏障则确保后续的写操作也不会提前到 flag 的读之前。
双重检查锁定(DCL)中 volatile 的作用是什么?
在双重检查锁定模式中,volatile 用于修饰单例实例变量,以防止指令重排序导致的线程安全问题。如果不使用 volatile,对象初始化过程中的内存分配、属性赋值和引用赋值可能发生重排序,导致其他线程获取到一个未完全初始化的对象引用。
public class Singleton {
private static volatile Singleton instance;
public static Singleton getInstance() {
if (instance == null) { // 第一次检查
synchronized (Singleton.class) {
if (instance == null) { // 第二次检查
instance = new Singleton(); // volatile 写
}
}
}
return instance;
}
}
在 instance = new Singleton() 这一行,实际包含三个步骤:1. 分配内存空间;2. 初始化对象;3. 将引用指向内存空间。如果没有 volatile,步骤 2 和 3 可能被重排序。此时,线程 A 执行完步骤 1 和 3,但尚未执行步骤 2,线程 B 进入 getInstance,发现 instance != null,直接返回 instance,但此时对象尚未初始化,导致错误。加入 volatile 后,步骤 2 和 3 之间的重排序被禁止,确保只有当对象完全初始化后,引用才会被赋值,从而保证线程安全。
Java免费学习笔记:立即使用
解锁 Java 大师之旅:从入门到精通的终极指南










