从互斥锁到CAS原子操作：高并发架构中的同步机制演进与创新设计

import java.util.concurrent.atomic.AtomicInteger;

public class CASExample {
    // 使用AtomicInteger实现基于CAS的计数器
    private AtomicInteger counter = new AtomicInteger(0);
    
    /**
     * 线程安全的自增操作
     * 使用CAS机制避免传统锁的开销
     */
    public void increment() {
        int oldValue, newValue;
        do {
            // 获取当前值作为预期原值
            oldValue = counter.get();
            // 计算新值
            newValue = oldValue + 1;
            // 尝试CAS更新：如果当前值仍等于oldValue，则更新为newValue
        } while (!counter.compareAndSet(oldValue, newValue));
        // 循环直到CAS成功（没有其他线程同时修改）
    }
    
    /**
     * 获取当前计数值
     */
    public int getValue() {
        return counter.get();
    }
    
    /**
     * 模拟多线程环境下的计数器使用
     */
    public static void main(String[] args) throws InterruptedException {
        final CASExample example = new CASExample();
        final int threadCount = 10;
        final int incrementsPerThread = 1000;
        
        Thread[] threads = new Thread[threadCount];
        
        // 创建并启动多个线程同时增加计数器
        for (int i = 0; i < threadCount; i++) {
            threads[i] = new Thread(() -> {
                for (int j = 0; j < incrementsPerThread; j++) {
                    example.increment();
                }
            });
            threads[i].start();
        }
        
        // 等待所有线程完成
        for (Thread thread : threads) {
            thread.join();
        }
        
        // 验证结果：应为threadCount * incrementsPerThread
        System.out.println("最终计数值: " + example.getValue());
        System.out.println("期望值: " + (threadCount * incrementsPerThread));
        System.out.println("结果正确: " + (example.getValue() == threadCount * incrementsPerThread));
    }
}

import java.util.concurrent.atomic.AtomicStampedReference;

public class ABASolutionExample {
    // 使用AtomicStampedReference包装共享数据
    private AtomicStampedReference<String> sharedData = 
            new AtomicStampedReference<>("初始值", 0);
    
    /**
     * 线程安全的更新操作，解决ABA问题
     * @param expectedValue 期望的原值
     * @param newValue 新值
     * @return 更新是否成功
     */
    public boolean safeUpdate(String expectedValue, String newValue) {
        int[] stampHolder = new int[1];
        String currentValue;
        
        // 重试直到成功或达到最大尝试次数
        for (int i = 0; i < 10; i++) {
            // 同时获取当前值和版本戳
            currentValue = sharedData.get(stampHolder);
            int currentStamp = stampHolder[0];
            
            // 检查当前值是否符合预期
            if (!currentValue.equals(expectedValue)) {
                System.out.println("值已被其他线程修改，当前值: " + currentValue);
                return false;
            }
            
            // 尝试CAS更新：同时检查值和版本戳
            if (sharedData.compareAndSet(
                currentValue, 
                newValue, 
                currentStamp, 
                currentStamp + 1)) {
                System.out.println("更新成功: " + currentValue + " -> " + newValue + 
                                 ", 新版本号: " + (currentStamp + 1));
                return true;
            }
            
            System.out.println("第" + (i + 1) + "次CAS失败，重试中...");
        }
        
        System.out.println("更新失败，已达到最大重试次数");
        return false;
    }
    
    /**
     * 模拟ABA问题场景
     */
    public static void main(String[] args) throws InterruptedException {
        ABASolutionExample example = new ABASolutionExample();
        
        Thread thread1 = new Thread(() -> {
            // 线程1尝试将值从"初始值"改为"线程1的值"
            boolean success = example.safeUpdate("初始值", "线程1的值");
            System.out.println("线程1更新结果: " + (success ? "成功" : "失败"));
        });
        
        Thread thread2 = new Thread(() -> {
            // 线程2模拟ABA场景：A->B->A
            boolean success1 = example.safeUpdate("初始值", "线程2的中间值");
            System.out.println("线程2第一次更新结果: " + (success1 ? "成功" : "失败"));
            
            if (success1) {
                boolean success2 = example.safeUpdate("线程2的中间值", "初始值");
                System.out.println("线程2第二次更新结果: " + (success2 ? "成功" : "失败"));
            }
        });
        
        // 启动线程2并等待完成，确保ABA场景发生
        thread2.start();
        thread2.join();
        
        // 启动线程1
        thread1.start();
        thread1.join();
    }
}

-- 创建支持乐观锁的表
CREATE TABLE inventory (
    id BIGINT PRIMARY KEY,
    product_id VARCHAR(50) NOT NULL,
    stock INT NOT NULL,
    version INT NOT NULL DEFAULT 0,  -- 版本号字段
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

-- 基于CAS的库存扣减操作
UPDATE inventory 
SET stock = stock - :quantity, 
    version = version + 1,
    updated_at = CURRENT_TIMESTAMP
WHERE product_id = :productId 
  AND stock >= :quantity 
  AND version = :expectedVersion;  -- CAS条件：版本号必须匹配

-- 检查更新是否成功
SELECT ROW_COUNT();  -- 返回受影响的行数，0表示CAS失败