Java内存模型中的volatile关键字
Java内存模型基础
在深入探讨 volatile 关键字之前，我们先来了解一下Java内存模型（Java Memory Model，JMM）的基本概念。JMM是一种抽象的规范，它定义了Java程序中多线程访问共享变量的规则。
主内存与工作内存
在JMM中，所有的变量都存储在主内存（Main Memory）中。每个线程还有自己独立的工作内存（Working Memory），线程对变量的操作（读取、写入等）都必须在工作内存中进行，而不能直接操作主内存中的变量。
当线程需要使用主内存中的变量时，它会将该变量从主内存拷贝到自己的工作内存中，然后对工作内存中的变量副本进行操作。当线程完成对变量副本的操作后，会将修改后的值再写回到主内存中。
内存可见性问题
由于每个线程都有自己的工作内存，这就可能导致内存可见性问题。假设有两个线程 A 和 B，线程 A 修改了一个共享变量的值并写回主内存，但是线程 B 可能并不知道这个变量已经被修改，因为它的工作内存中的变量副本还是旧值。这就使得线程 B 读取到的变量值与主内存中的实际值不一致。
以下是一个简单的代码示例来说明内存可见性问题：
public class VisibilityProblem {
private static int number = 0;
public static void main(String[] args) {
new Thread(() -> {
while (number == 0) {
// 线程1在等待number值变化
}
System.out.println("线程1发现number值已经不为0");
}).start();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(() -> {
number = 1;
System.out.println("线程2将number值修改为1");
}).start();
}
}
在上述代码中，线程1在一个 while 循环中等待 number 值变为非零。线程2在延迟1秒后将 number 值修改为1。理论上，线程2修改 number 值后，线程1应该能够跳出循环并打印相应信息。但实际上，线程1可能会一直处于循环中，这就是因为内存可见性问题。线程2修改的 number 值虽然写回了主内存，但线程1的工作内存中的 number 副本并没有及时更新，所以线程1一直读取到的是旧值0。
volatile关键字详解
volatile 关键字是Java提供的一种轻量级的同步机制，它主要用于解决内存可见性问题。当一个变量被声明为 volatile 时，它具有以下特性：
保证可见性
当一个线程修改了 volatile 变量的值，新值会立即被刷新到主内存中，并且其他线程在读取该变量时，会直接从主内存中读取最新的值，而不是从自己的工作内存中读取旧值。
我们对前面的代码进行修改，将 number 声明为 volatile：
public class VolatileVisibility {
private static volatile int number = 0;
public static void main(String[] args) {
new Thread(() -> {
while (number == 0) {
// 线程1在等待number值变化
}
System.out.println("线程1发现number值已经不为0");
}).start();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(() -> {
number = 1;
System.out.println("线程2将number值修改为1");
}).start();
}
}
在修改后的代码中，当线程2修改 number 值时，新值会立即刷新到主内存，线程1会从主内存中读取到最新的 number 值，从而跳出循环并打印信息。
禁止指令重排序
指令重排序是指编译器和处理器为了优化程序性能，在不改变程序语义的前提下，对指令的执行顺序进行重新排序。虽然指令重排序在单线程环境下不会影响程序的正确性，但在多线程环境下可能会导致问题。
volatile 关键字可以禁止指令重排序，确保 volatile 变量的写操作先于读操作完成。具体来说，在 volatile 写操作之前的所有操作都先于 volatile 写操作完成，并且 volatile 读操作之后的所有操作都在 volatile 读操作完成之后执行。
下面通过一个示例来理解指令重排序问题以及 volatile 如何解决：
public class InstructionReordering {
private static int a = 0;
private static int b = 0;
private static volatile boolean flag = false;
public static void main(String[] args) throws InterruptedException {
for (int i = 0; i < 1000000; i++) {
a = 0;
b = 0;
flag = false;
Thread thread1 = new Thread(() -> {
a = 1;
flag = true;
});
Thread thread2 = new Thread(() -> {
if (flag) {
b = a * 2;
}
if (b != 2) {
System.out.println("b的值不为2，a: " + a + ", b: " + b);
}
});
thread1.start();
thread2.start();
thread1.join();
thread2.join();
}
}
}
在上述代码中，线程1先将 a 赋值为1，然后将 flag 设置为 true。线程2在 flag 为 true 时，计算 b = a * 2。按照正常的执行顺序，b 的值应该为2。但是由于指令重排序，线程1可能先执行 flag = true，然后再执行 a = 1。这样当线程2执行 b = a * 2 时，a 可能还没有被赋值为1，从而导致 b 的值不为2。
通过将 flag 声明为 volatile，可以禁止指令重排序，保证 a = 1 先于 flag = true 执行，从而确保 b 的值始终为2。
volatile与原子性
需要注意的是，volatile 关键字并不能保证操作的原子性。原子操作是指不可被中断的操作，要么全部执行，要么全部不执行。
例如，对于 int 类型的变量 count，执行 count++ 操作实际上包含了三个步骤：读取 count 的值、对值进行加1操作、将结果写回 count。如果有多个线程同时执行 count++，可能会出现数据竞争问题。
以下代码展示了 volatile 不能保证原子性的情况：
public class VolatileAtomicity {
private static volatile int count = 0;
public static void increment() {
count++;
}
public static void main(String[] args) throws InterruptedException {
Thread[] threads = new Thread[100];
for (int i = 0; i < 100; i++) {
threads[i] = new Thread(() -> {
for (int j = 0; j < 1000; j++) {
increment();
}
});
threads[i].start();
}
for (Thread thread : threads) {
thread.join();
}
System.out.println("最终count的值: " + count);
}
}
在上述代码中，我们创建了100个线程，每个线程执行1000次 count++ 操作。理论上，最终 count 的值应该为100000，但实际上由于 count++ 不是原子操作，多个线程同时操作可能会导致数据不一致，最终 count 的值往往小于100000。
如果要保证原子性，可以使用 java.util.concurrent.atomic 包下的原子类，例如 AtomicInteger：
import java.util.concurrent.atomic.AtomicInteger;
public class AtomicityExample {
private static AtomicInteger count = new AtomicInteger(0);
public static void increment() {
count.incrementAndGet();
}
public static void main(String[] args) throws InterruptedException {
Thread[] threads = new Thread[100];
for (int i = 0; i < 100; i++) {
threads[i] = new Thread(() -> {
for (int j = 0; j < 1000; j++) {
increment();
}
});
threads[i].start();
}
for (Thread thread : threads) {
thread.join();
}
System.out.println("最终count的值: " + count.get());
}
}
AtomicInteger 类提供了原子操作方法，如 incrementAndGet，可以保证操作的原子性，最终 count 的值为100000。
volatile的使用场景
状态标志位
volatile 常用于定义状态标志位，例如线程的启动、停止等状态。
public class ThreadStateFlag {
private static volatile boolean stopFlag = false;
public static void main(String[] args) {
Thread thread = new Thread(() -> {
while (!stopFlag) {
// 线程执行任务
System.out.println("线程正在运行...");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("线程停止");
});
thread.start();
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
stopFlag = true;
}
}
在上述代码中，stopFlag 用于控制线程的停止。主线程在延迟5秒后将 stopFlag 设置为 true，工作线程能够及时感知到这个变化并停止运行。
单例模式中的双重检查锁定（DCL）
在单例模式中，双重检查锁定是一种常用的实现方式，volatile 在其中起到了关键作用。
public class Singleton {
private static volatile Singleton instance;
private Singleton() {
}
public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}
在上述代码中，instance 被声明为 volatile。这是因为 instance = new Singleton(); 这行代码实际上包含了多个步骤：分配内存空间、初始化对象、将 instance 指向分配的内存空间。如果没有 volatile，指令重排序可能会导致在对象还未完全初始化时，instance 就被赋值，从而其他线程获取到一个未初始化完全的对象。通过 volatile 禁止指令重排序，可以确保对象初始化完成后才将 instance 赋值。
volatile性能分析
volatile 关键字相比使用锁（如 synchronized）具有较低的性能开销。锁机制会导致线程阻塞，而 volatile 只是保证内存可见性和禁止指令重排序，不会阻塞线程。
在多线程环境下，如果只是需要保证变量的可见性，而不需要保证原子性，使用 volatile 是一个很好的选择。例如，在一些只读多写少的场景中，volatile 可以在保证数据一致性的同时，提高程序的性能。
然而，如果在多线程环境下需要对变量进行复杂的读写操作，并且需要保证操作的原子性，仅仅使用 volatile 是不够的，此时可能需要使用锁机制或原子类来确保数据的一致性和正确性。
总结与注意事项
volatile 关键字是Java内存模型中重要的一部分，它主要用于解决内存可见性和指令重排序问题。虽然它不能保证操作的原子性，但在很多场景下，它能够提供一种轻量级的同步解决方案，提高程序的性能和正确性。
在使用 volatile 时，需要注意以下几点：
- 只有在对变量的操作不涉及原子性问题，且主要关注内存可见性时，才适合使用
volatile。 - 避免过度使用
volatile，在需要保证复杂操作原子性的情况下，应使用锁机制或原子类。 - 理解
volatile的原理和特性，特别是它与指令重排序、内存可见性之间的关系，以正确使用volatile关键字编写高效、线程安全的代码。
通过深入理解 volatile 关键字，Java开发者可以更好地处理多线程编程中的内存可见性问题，编写出更健壮、高效的多线程程序。