带你了解Java无锁并发CAS

带你了解Java无锁并发CAS

在多核处理器时代，并发编程已成为提升系统性能的核心手段。传统的同步机制（如synchronized和ReentrantLock）通过互斥锁实现线程安全，但其存在以下关键问题：

1. 性能损耗：线程阻塞/唤醒涉及内核态切换，单次操作耗时约1微秒（百万条指令时间）
2. 优先级反转：高优先级线程可能被低优先级线程阻塞
3. 死锁风险：不正确的锁顺序可能导致系统冻结

今天带你了解另一种保证线程安全的无锁方式：CAS

取钱案例

这里模拟了一个取钱业务的接口，主要有两个方法，一个是获取余额，另一个是取款并扣减余额的业务

除此之外还编写了一个测试方法，模拟1000个线程同时做取款操作，来观察他的并发安全问题

public interface Account {
   
    // 获取余额
    Integer getBalance();
    // 取款
    void withdraw(Integer amount);
    /** * 方法内会启动 1000 个线程，每个线程做 -10 元 的操作 * 如果初始余额为 10000 那么正确的结果应当是 0 */
    static void demo(Account account) {
   
        List<Thread> ts = new ArrayList<>();
        long start = System.nanoTime();
        for (int i = 0; i < 1000; i++) {
   
            ts.add(new Thread(() -> {
   
                account.withdraw(10);
            }));
        }
        ts.forEach(Thread::start);
        ts.forEach(t -> {
   
            try {
   
                t.join();
            } catch (InterruptedException e) {
   
                e.printStackTrace();
            }
        });
        // 记录业务耗时
        long end = System.nanoTime();
        System.out.println(account.getBalance()
                + " cost: " + (end-start)/1000_000 + " ms");
    }
}

接下来我们用多种方式来实现这个业务接口，并且分析其并发问题

不安全实现

首先可以不做任何并发安全处理，直接扣减余额：

public class AccountUnSafe implements Account{
   
    // 余额
    private Integer balance;

    public AccountUnSafe(Integer balance) {
   
        this.balance = balance;
    }

    @Override
    public Integer getBalance() {
   
        return balance;
    }

    @Override
    public void withdraw(Integer amount) {
   
        // 直接扣减
        balance -= amount;
    }
}

这种方式在并发场景下显然是不安全的，多个线程同时对共享变量balance进行操作，会导致错误的结果，我们可以编写一个测试类来查看运行结果：

public class TestAccount {
   
    public static void main(String[] args) {
   
        Account account = new AccountUnSafe(10000); // 初始化余额为10000元
        // 开始测试
        Account.demo(account);
    }
}

1000个线程同时做取款10元的操作，那么正常情况下来说，最后的余额应该是0，但是运行过后我们可以看到控制台打印了运行结果：

150 cost: 49 ms

余额是150或是其他数字，因此我们需要做一些并发安全方面的保护

常规加锁实现

对于多线程下对共享变量的读写操作，我们通常会通过加锁来处理：

public class AccountByLock implements Account{
   
    private Integer balance;

    public AccountByLock(Integer balance) {
   
        this.balance = balance;
    }

    @Override
    public Integer getBalance() {
   
        synchronized (this) {
   
            return balance;
        }
    }

    @Override
    public void withdraw(Integer amount) {
   
        synchronized (this) {
   
            balance -= amount;
        }
    }
}

这里使用的synchronized进行安全保证，每次只有一个线程可以操作共享变量，从而保证并发的安全性：

public class TestAccount {
   
    public static void main(String[] args) {
   
        Account accountByLock = new AccountByLock(10000);

        Account.demo(accountByLock);
    }
}

运行后的结果不会再出现问题：

0 cost: 50 ms

但是这种方式会导致其他线程在等待释放锁的过程中，线程状态由运行状态转换为阻塞状态，会大大降低业务的运行效率

无锁并发

如果你想使用无锁并发、无阻塞并发，可以通过CAS和 volatile来实现：

这里的余额类型不再使用整数类型，而是使用了juc包下的原子整数类型，底层的实现上，是将数字存放在了一个由volatile来修饰的整数变量中，保证数据的可见性，在更改余额的时候使用了CAS(compareAndSet)操作，该操作虽然有比较和赋值两个子操作，但java能够保证他们的原子性，从而防止指令交错带来的并发安全问题

public class AccountByCAS implements Account{
   
    // 运用了原子整数类型
    private AtomicInteger balance;

    public AccountByCAS(Integer balance) {
   
        this.balance = new AtomicInteger(balance);
    }

    @Override
    public Integer getBalance() {
   
        return balance.get();
    }

    @Override
    public void withdraw(Integer amount) {
   
        while (true){
   
            // 获取余额最新值
            int prev = balance.get();
            // 计算出剩余余额
            int next = prev - amount;
            // 用CAS操作比较并赋值
            if (balance.compareAndSet(prev, next)){
   // 返回true标识成功
                break;
            }
        }
    }
}

CAS 的底层是 lock cmpxchg 指令（X86 架构），在单核 CPU 和多核 CPU 下都能够保证【比较-交换】的原子性

原文链接：带你了解Java无锁并发CAS