volatile 关键字

背景

volatile 关键字在多线程编程中起到关键作用，主要用于解决变量的可见性和有序性问题，但其不保证原子性。

可见性

问题：

多个线程访问共享变量时，每个线程都会在自己的工作内存中缓存变量副本，导致一个线程的修改对其他线程不可见。

解决：

在 Java 中，volatile 关键字可以保证变量的可见性，如果将变量声明为 volatile，这就指示 JVM，这个变量是共享且不稳定的，每次使用这个变量都要到主存中读取最新的。

 未使用 volatile 关键字时：

使用 volatile 关键字时：

有序性

问题：

编译器和处理器可能会对指令进行重排序优化，导致代码执行顺序和预期不符。

解决：

volatile 通过内插入特定的存屏障的方式来禁止指令重排序，确保：

• 写操作前的代码不会重排到写操作之后
• 读操作后的代码不会重排到读操作之前

实践

双重检测单例模式

public class Singleton {private volatile static Singleton uniqueInstance;private Singleton() {}public static Singleton getUniqueInstance() {//先判断对象是否已经实例过，没有实例化过才进入加锁代码if (uniqueInstance == null) {//类对象加锁synchronized (Singleton.class) {if (uniqueInstance == null) {uniqueInstance = new Singleton();}}}return uniqueInstance;}
}

uniqueInstance = new Singleton(); 这段代码其实是分为三步执行：

1. 为 uniqueInstance 分配对象空间
2. 初始化 uniqueInstance
3. 将 uniqueInstance 指向分配的内存地址

但是由于 JVM 具有指令重排的特性，执行顺序有可能变成 1 -> 3 -> 2。指令重排在单线程环境下不会出现问题，但是在多线程环境下会导致一个线程获得还没有初始化的实例。例如，线程 T1 执行了 1 和 3，此时 T2 调用 getUniuqeInstance() 后发现 uniqueInstance 不为空，因此返回 uniqueInstance，但此时 uniqueInstance 还未被初始化。

不保证原子性

问题：

volatile 关键字不能保证对变量的操作是原子性的。

通过以下代码即可证明：

public class VolatileAtomicityDemo {public volatile static int inc = 0;public void increase() {inc++;}public static void main(String[] args) throws InterruptedException {ExecutorService threadPool = Executors.newFixedThreadPool(5);VolatileAtomicityDemo volatileAtomicityDemo = new VolatileAtomicityDemo();for (int i = 0; i < 5; i++) {threadPool.execute(() -> {for (int j = 0; j < 500; j++) {volatileAtomicityDemo.increase();}});}// 等待1.5秒，保证上面程序执行完成Thread.sleep(1500);System.out.println(inc);threadPool.shutdown();}
}

正常情况下，运行代码理应输出 2500 。但是真正运行了代码之后，就会发现每次输出结果都小于 2500 。如果 volatile 能保证 inc++ 操作的原子性的话。每个线程中对 inc 变量自增完之后，其他线程可以立即看到修改后的值。5 个线程分别进行了 500 次操作，那么最终 inc 的值应该是 5*500=2500 。

实际上，inc++ 是一个复合操作，包括三步：

1. 读取 inc 的值
2. 对 inc 加 1
3. 将  inc 的值写回内存

由于 volatile 无法保证这三个操作是具有原子性的，可能会到出现以下情况：

1. 线程 1 对 inc 进行读取操作后，还未对其进行修改。线程 2 又读取了 inc 的值，并对其进行修改(+1)，再将 inc 的值写回内存。
2. 线程 2 操作完毕后，线程 1 对 inc 的值进行修改(+1)，再将 inc 的值写回内存。

这就导致两个线程分别对 inc 进行了一次自增操作，但 inc 实际上只增加了 1。

解决：

使用 synchronized、Lock 或者 AtomicInteger 就可以保证上面代码运行正确。

• 使用 synchronized 改进：

public synchronized void increase() {inc++;
}

• 使用 AtomicInteger 改进：

public AtomicInteger inc = new AtomicInteger();public void increase() {inc.getAndIncrement();
}

• 使用 ReentrantLock 改进：

Lock lock = new ReentrantLock();
public void increase() {lock.lock();try {inc++;} finally {lock.unlock();}
}