目录
- 1、概念
- 2、原理
- 3、缺点
- 4、ABA问题
- 5、解决ABA问题
1、概念
CAS(Compare And Swap)： 比较并替换，它是一条CPU原语，是一条原子指令(原子性)。
CAS通过比较真实值与预期值是否相同，如果是则进行修改，Atomic原子类底层就是使用了CAS，CAS属于乐观锁。
CAS 操作包含三个操作数 —— 内存位置（V）、预期原值（A）和新值(B)。如果内存位置的值与预期原值相匹配，那么会自动将该内存位置的值更新为新值，反之不做任何操作。
2、原理
CAS执行依赖于Unsafe类，Unsafe类的所有方法通过native修饰，所以Unsafe类直接操作系统底层的数据地址，而不通过JVM实现。
比如：A、B线程通过AtomicInteger同时对变量进行自增
public final int getAndAdd(int delta) {
return unsafe.getAndAddInt(this, valueOffset, delta);
}
// 使用了unsafe类
public final int getAndAddInt(Object var1, long var2, int var4) {
int var5;
do {
// 获取原值
var5 = this.getIntVolatile(var1, var2);
// 将原值与预期值进行对比，一致则进行相加var4
} while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
return var5;
}
伪代码流程解释：
A线程将变量num从1进行自增，当执行时没有其他线程修改过num值,所以一次成功，num自增后将值返回给主内存。
B线程也将num进行自增，但是num已经被A线程进行了修改，所有将再次执行do-while，重新获取num的值。
由于JMM模型的可见性，B线程重新获取值时会从主内存中获取到被A修改后的最新值。
通过最新值与期望值进行比较，满足条件就返回true。
CAS如何实现：
通过Unsafe类对系统底层的数据地址进行原子性操作，对比内存地址的值和预期值是否一样，如果一样进行修改。
3、缺点
- 1、循环时间长,增加了CPU的开销。
- 2、只能保证一个变量的原子操作。
- 3、会导致ABA问题。
4、ABA问题
如线程1从内存X中取出A，这时候另一个线程2也从内存X中取出A，并且线程2进行了一些操作将内存X中的值变成了B，然后线程2又将内存X中的数据变成A，这时候线程1进行CAS操作发现内存X中仍然是A，然后线程1操作成功。虽然线程1的CAS操作成功，但是整个过程就是有问题的，因为内存X中的值从A到B再到了A。
CAS执行时，将过去某时刻的值与当下时刻进行比较并替换，在这时间差中，值可能会发生多次修改，只是最终值的结果不变。
5、解决ABA问题
为了防止在值比较时，存在被修改过的可能，通过为值加上版本号的方式，在最后执行CAS时判断版本号，确保不会出现ABA问题。
通过原子引用(AtomicReference)加时间戳原子引用(AtomicStampedReference)解决ABA问题。
代码如下：
public class Test {
private static AtomicReference<Integer> atomicReference = new AtomicReference<>(100);
private static AtomicStampedReference<Integer> atomicStampedReference = new AtomicStampedReference<>(100, 1);
public static void main(String[] args) {
System.out.println("=========以下ABA问题产生：=========");
// 线程 t1 模拟ABA问题的产生
new Thread(() -> {
// 进行一次修改，将值修改为101
atomicReference.compareAndSet(100, 101);
// 进行第二次修改，将值修改回100
atomicReference.compareAndSet(101, 100);
}, "t1").start();
new Thread(() -> {
// 线程t2暂停1S，保证线程t1执行完成
try {TimeUnit.SECONDS.sleep(1);} catch (Exception e) {e.printStackTrace();}
System.out.println(atomicReference.compareAndSet(100, 102));
System.out.println("修改成功，修改后值为："+atomicReference.get());
}, "t2").start();
try {TimeUnit.SECONDS.sleep(2);} catch (Exception e) {e.printStackTrace();}
System.out.println("=========以下ABA问题解决方式：=========");
new Thread(() -> {
// 获取版本号
int stamp = atomicStampedReference.getStamp();
System.out.println("线程名称："+Thread.currentThread().getName()+"，第一次版本号："+stamp);
try {TimeUnit.SECONDS.sleep(1);} catch (Exception e) {e.printStackTrace();}
// 进行一次修改，将值修改为101
atomicStampedReference.compareAndSet(100,101,stamp,stamp+1);
stamp = atomicStampedReference.getStamp();
System.out.println("线程名称："+Thread.currentThread().getName()+"，第二次版本号："+stamp);
// 进行第二次修改，将值修改回100
atomicStampedReference.compareAndSet(101,100,stamp,stamp+1);
stamp = atomicStampedReference.getStamp();
System.out.println("线程名称："+Thread.currentThread().getName()+"，第三次版本号："+stamp);
}, "t3").start();
new Thread(() -> {
// 获取版本号
int stamp = atomicStampedReference.getStamp();
System.out.println("线程名称："+Thread.currentThread().getName()+"，第一次版本号："+stamp);
// 线程t4暂停1S，保证线程t3执行完成
try {TimeUnit.SECONDS.sleep(2);} catch (Exception e) {e.printStackTrace();}
boolean andSet = atomicStampedReference.compareAndSet(100, 101, stamp,stamp+1);
System.out.println("线程名称："+Thread.currentThread().getName()+"，修改结果："+andSet+"，第二次版本号:"+stamp+1+"实际版本号："+atomicStampedReference.getStamp());
System.out.println("当前最新值："+atomicStampedReference.getReference());
}, "t4").start();
}
}
分析：
在线程t1中，将值从100修改为了101又修改回了100，但是线程t2却成功更新了值，所以产生了ABA问题。
在线程t3中，将值从100修改为了101又修改回了100，并且更新的版本号为3；在线程t4中，将100修改为101时，由于线程t4更新时的版本号为2，但是实际的版本号为3，所以无法更新，解决了ABA问题。
运行结果：
