【JAVA-面经】8.Java 中的 volatile 关键字详解

深入解析 Java 中的 volatile 关键字

在 Java 并发编程中，volatile 是一个经常被提及的关键字。它提供了一种轻量级的同步机制，主要解决了多线程环境下共享变量的可见性问题。本文将详细介绍 volatile 的工作原理、使用场景以及它的优缺点，帮助你更好地理解并发编程中的这个关键工具。

---

一、volatile 关键字的作用

volatile 关键字用于修饰变量，保证了变量在多线程环境下的可见性。在没有 volatile 的情况下，多个线程可能会对变量的副本进行操作，而非直接操作主内存中的值，导致线程间无法感知彼此的修改。通过 volatile，Java 保证了所有线程访问的都是变量的最新值。

volatile的两大作用：

1. 可见性：当一个线程修改了 volatile 变量，其他线程能够立即感知到这个修改。
2. 禁止指令重排序：对 volatile 变量的读写操作，不能被 JVM 以及 CPU 指令重排序优化，从而保证操作的顺序性。

---

二、volatile 的工作原理

在多线程环境下，线程通常会将共享变量从主内存加载到各自的 CPU 缓存中进行操作，这样可以提高执行效率。但是，这也带来了一个问题：如果一个线程修改了共享变量的值，其他线程并不能立即知道，因为各个线程可能操作的是不同的缓存副本。

volatile 通过以下两点来解决这一问题：

• 内存屏障：在每次读写 volatile 变量时，Java 会通过插入“内存屏障（Memory Barrier）”来保证缓存一致性。写操作后会立即刷新到主内存，读操作时则强制从主内存中获取最新值。
• 禁止指令重排序：编译器和处理器在 volatile 变量前后插入内存屏障，防止指令重排序优化，保证指令按编写的顺序执行。

---

三、volatile 与 synchronized 的区别

1. 修饰范围

   • volatile：只能修饰变量。
   • synchronized：可以修饰方法或代码块，用于锁定代码逻辑。

2. 保证的属性

   • volatile：仅保证可见性，即当一个线程修改变量时，其他线程能够立即看到变化。
   • synchronized：保证原子性和可见性。它确保线程对代码块或方法的独占访问，确保复合操作的完整性和线程安全性。

3. 性能与线程阻塞

   • volatile：不会造成线程阻塞，属于轻量级同步。适用于不需要复杂操作的场景。
   • synchronized：会造成线程阻塞，当一个线程进入 synchronized 修饰的代码块或方法时，其他线程需要等待，属于重量级同步。

4. JVM 优化

   • volatile：背后没有特殊的优化操作，仅保证变量的可见性。
   • synchronized：JVM 对 synchronized 进行了大量的优化，例如偏向锁、轻量级锁和自旋锁等，来提升性能。

5. 本质区别

   • volatile：通过告诉 JVM，该变量的值是不稳定的，需要从主存中读取最新值，从而保证可见性。

   • synchronized：通过锁定某段代码或对象，确保同一时间只有一个线程可以访问被锁定的代码或资源，其他线程会被阻塞等待，直到锁被释放。

     1. 使用 volatile 关键字（不保证原子性）

     volatile 关键字只能保证变量的可见性，但无法确保复合操作（如 count++）的原子性。count++ 是一个非原子操作，包含三个步骤：读取值、增加值、写回值。多个线程可能同时执行这些步骤，导致线程安全问题。

     public class VolatileCountExample {
         private volatile int count = 0;
     
         // 增加 count 值，不保证原子性
         public void increment() {
             count++;  // 不是原子操作
         }
     
         public int getCount() {
             return count;
         }
     
         public static void main(String[] args) throws InterruptedException {
             VolatileCountExample example = new VolatileCountExample();
     
             // 创建多个线程执行 increment 操作
             Thread t1 = new Thread(example::increment);
             Thread t2 = new Thread(example::increment);
     
             t1.start();
             t2.start();
     
             t1.join();
             t2.join();
     
             System.out.println("Final count: " + example.getCount());  // 结果可能小于预期
         }
     }
     

     在这个例子中，count++ 是一个非原子操作，尽管 volatile 保证了 count 的可见性，但多个线程同时进行 count++ 操作时，仍然可能出现线程安全问题。例如，两个线程可能都读取了相同的 count 值并将其增加，从而丢失一次加法操作，最终结果可能小于预期。

     ---

     2. 使用 synchronized 关键字（保证原子性）

     count++ 是一个复合操作，涉及多个步骤。为了确保多个线程同时访问时操作的完整性和线程安全性，我们可以使用 synchronized 来确保这些步骤的原子性。

     public class SynchronizedCountExample {
         private int count = 0;
     
         // 使用 synchronized 确保 count++ 操作的原子性
         public synchronized void increment() {
             count++;
         }
     
         public synchronized int getCount() {
             return count;
         }
     
         public static void main(String[] args) throws InterruptedException {
             SynchronizedCountExample example = new SynchronizedCountExample();
     
             // 创建多个线程执行 increment 操作
             Thread t1 = new Thread(example::increment);
             Thread t2 = new Thread(example::increment);
     
             t1.start();
             t2.start();
     
             t1.join();
             t2.join();
     
             System.out.println("Final count: " + example.getCount());  // 结果是预期的 2
         }
     }
     

     在这个示例中，synchronized 确保了 count++ 操作的原子性。由于 increment 方法被 synchronized 修饰，多个线程无法同时进入该方法，这样可以避免线程安全问题，保证 count 的最终结果是正确的。

