[普通寫/讀操作]  →  [StoreStore屏障]  →  [volatile寫]  →  [StoreLoad屏障]

[volatile讀]  →  [LoadLoad屏障]  →  [LoadStore屏障]  →  [普通寫/讀操作]

public class ShutdownHandler {
    private volatile boolean shutdownRequested = false;
    
    public void shutdown() {
        shutdownRequested = true;
    }
    
    public void doWork() {
        while (!shutdownRequested) {
            // 執(zhí)行任務(wù)
        }
    }
}

public class Singleton {
    // 必須使用 volatile 防止指令重排序
    private static volatile Singleton instance;
    
    private Singleton() {}
    
    public static Singleton getInstance() {
        if (instance == null) {                     // 第一次檢查：避免不必要的同步
            synchronized (Singleton.class) {
                if (instance == null) {             // 第二次檢查：確保單例
                    // 創(chuàng)建對(duì)象分為三步（無(wú)volatile可能重排序）：
                    // 1. 分配內(nèi)存空間
                    // 2. 初始化對(duì)象
                    // 3. 將引用指向內(nèi)存地址
                    // 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;
    
    // 一個(gè)線程定期更新溫度
    public void updateTemperature(double temp) {
        currentTemperature = temp;
    }
    
    // 多個(gè)線程同時(shí)讀取最新的溫度值
    public double getTemperature() {
        return currentTemperature;
    }
}

public class Counter {
    private volatile int count = 0;
    
    // 線程不安全！count++ 不是原子操作
    public void increment() {
        count++;  // 實(shí)際包含：讀 → 加1 → 寫 三個(gè)步驟
    }
}

// 方案1：使用 synchronized（適合復(fù)雜同步）
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（高級(jí)用法）
public class VolatileCASCounter {
    private volatile int count = 0;
    private static final sun.misc.Unsafe UNSAFE = // 獲取Unsafe實(shí)例
    
    public void increment() {
        int current;
        do {
            current = count;
        } while (!UNSAFE.compareAndSwapInt(this, OFFSET, current, current + 1));
    }
}

// volatile 變量訪問(wèn) vs 普通變量訪問(wèn)
volatile int vCounter = 0;
int counter = 0;

// volatile 訪問(wèn)有約10-20%的性能損耗
// 但相比 synchronized 的數(shù)千倍性能損耗可忽略不計(jì)