Java volatile与锁机制对比案例分析

public class StrategyContext {
    // 1. volatile 保证可见性，但不提供锁
    private volatile Strategy strategy = new Strategy("Default");
    // 2. 无锁 Setter：任何时候都能调，不会被阻塞
    public void setStrategy(Strategy strategy) {
        this.strategy = strategy;
    }
    // 3. 无锁 Getter：任何时候都能调
    public Strategy getStrategy() {
        return strategy;
    }
    // 4. 加锁的方法：执行耗时 10 秒
    public synchronized void execute() {
        System.out.println(Thread.currentThread().getName() + " 拿到锁，开始执行 execute (10s)...");
        try {
            // 模拟长时间执行
            for (int i = 0; i < 5; i++) {
                // 危险：如果这里直接使用成员变量 strategy，可能会在执行中途发现它变了
                System.out.println("Execute 中途读取策略: " + strategy.getName());
                Thread.sleep(2000); 
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " 执行结束，释放锁。");
    }
}

public synchronized void execute() {
    // 【关键】进入方法时，将 volatile 变量赋值给局部变量
    // 局部变量存在于线程栈中，其他线程无法修改它
    Strategy localStrategy = this.strategy; 
    // 后续所有操作都使用 localStrategy
    // 即使成员变量 this.strategy 被其他线程改了，localStrategy 依然指向旧的对象
    localStrategy.algorithm(); 
}

public class StrategyContext {
    private volatile Strategy strategy = new Strategy("Default");
    //1. 加锁，完全互斥，阻塞
    public synchronized void setStrategy(Strategy strategy) {
        this.strategy = strategy;
    }
    //2. 加锁，完全互斥，阻塞
    public synchronized Strategy getStrategy() {
        return strategy;
    }
    // 加锁的方法：执行耗时 10 秒
    public synchronized void execute() {
        System.out.println(Thread.currentThread().getName() + " 拿到锁，开始执行 execute (10s)...");
        try {
            // 此时其他线程执行getter, setter方法会挂起等待，直到execute方法退出，锁释放，JVM唤醒等待线程
                Thread.sleep(10000); 
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " 执行结束，释放锁。");
    }
}

import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
public class RWLockStrategyContext {
    private Strategy strategy = new Strategy("Default");
    //注意读写有锁保护时，不需要volatile的可见性了
    private final ReadWriteLock rwLock = new ReentrantReadWriteLock();
    // 1. 写锁保护 Setter
    // 只有当没有任何人在读（包括 execute 和 get），也没有人在写时，才能拿到这把锁
    public void setStrategy(Strategy strategy) {
        rwLock.writeLock().lock();
        try {
            this.strategy = strategy;
        } finally {
            rwLock.writeLock().unlock(); 
        }
    }
    // 2. 读锁保护 Getter
    // 只要没有人持有写锁，可以多线程访问
    public Strategy getStrategy() {
        rwLock.readLock().lock(); 
        try {
            return strategy;
        } finally {
            rwLock.readLock().unlock();
        }
    }
    // 3. 读锁保护 Execute 
    public void execute() {
        rwLock.readLock().lock(); // 获取读锁
        try {
            System.out.println(Thread.currentThread().getName() + " 拿到读锁，开始 execute (10s)...");
            // 只要还在这个 try 块里，写锁（setStrategy）就进不来
            // 但是其他读锁（getStrategy）可以随便进！
            for (int i = 0; i < 5; i++) {
                System.out.println("Execute 运行中，当前策略: " + strategy.getName());
                try { Thread.sleep(2000); } catch (InterruptedException e) {}
            }
        } finally {
            System.out.println(Thread.currentThread().getName() + " 执行结束，释放读锁。");
            rwLock.readLock().unlock();
        }
    }
}