Java中 synchronized 和 volatile的核心区别解析

public class Counter {
    private int count = 0;
    // 锁定的是当前对象实例 (this)
    public synchronized void increment() {
        count++; // 这个操作是原子的
    }
    public synchronized int getCount() {
        return count;
    }
}

public class GlobalCounter {
    private static int globalCount = 0;
    // 锁定的是当前类的 Class 对象 (GlobalCounter.class)
    public static synchronized void incrementGlobal() {
        globalCount++;
    }
    public static synchronized int getGlobalCount() {
        return globalCount;
    }
}

public class FineGrainedCounter {
    private int countA = 0;
    private int countB = 0;
    private final Object lockA = new Object();
    private final Object lockB = new Object();
    // 只锁定操作 countA 的部分，提高并发度
    public void incrementA() {
        synchronized (lockA) { // 锁定指定的对象 lockA
            countA++;
        }
    }
    // 只锁定操作 countB 的部分
    public void incrementB() {
        synchronized (lockB) { // 锁定指定的对象 lockB
            countB++;
        }
    }
    // 锁定当前对象实例
    public void doSomething() {
        synchronized (this) {
            // ... 临界区代码
        }
    }
}

public class VolatileExample {
    // 修饰一个布尔标志位，用于线程间通信
    private volatile boolean shutdownRequested = false;
    // 修饰一个对象引用
    private volatile Config config;
    // 线程A：设置标志位
    public void shutdown() {
        shutdownRequested = true; // 写操作，会立即刷新到主内存
    }
    // 线程B：检查标志位
    public void doWork() {
        while (!shutdownRequested) { // 读操作，每次都从主内存读取最新值
            // ... 执行任务
        }
        // 收到关闭请求，优雅退出
    }
    // 注意：以下操作不是原子的！
    private volatile int counter = 0;
    public void unsafeIncrement() {
        counter++; // 读-改-写，非原子操作，多线程下结果可能错误
    }
}

public class Singleton {
    // volatile 防止 instance = new 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;
    }
}

class TaskRunner {
    private volatile boolean stopped = false; // 线程安全的状态标志
    public void run() {
        while (!stopped) { /* 执行任务 */ }
    }
    public void stop() { stopped = true; } // 修改立即可见
}

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

class BankAccount {
    private double balance;
    public synchronized void deposit(double amount) { // 整个方法同步
        balance += amount;
    }
    public void withdraw(double amount) {
        synchronized (this) { // 代码块同步
            balance -= amount;
        }
    }
}

class ProducerConsumer {
    private final Object lock = new Object();
    private boolean isProduced = false;
    public void produce() {
        synchronized (lock) {
            while (isProduced) { lock.wait(); } // 等待消费
            // 生产数据...
            isProduced = true;
            lock.notifyAll(); // 通知消费者
        }
    }
    public void consume() {
        synchronized (lock) {
            while (!isProduced) { lock.wait(); } // 等待生产
            // 消费数据...
            isProduced = false;
            lock.notifyAll(); // 通知生产者
        }
    }
}