开场

那天面试，面试官盯着我，问了一句：“小A，你对 volatile 了解吗？它是怎么解决并发问题的？”

我笑了笑，心想：还好这是我准备过的内容。于是，我坐直身子，点了点头：“volatile 是 Java 中的一个关键字，虽然简单，但它有着独特的魔力——在多线程环境中，它可以解决线程间的可见性问题，还能防止指令重排序。我给您讲讲它的作用和用法吧。”

volatile 的核心作用

我一边说，一边掏出笔在纸上写了两个关键点：

1. 保证可见性：
   当一个线程修改了 volatile 修饰的变量，其他线程立刻可以看到这个修改。
2. 防止指令重排序：
   编译器和 CPU 会优化代码执行顺序，而 volatile 能确保被修饰变量的读写操作不会乱序。

我举了个例子来说明：“比如，你开了一家咖啡店，所有员工都有一份菜单。某天你决定新增一款新品，如果不通知大家修改菜单，员工还是会按旧菜单服务。volatile 就像广播通知，告诉所有人菜单已经更新。”

实际问题：线程间的可见性

为了让面试官更明白，我继续举了一个实际问题。

“假如我们有一个任务线程在后台运行，它依赖一个标志位来决定是否继续执行。主线程负责修改标志位以停止任务。”

我写下了第一段代码：

class Task {
    private boolean running = true; // 标志位

    public void stop() {
        running = false;
    }

    public void run() {
        while (running) {
            // 模拟任务
        }
        System.out.println("Task stopped.");
    }
}

我解释道：“看似没问题，但在多线程环境中，running 的修改可能在主线程的本地缓存中停留，任务线程看不到这个变化，导致程序无法停止。”

解决方案：用 volatile 修饰标志位

我补充道：“为了让任务线程立刻感知到标志位的变化，我们可以用 volatile 关键字。”

我快速写下第二段代码：

class Task {
    private volatile boolean running = true; // 用 volatile 修饰

    public void stop() {
        running = false;
    }

    public void run() {
        while (running) {
            // 模拟任务
        }
        System.out.println("Task stopped.");
    }
}

我总结：“加上 volatile 后，主线程修改 running 的值后，任务线程会立刻感知到这个变化，程序可以正常停止。”

防止指令重排序

接着，我说：“volatile 的另一个作用是防止指令重排序，尤其在双重检查锁实现单例模式中非常重要。”

我继续写代码：“比如，我们实现一个懒加载单例模式，如果没有 volatile，可能会因为指令重排序导致线程拿到一个未初始化完全的实例。”

class Singleton {
    private static volatile Singleton instance; // volatile 确保可见性和有序性

    private Singleton() {}

    public static Singleton getInstance() {
        if (instance == null) { // 第一次检查
            synchronized (Singleton.class) {
                if (instance == null) { // 第二次检查
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

我解释：“这里的 volatile 确保 instance 的初始化过程不会被重排序，从而避免其他线程获取到未完全初始化的对象。”

volatile 的局限性

看到面试官似乎挺满意，我接着说道：“不过，volatile 虽然好用，但它也有自己的局限性。比如——”

1. 不保证原子性：
   “volatile 只能解决可见性问题，但它不能保证原子性。比如我们用 volatile 修饰一个计数器，它还是会有线程安全问题。”

我写下了代码：

class Counter {
    private volatile int count = 0;

    public void increment() {
        count++; // 非原子操作
    }
}

我解释：“这里的 count++ 实际上包含三步（读取、计算、写回），如果多个线程同时执行，可能会导致数据丢失。这个时候我们就需要用 synchronized 或 AtomicInteger。”

2. 复杂同步场景不适用：
   “如果线程间有复杂的依赖关系，volatile 就显得无力了。这种情况下，synchronized 或其他并发工具会更适合。”

volatile 和 synchronized 的区别

为了更直观，我拿出了一个比喻：“如果把并发问题比作交通问题——”

• volatile 就像红绿灯：
  它能让每辆车（线程）知道什么时候可以走，什么时候需要停下，但它不能解决谁先走的问题。
• synchronized 就像交通警察：
  它可以直接控制哪辆车先走，并保证整个过程是安全且有序的。

我补充道：“所以，volatile 更适合轻量级的线程间通信，而 synchronized 适用于复杂的临界区操作。”

总结与实践感悟

最后，我总结道：“volatile 是一个轻量级的同步工具，主要解决可见性问题，同时防止指令重排序。在实际使用中，它非常适合——”

1. 标志位控制：
   用来通知线程停止、启动等简单状态管理。
2. 双重检查锁：
   确保单例模式中的线程安全。
3. 轻量级场景：
   比如简单的读写操作，不需要复杂的锁机制。

“但在涉及原子性或复杂同步逻辑时，我们还是需要 synchronized 或 java.util.concurrent 包下的工具。”