前言

听说经常面试被问到~今天同事说了这个问题，就查了一下这问题，觉得挺有意思的，就整理出来跟大家分享下。主要思考下面几个问题：

1、什么是CAS?

2、什么是CAS的ABA问题？

3、怎么解决这个问题？

一、什么是CAS？

CAS是compare and swap的缩写，也有说是compare and set的缩写，即我们所说的比较交换。cas是一种基于锁的操作，而且是乐观锁。在java中锁分为乐观锁和悲观锁。悲观锁是将资源锁住，等一个之前获得锁的线程释放锁之后，下一个线程才可以访问。而乐观锁采取了一种宽泛的态度，通过某种方式不加锁来处理资源，比如通过给记录加version来获取数据，性能较悲观锁有很大的提高。

CAS 操作包含三个操作数 —— 内存位置(V)、预期原值(A)和新值(B)。如果内存地址里面的值和A的值是一样的，那么就将内存里面的值更新成B。CAS是通过无限循环来获取数据的，若果在第一轮循环中，a线程获取地址里面的值被b线程修改了，那么a线程需要自旋，到下次循环才有可能机会执行。

二、什么是CAS的ABA问题？

并发的情况下：

1、线程1获取参数A

2、线程2获取参数A，并获取cpu的执行权，修改参数A为参数B。

3、线程2执行完毕，线程3获取cpu的执行权，修改参数B为参数A，并放入内存中。

4、线程1开始执行，判断原A和内存中的A相等，线程1把执行的结果存入该内存地址。

虽然原A和内存中的A相等，但是内存中的A已经不是以前的A了。。这样就会有问题

CAS造成CPU利用率增加。CAS里面是一个循环判断的过程，如果线程一直没有获取到状态，cpu资源会一直被占用。

三、怎么解决这个问题？

解决办法就是增加一个版本号，每次操作，版本号+1，版本号不同，不允许修改。在java5中，已经提供了AtomicStampedReference来解决问题。

看AutoInteger的实现源码

其实AutoInteger就是使用了CAS来实现加1，我们知道如果有一个共享变量count=1,开5个线程，每个线程加20次，结果一般来说都会小于100.

@Testpublic void test20() throws InterruptedException { for (int i = 1; i <= 5; i++) { MyThrend thrend = new MyThrend("thead" + i); Thread thread = new Thread(thrend); thread.start(); } Thread.sleep(2000); System.out.println(MyCount1.count);}static class MyThrend implements Runnable { private String name; MyThrend(String threadName) { this.name = threadName; } @Override public void run() { for (int i=0;i<20;i++) MyCount1.count++; }}private static class MyCount1 { static int count = 0;}

运行结果小于100

现在修改一个代码，将int变成AtomicInteger

@Testpublic void test20() throws InterruptedException { for (int i = 1; i <= 5; i++) { MyThrend thrend = new MyThrend("thead" + i); Thread thread = new Thread(thrend); thread.start(); } Thread.sleep(2000); System.out.println(MyCount.count.get());}static class MyThrend implements Runnable { private String name; MyThrend(String threadName) { this.name = threadName; } @Override public void run() { for (int i=0;i<20;i++) MyCount.count.getAndIncrement(); //加1方法 }}private static class MyCount { static AtomicInteger count = new AtomicInteger(0);}

每次结果都是100，怎么做到的呢？这里是没有直接加锁的，看源码。

public final int getAndIncrement() { return unsafe.getAndAddInt(this, valueOffset, 1); //第一个参数当前对象地址，第二个参数数据偏移量，第三个参数每次指定默认加1}public final int getAndAddInt(Object var1, long var2, int var4) { //这个方法使用的就是CAS,核心在于循环比较内存里面的值和当前值是否相等，如果相等就用新值覆盖 int var5;  do { var5 = this.getIntVolatile(var1, var2); //如果a，b线程同时执行这个方法，a线程拿到值1后cpu执行时间到了挂起，b开始执行，也拿到1，但是没有挂起，接着将值变成了2 } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4)); //这个时候a线程恢复执行，去比较的时候发现手上的1 和内存里面的值2不等，这个时候他要进行下一个循环，看出来了占用cpu吧 return var5;}

java.util.current.atomic包下面，里面有很多类采用了CAS机制来实现加锁，可以自己研究下。

四、扩展和思考

一个商品库存为10个， 并发的情况下，A和B两个用户同时购买，他们查出来的数据都是10个，A用户购买5个，B用户购买3个。如果根据主键去更新数据，A用户把数据修改为5个，而B用户把数据修改7个，这样数据就不正确了。

思考一：

我们可以根据主键和商品数量是否等于查出来原始数量去跟新

update stock set num=$num_new where sid=$sid升级为：update stock set num=$num_new where sid=$sid and num=$num_old

但是，并发情况下，在B修改之前，C又把库存改为了10，这个时间就是典型的ABA问题了，虽然都是10，但是含义已经不一样，直接修改可能会影响别的业务。

思考二：

添加一个版本号，每次修改数据的同时修改版本号。例如

旧版本“值”比对CASupdate stock set num=$num_new where sid=$sid and num=$num_old升级为“版本号”比对CASupdate stock set num=$num_new, version=$version_new where sid=$sid and version=$version_old

我觉得上面得这个例子更能让大家理解，就添加进来了。