对比 synchronized 和 volatile

synchronized 和 volatile 是 Java 中用于处理并发编程的两个重要关键字，它们的作用和适用场景有明显区别，但也有一定的互补性。以下是两者的详细对比：

核心区别

底层实现

• synchronized：
  • 依赖对象头中的 Monitor（监视器）实现，通过锁升级（偏向锁 → 轻量级锁 → 重量级锁）优化性能。
  • 涉及用户态与内核态的切换（重量级锁），成本较高。
• volatile：
  • 通过 JVM 插入内存屏障（如 StoreLoad 屏障）实现：
    • 写操作后插入屏障，确保写操作前的所有操作都已完成，并刷新到主内存。
    • 读操作前插入屏障，确保其他线程的写操作已刷新到主内存。

典型应用场景

结合使用示例

双重检查锁定（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 防止 new Singleton() 的指令重排序（如先分配内存再初始化对象），避免其他线程看到半初始化的对象。
  • synchronized 保证只有一个线程能创建实例。

选择建议

1. 仅需可见性：使用 volatile，如状态标志位。

   private volatile boolean shutdown = false;
   
   public void shutdown() {
         shutdown = true; }
   
   public void run() {
        
       while (!shutdown) {
         ... }  // 保证立即看到其他线程修改的 shutdown 值
   }
   

2. 需原子性+可见性：使用 synchronized 或 ReentrantLock，如计数器。

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

3. 复合操作：volatile 不适用，需使用锁或原子类（如 AtomicInteger）。

   private final AtomicInteger count = new AtomicInteger(0);
   public void increment() {
         count.incrementAndGet(); }  // 原子操作
   

总结

• 优先使用 volatile：当仅需保证变量可见性且不涉及复合操作时。
• 使用 synchronized：当需要保证原子性、可见性和有序性，且并发度不高时。
• 考虑原子类：在高并发场景下，对单个变量的复合操作优先使用 Atomic* 类（如 AtomicInteger）。