深入理解 Java 中的 volatile 和 synchronized 关键字

在多线程编程中，Java 提供了 volatile 和 synchronized 两种关键字来管理线程之间的交互。它们各自具有独特的特性，可以解决不同类型的并发问题。本文将结合两者的特点，深入探讨它们的用法、工作原理及实际开发中的应用场景。

---

什么是 volatile？

volatile 是一种轻量级的同步机制，用于确保变量的可见性和防止指令重排序。它主要解决以下两大问题：

1. 可见性
   当一个线程修改了 volatile 变量的值，其他线程会立即感知到这一变化。

2. 防止指令重排序
   通过 volatile 修饰的变量，编译器和处理器不会对其相关指令进行重排序优化。

示例代码

以下代码展示了 volatile 的一个典型使用场景：

public class VolatileExample {
    private static volatile boolean flag = false;

    public static void main(String[] args) {
        new Thread(() -> {
            System.out.println("Thread 1: 正在等待 flag 变为 true...");
            while (!flag) {
                // 循环等待
            }
            System.out.println("Thread 1: 结束等待，flag 已变为 true!");
        }).start();

        new Thread(() -> {
            try {
                Thread.sleep(2000); // 模拟延迟
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            flag = true;
            System.out.println("Thread 2: 已将 flag 设置为 true.");
        }).start();
    }
}

在这段代码中，Thread 1 能够及时感知到 flag 的改变，是因为 flag 被声明为 volatile，避免了线程缓存带来的数据可见性问题。

volatile 的局限性

1. 无法保证原子性
   对于复合操作（如 count++），volatile 不能确保线程安全。

2. 不支持锁机制
   volatile 仅能保证可见性，无法实现对共享资源的互斥访问。

---

什么是 synchronized？

synchronized 是 Java 提供的一种重量级同步机制，用于控制线程对共享资源的访问。它不仅可以确保可见性，还可以保证操作的原子性。

Synchronized 的用法

synchronized 可以用在方法上，也可以用在代码块中。

同步方法

public synchronized void incrementCount() {
    count++;
}

使用同步方法时，整个方法被锁定，保证在同一时间只有一个线程可以执行该方法。

同步代码块

public void incrementCount() {
    synchronized (this) {
        count++;
    }
}

同步代码块允许对特定的代码段进行同步，而非锁定整个方法，这样可以提高效率。

---

volatile 与 synchronized 的对比

特性	volatile	synchronized
可见性	保证	保证
原子性	不保证	保证
重排序	防止指令重排序	默认防止
性能开销	较低	较高，线程可能需要进入阻塞状态
适用场景	状态标识或简单变量	复杂逻辑或涉及多步操作的场景

---

结合使用 volatile 和 synchronized

在某些场景下，可以结合使用 volatile 和 synchronized，以便在提供线程安全的同时降低性能开销。例如，在单例模式的双重检查锁（DCL）中，volatile 和 synchronized 的组合是经典用法：

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;
    }
}

在这段代码中：

• volatile 保证 instance 的可见性，防止指令重排序。
• synchronized 确保实例化过程的线程安全。

---

总结

• volatile 是一种轻量级的同步机制，适用于标志位或简单变量的更新场景。
• synchronized 提供了更强的同步能力，适用于复杂的多步操作，但可能带来性能开销。
• 两者各有优缺点，可以结合实际需求选择使用，甚至在某些情况下可以配合使用。

通过正确理解和使用 volatile 和 synchronized，开发者可以更高效地编写多线程程序，既保障线程安全，又兼顾性能优化。这是 Java 并发编程中的重要一环，也是深入掌握多线程技术的关键步骤。

参考链接

深入理解 Java 中的 Synchronized 关键字

深入理解 Java 中的 volatile 关键字