深入浅出：Java面试中的CAS技巧-洪萨配资

文章目录

深入浅出：Java面试中的CAS技巧 ?
- 什么是 CAS？
- CAS 的基本原理
- 乐观锁 vs 悲观锁
- CAS 的应用场景
- - 1. 并发控制中的原子操作
  - - 示例：用 CAS 实现一个自增计数器
  - 2. 实现无锁数据结构
  - - 示例：用 CAS 实现一个简单的无锁栈
- CAS 的优缺点
- - 优点
  - 缺点
  - - 解决方案：使用带有版本号的 CAS
- 总结
- CAS 是一种非常强大的并发工具，广泛应用于高并发场景。通过 `AtomicInteger`、`AtomicReference` 等类，我们可以方便地实现原子操作和无锁数据结构。但需要注意的是，CAS 并不是万能的，在解决 ABA 问题时需要借助版本号机制。希望这篇文章能帮助你更好地理解和使用 CAS！
- - 📚 领取 | 1000+ 套高质量面试题大合集（无套路，闫工带你飞一把）！

深入浅出：Java面试中的CAS技巧 ?

大家好！我是都叫闫工，今天要聊的是一个 Java 面试中经常被问到的“硬核”知识点——CAS（Compare-And-Swap）。这个知识点看似简单，但其实里面有很多细节和应用场景，掌握好了它不仅能在面试中拿到高分，还能在工作中解决很多实际问题。

什么是 CAS？

CAS 是一种乐观锁机制，全称为“比较并交换”（Compare And Swap）。它的核心思想是：我先检查一下变量的值是否符合预期，如果符合，我就把它修改成新的值；如果不符，那就说明有其他线程已经修改过了，这时候就需要重新尝试或者采取其他措施。

简单来说，CAS 有点像“我要买一杯咖啡，但前提是店里的拿铁还有货。如果有，我买下它；如果没有，我就只能喝奶茶了。”

在 Java 中，CAS 的实现主要依赖于java.util.concurrent.atomic包中的类，比如AtomicInteger、AtomicLong等。

CAS 的基本原理

CAS 的核心是通过硬件指令（通常是 CPU 提供的原子操作）来实现无锁编程。Java 通过调用底层的Unsafe类的方法来完成这个过程。具体来说，CAS 包含三个参数：

内存位置：即要操作的变量。
预期值：我预设的旧值。
新值：如果内存位置的值等于预期值，那么我就把它改成新值。

用代码表示就是：

publicbooleancompareAndSet(intexpectedValue,intnewValue){// 实际实现会调用 Unsafe 的 compareAndSwapInt 方法returnunsafe.compareAndSwapInt(this,valueOffset,expectedValue,newValue);}

这个方法的返回值是一个布尔值，表示操作是否成功。

乐观锁 vs 悲观锁

在聊 CAS 之前，我们先简单了解一下乐观锁和悲观锁的区别。这有助于我们更好地理解 CAS 的应用场景。

乐观锁：假设并发情况下不会发生冲突，所以在执行操作时不需要加锁。如果发现冲突，再进行处理。
悲观锁：假设并发情况下肯定会发生冲突，所以在执行任何操作之前都会先加锁。

CAS 属于乐观锁的一种实现方式，因为它不依赖传统的加锁机制，而是通过不断尝试来完成操作。

CAS 的应用场景

1. 并发控制中的原子操作

CAS 最常见的应用场景是实现原子操作。例如，在高并发场景下，我们需要确保某个变量的修改是原子性的。

示例：用 CAS 实现一个自增计数器

importjava.util.concurrent.atomic.AtomicInteger;publicclassCounter{privateAtomicIntegercount=newAtomicInteger(0);publicvoidincrement(){intcurrent;do{current=count.get();}while(!count.compareAndSet(current,current+1));}publicstaticvoidmain(String[]args){Countercounter=newCounter();// 启动多个线程同时调用 increment 方法for(inti=0;i<5;i++){Threadthread=newThread(counter::increment);thread.start();}}}

在这个例子中，AtomicInteger的compareAndSet方法会不断尝试将当前值加 1，直到操作成功。这样就能保证计数器的自增是原子性的。

2. 实现无锁数据结构

CAS 还可以用来实现一些无锁的数据结构，比如无锁队列、无锁堆等。这种数据结构在高并发场景下性能非常优秀。

示例：用 CAS 实现一个简单的无锁栈

importjava.util.concurrent.atomic.AtomicReference;publicclassLockFreeStack<T>{privateAtomicReference<Node<T>>top=newAtomicReference<>();privatestaticclassNode<T>{Tvalue;Node<T>next;publicNode(Tvalue){this.value=value;}}publicvoidpush(Tvalue){Node<T>newNode=newNode<>(value);Node<T>oldTop;do{oldTop=top.get();newNode.next=oldTop;// 将新节点指向旧栈顶}while(!top.compareAndSet(oldTop,newNode));}publicTpop(){Node<T>oldTop;do{oldTop=top.get();if(oldTop==null){// 栈为空returnnull;}}while(!top.compareAndSet(oldTop,oldTop.next));returnoldTop.value;}publicstaticvoidmain(String[]args){LockFreeStack<String>stack=newLockFreeStack<>();stack.push("A");stack.push("B");System.out.println(stack.pop());// 输出 BSystem.out.println(stack.pop());// 输出 A}}

这个例子通过AtomicReference和 CAS 实现了一个简单的无锁栈。每次入栈和出栈操作都通过compareAndSet来保证原子性。

CAS 的优缺点

优点

高并发性能：CAS 是基于乐观锁的实现，避免了传统加锁机制带来的阻塞问题，因此在低冲突场景下性能非常优秀。
无锁设计：不需要依赖操作系统提供的互斥锁，减少了系统调用的开销。
简单易懂：实现逻辑相对简单，容易理解和维护。

缺点

ABA 问题：CAS 只检查值是否等于预期值，但如果某个变量被改成了其他值，再改回来，就会导致误判。例如：
- 初始值是 A。
- 线程 1 读取到 A，并准备修改为 B。
- 线程 2 把 A 改成了 B，然后再改回了 A。
- 线程 1 检查到当前值还是 A，就继续执行，导致错误。

解决方案：使用带有版本号的 CAS

通过在变量中加入版本号，每次修改都会增加版本号，这样就能避免ABA问题。

importjava.util.concurrent.atomic.AtomicStampedReference;publicclassABADemo{privateAtomicStampedReference<Integer>stampedRef=newAtomicStampedReference<>(0,0);publicvoidfixABA(){intvalue=stampedRef.getReference();intstamp=stampedRef.getStamp();// 线程 1 尝试修改booleansuccess=stampedRef.compareAndSet(value,1,stamp,stamp+1);if(success){System.out.println("线程 1 修改成功");}else{System.out.println("线程 1 修改失败，重试");}// 线程 2 尝试修改value=stampedRef.getReference();stamp=stampedRef.getStamp();success=stampedRef.compareAndSet(value,0,stamp,stamp+1);if(success){System.out.println("线程 2 修改成功");}else{System.out.println("线程 2 修改失败，重试");}}publicstaticvoidmain(String[]args){ABADemodemo=newABADemo();demo.fixABA();}