带你了解Java无锁并发CAS

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

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

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

取钱案例

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

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

java">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");}
}

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

不安全实现

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

java">public class AccountUnSafe implements Account{// 余额private Integer balance;public AccountUnSafe(Integer balance) {this.balance = balance;}@Overridepublic Integer getBalance() {return balance;}@Overridepublic void withdraw(Integer amount) {// 直接扣减balance -= amount;}
}

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

java">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或是其他数字，因此我们需要做一些并发安全方面的保护

常规加锁实现

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

java">public class AccountByLock implements Account{private Integer balance;public AccountByLock(Integer balance) {this.balance = balance;}@Overridepublic Integer getBalance() {synchronized (this) {return balance;}}@Overridepublic void withdraw(Integer amount) {synchronized (this) {balance -= amount;}}
}

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

java">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能够保证他们的原子性，从而防止指令交错带来的并发安全问题

java">public class AccountByCAS implements Account{// 运用了原子整数类型private AtomicInteger balance;public AccountByCAS(Integer balance) {this.balance = new AtomicInteger(balance);}@Overridepublic Integer getBalance() {return balance.get();}@Overridepublic void withdraw(Integer amount) {while (true){// 获取余额最新值int prev = balance.get();// 计算出剩余余额int next = prev - amount;// 用CAS操作比较并赋值if (balance.compareAndSet(prev, next)){// 返回true标识成功break;}}}
}