Java 关键字 volatile

volatile 是 Java 中的一个关键字，用于修饰变量，确保多线程环境下的可见性和有序性。它主要用于解决以下两个问题：

1. 可见性问题 ：一个线程对 volatile 变量的修改对其他线程立即可见。
2. 有序性问题：禁止指令重排序，确保代码的执行顺序符合预期。

---

1. 可见性问题

在多线程环境中，每个线程都有自己的工作内存（缓存），线程对变量的操作通常是在工作内存中进行的。如果没有同步机制，一个线程对变量的修改可能不会立即反映到主内存中，其他线程也就无法看到最新的值。

示例：非 volatile 变量的可见性问题

public class VisibilityProblem {
    private static boolean flag = false; // 非 volatile 变量

    public static void main(String[] args) {
        new Thread(() -> {
            while (!flag) {
                // 空循环
            }
            System.out.println("Flag is now true");
        }).start();

        try {
            Thread.sleep(1000); // 主线程休眠 1 秒
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        flag = true; // 修改 flag 的值
        System.out.println("Flag set to true");
    }
}

问题：

• 由于 flag 不是 volatile 变量，子线程可能无法看到主线程对 flag 的修改，导致子线程陷入死循环。

解决方案：使用 volatile

private static volatile boolean flag = false; // 使用 volatile 修饰

效果：

• volatile 确保对 flag 的修改立即写入主内存，其他线程也能立即看到最新的值。

---

2. 有序性问题

Java 编译器和处理器可能会对指令进行重排序以优化性能，但这可能导致多线程环境下的行为不符合预期。volatile 可以禁止指令重排序，确保代码的执行顺序符合程序员的意图。

示例：指令重排序问题

public class ReorderingProblem {
    private static int x = 0;
    private static int y = 0;
    private static boolean ready = false;

    public static void main(String[] args) {
        new Thread(() -> {
            while (!ready) {
                // 空循环
            }
            System.out.println("x: " + x + ", y: " + y);
        }).start();

        x = 1;
        y = 2;
        ready = true;
    }
}

问题：

• 由于指令重排序，ready = true 可能会在 x = 1 和 y = 2 之前执行，导致子线程看到 ready 为 true，但 x 和 y 的值仍然是 0。

解决方案：使用 volatile

private static volatile boolean ready = false; // 使用 volatile 修饰

效果：

• volatile 禁止指令重排序，确保 ready = true 在 x = 1 和 y = 2 之后执行。

---

volatile 的工作原理

1. 内存可见性 ：
   • 对 volatile 变量的写操作会立即刷新到主内存。
   • 对 volatile 变量的读操作会从主内存中读取最新的值。
2. 禁止指令重排序 ：
   • volatile 变量的读写操作前后会插入内存屏障（Memory Barrier），确保指令不会被重排序。

---

volatile 的局限性

• 不保证原子性 ：
  • volatile 只能保证单个读/写操作的原子性，但不能保证复合操作的原子性。
  • 例如，i++ 不是原子操作，即使 i 是 volatile 变量，多线程环境下仍然可能出现问题。

示例：volatile 不保证原子性

public class VolatileAtomicity {
    private static volatile int count = 0;

    public static void main(String[] args) throws InterruptedException {
        Runnable task = () -> {
            for (int i = 0; i < 1000; i++) {
                count++; // 非原子操作
            }
        };

        Thread t1 = new Thread(task);
        Thread t2 = new Thread(task);

        t1.start();
        t2.start();

        t1.join();
        t2.join();

        System.out.println("Final count: " + count); // 结果可能小于 2000
    }
}

解决方案：

• 使用 synchronized 或 java.util.concurrent.atomic 包中的原子类（如 AtomicInteger）。

---

volatile 的使用场景

1. 状态标志：

   • 例如，一个线程修改标志变量，另一个线程读取标志变量。

   private volatile boolean running = true;
   
   public void stop() {
       running = false;
   }
   
   public void run() {
       while (running) {
           // 执行任务
       }
   }

2. 双重检查锁定（Double-Checked Locking）：

   • 用于单例模式中，确保实例的可见性。

   public class Singleton {
       private static volatile Singleton instance;
   
       public static Singleton getInstance() {
           if (instance == null) {
               synchronized (Singleton.class) {
                   if (instance == null) {
                       instance = new Singleton();
                   }
               }
           }
           return instance;
       }
   }

---

总结

• volatile 用于解决多线程环境下的可见性和有序性问题。
• 它不能保证复合操作的原子性，适用于简单的状态标志或双重检查锁定等场景。
• 如果需要更复杂的同步机制，可以结合 synchronized 或原子类使用。