---

四、volatile 的局限性

尽管 volatile 提供了一定的线程安全性，但它并不能完全替代 synchronized 或其他锁机制。它的主要局限性包括：

1. 不保证原子性：volatile 只保证可见性，不能保证原子性。例如，volatile 无法解决 i++ 操作的线程安全问题。i++ 是一个复合操作，包含读取和写入多个步骤，而这些步骤可能会被其他线程打断，从而导致错误的结果。

2. 不能同步多个变量：volatile 只能确保单个变量的可见性，无法对多个变量的操作进行同步。而 synchronized 可以通过锁定代码块来保证多个变量的原子性操作。

---

五、volatile 的适用场景

volatile 适用于一些特定的场景，主要包括以下几类：

1. 状态标志：用于实现简单的开关控制，在多个线程中共享一个状态标志，当标志变化时，其他线程能够立即感知到。

   private volatile boolean running = true;
   
   public void stop() {
       running = false;
   }
   
   public void run() {
       while (running) {
           // do something
       }
   }
   

2. 单例模式中的双重检查锁（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;
       }
   }
   

3. volatile 替代锁：在某些场景中，如果仅需要同步读写简单的标志或单一变量，可以使用 volatile 来替代锁，从而减少性能开销。相比于 synchronized 关键字，volatile 是一种更轻量级的同步机制。synchronized 不仅要保证可见性，还要确保原子性，这会引入线程的阻塞和上下文切换，而 volatile 仅保证可见性，不会阻塞线程。

   示例代码：

   private volatile boolean running = true;
   
   public void stop() {
       running = false;  // 其他线程能够立即看到该值的变化
   }
   
   public void run() {
       while (running) {
           // 执行任务，直到running被置为false
       }
   }
   

   在上述代码中，running 作为标志变量，由于它被声明为 volatile，当某个线程调用 stop() 方法时，running 的值变化可以立即被其他线程感知，因此可以不需要使用锁来保证同步。

   volatile 替代锁的场景

   • 单一标志位的同步：使用 volatile 非常适合同步简单的状态标志，如 running 的状态变化。

   • 写操作简单，读多写少的场景：如果一个变量主要是被多个线程读取，且写入次数较少，volatile 可以避免锁的开销。

   • 轻量级状态变量：volatile 适用于对性能要求较高的状态变量，例如取消操作标志和状态切换标志。

---

六、总结

volatile 是 Java 中非常有用的关键字，通过保障可见性和禁止指令重排序，解决了多线程中共享变量的可见性问题。在一些特定的应用场景中，volatile 可以替代锁，减少性能损耗。但它并不能保证复合操作的原子性，也不能同步多个变量，因此在复杂的并发场景中，仍需要使用 synchronized 或 Lock 等机制。

使用 volatile 的核心要点：

• 适用于轻量级读写、状态标志等简单场景；
• 无法保证复合操作的原子性；
• 是锁机制的补充，提供更轻量级的并发解决方案。