Java中的volatile关键字经典应用场景和常见问题

[普通写/读操作]  →  [StoreStore屏障]  →  [volatile写]  →  [StoreLoad屏障]

[volatile读]  →  [LoadLoad屏障]  →  [LoadStore屏障]  →  [普通写/读操作]

public class ShutdownHandler {
    private volatile boolean shutdownRequested = false;
    
    public void shutdown() {
        shutdownRequested = true;
    }
    
    public void doWork() {
        while (!shutdownRequested) {
            // 执行任务
        }
    }
}

public class Singleton {
    // 必须使用 volatile 防止指令重排序
    private static volatile Singleton instance;
    
    private Singleton() {}
    
    public static Singleton getInstance() {
        if (instance == null) {                     // 第一次检查：避免不必要的同步
            synchronized (Singleton.class) {
                if (instance == null) {             // 第二次检查：确保单例
                    // 创建对象分为三步（无volatile可能重排序）：
                    // 1. 分配内存空间
                    // 2. 初始化对象
                    // 3. 将引用指向内存地址
                    // volatile 确保 2 在 3 之前完成
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

public class Resource {
    private volatile Resource resource;
    
    public Resource getResource() {
        if (resource == null) {
            synchronized (this) {
                if (resource == null) {
                    resource = new Resource();
                }
            }
        }
        return resource;
    }
}

public class SensorReader {
    private volatile double currentTemperature;
    
    // 一个线程定期更新温度
    public void updateTemperature(double temp) {
        currentTemperature = temp;
    }
    
    // 多个线程同时读取最新的温度值
    public double getTemperature() {
        return currentTemperature;
    }
}

public class Counter {
    private volatile int count = 0;
    
    // 线程不安全！count++ 不是原子操作
    public void increment() {
        count++;  // 实际包含：读 → 加1 → 写 三个步骤
    }
}

// 方案1：使用 synchronized（适合复杂同步）
public class SynchronizedCounter {
    private int count = 0;
    
    public synchronized void increment() {
        count++;
    }
}

// 方案2：使用原子类（推荐，性能更好）
import java.util.concurrent.atomic.AtomicInteger;

public class AtomicCounter {
    private AtomicInteger count = new AtomicInteger(0);
    
    public void increment() {
        count.incrementAndGet();  // CAS操作，保证原子性
    }
    
    public int getCount() {
        return count.get();
    }
}

// 方案3：使用 volatile + CAS（高级用法）
public class VolatileCASCounter {
    private volatile int count = 0;
    private static final sun.misc.Unsafe UNSAFE = // 获取Unsafe实例
    
    public void increment() {
        int current;
        do {
            current = count;
        } while (!UNSAFE.compareAndSwapInt(this, OFFSET, current, current + 1));
    }
}

// volatile 变量访问 vs 普通变量访问
volatile int vCounter = 0;
int counter = 0;

// volatile 访问有约10-20%的性能损耗
// 但相比 synchronized 的数千倍性能损耗可忽略不计