CAS在底层源码中是使用非常广的，像我之前的HashMap源码解析、volatile详解等文章都有提到CAS。本文将详细介绍CAS。
一、什么叫CAS？
CAS，是 compare and swap 的缩写，即比较并交换。它是一种基于乐观锁的操作。它有三个操作数，内存值V，预期值A，更新值B。当且仅当A和V相同时，才会把V修改成B，否则什么都不做。之前说到AtomicInteger用到了CAS，那么先从这个类说起。看如下代码：
1public static void main(String[] args){
2 AtomicInteger atomicInteger = new AtomicInteger(5);
3 System.out.println(atomicInteger.compareAndSet(5,50));
4 System.out.println(atomicInteger.compareAndSet(5,100));
5}
AtomicInteger有一个compareAndSet方法，有两个操作数，第一个是期望值，第二个是希望修改成的值。首先初始值是5，第一次调用compareAndSet方法的时候，将5拷贝回自己的工作空间，然后改成50，写回到主内存中的时候，它期望主内存中的值是5，而这时确实也是5，所以可以修改成功，主内存中的值也变成了50，输出true。第二次调用compareAndSet的时候，在自己的工作内存将值修改成100，写回去的时候，希望主内存中的值是5，但是此时是50，所以set失败，输出false。这就是比较并交换，也即CAS。
二、CAS的工作原理
简而言之，CAS工作原理就是UnSafe类和自旋锁。
1、UnSafe类：
UnSafe类在jdk的rt.jar下面的一个类，全包名是sun.misc.UnSafe。这个类大多数方法都是native方法。由于Java不能操作计算机系统，所以设计之初就留了一个UnSafe类。通过UnSafe类，Java就可以操作指定内存地址的数据。调用UnSafe类的CAS，JVM会帮我们实现出汇编指令，从而实现原子操作。现在就来分析一下AtomicInteger的getAndIncrement方法是怎么工作的。看下面的代码：
1 public final int getAndIncrement() {
2 return unsafe.getAndAddInt(this, valueOffset, 1);
3 }
这个方法调用的是unsafe类的getAndAddInt方法，有三个参数。第一个表示当前对象，也就是你new 的那个AtomicInteger对象；第二个表示内存地址；第三个表示自增步伐。然后再点进去看看这个getAndAddInt方法。
1public final int getAndAddInt(Object var1, long var2, int var4) {
2 int var5;
3 do {
4 var5 = this.getIntVolatile(var1, var2);
5 } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
6 return var5;
7 }
这里的val1就是当前对象，val2是内存地址，val4是1，也就是自增步伐。首先把当前对象主内存中的值赋给val5，然后进入while循环。判断当前对象此刻主内存中的值是否等于val5，如果是，就自增，否则继续循环，重新获取val5的值。这里的compareAndSwapInt方法就是一个native方法，这个方法汇编之后是CPU原语指令，原语指令是连续执行不会被打断的，所以可以保证原子性。
2、自旋锁：
所谓的自旋，其实就是上面getAndAddInt方法中的do while循环操作。当预期值和主内存中的值不等时，就重新获取主内存中的值，这就是自旋。
三、CAS的缺点
缺点有三个。
1、循环时间长，开销大。
synchronized是加锁，同一时间只能一个线程访问，并发性不好。而CAS并发性提高了，但是由于CAS存在自旋操作，即do while循环，如果CAS失败，会一直进行尝试。如果CAS长时间不成功，会给CPU带来很大的开销。
2、只能保证一个共享变量的原子性。
上面也看到了，getAndAddInt方法的val1是代表当前对象，所以它也就是能保证这一个共享变量的原子性。如果要保证多个，那只能加锁了。
3、引来的ABA问题。
假设现在主内存中的值是A，现有t1和t2两个线程去对其进行操作。t1和t2先将A拷贝回自己的工作内存。这个时候t2线程将A改成B，刷回到主内存。此刻主内存和t2的工作内存中的值都是B。接下来还是t2线程抢到执行权，t2又把B改回A，并刷回到主内存。这时t1终于抢到执行权了，自己工作内存中的值的A，主内存也是A，因此它认为没人修改过，就在工作内存中把A改成了X，然后刷回主内存。也就是说，在t1线程执行前，t2将主内存中的值由A改成B再改回A。这便是ABA问题。看下面的代码演示(代码涉及到原子引用，请参考下面的原子引用的介绍)：
1class ABADemo {
2 static AtomicReference<String> atomicReference = new AtomicReference<>("A");
3 public static void main(String[] args){
4 new Thread(() -> {
5 atomicReference.compareAndSet("A","B");
6 atomicReference.compareAndSet("B","A");
7 },"t2").start();
8 new Thread(() -> {
9 try {
10 TimeUnit.SECONDS.sleep(1);
11 } catch (InterruptedException e) {
12 e.printStackTrace();
13 }
14 System.out.println(atomicReference.compareAndSet("A","C")
15 + "\t" + atomicReference.get());
16 },"t1").start();
17 }
18}
这段代码执行结果是"true C"，这就证明了ABA问题的存在。如果一个业务只管开头和结果，不管这个A中间是否变过，那么出现了ABA问题也没事。如果需要A还是最开始的那个A，中间不许别人动手脚，那么就要规避ABA问题。要解决ABA问题，先看下面的原子引用的介绍。
JUC包下给我们提供了原子包装类，像AtomicInteger。如果我不仅仅想要原子包装类，我自己定义的User类也想具有原子操作，怎么办呢？JUC为我们提供了AtomicReference，即原子引用。看下面的代码：
1@AllArgsConstructor
2class User {
3 int age;
4 String name;
5
6 public static void main(String[] args){
7 User user = new User(20,"张三");
8 AtomicReference<User> atomicReference = new AtomicReference<>();
9 atomicReference.set(user);
10 }
11}
像这样，就把User类变成了原子User类了。
我们可以这个共享变量带上一个版本号。比如现在主内存中的是A，版本号是1，然后t1和t2线程拷贝一份到自己工作内存。t2将A改为B，刷回主内存。此时主内存中的是B，版本号为2。然后再t2再改回A，此时主内存中的是A，版本号为3。这个时候t1线程终于来了，自己工作内存是A，版本号是1，主内存中是A，但是版本号为3，它就知道已经有人动过手脚了。那么这个版本号从何而来，这就要说说AtomicStampedReference这个类了。
1class ABADemo {
2 static AtomicStampedReference<String> atomicReference = new AtomicStampedReference<>("A", 1);
3 public static void main(String[] args) {
4 new Thread(() -> {
5 try {
6 TimeUnit.SECONDS.sleep(1);// 睡一秒，让t1线程拿到最初的版本号
7 } catch (InterruptedException e) {
8 e.printStackTrace();
9 }
10 atomicReference.compareAndSet("A", "B", atomicReference.getStamp(), atomicReference.getStamp() + 1);
11 atomicReference.compareAndSet("B", "A", atomicReference.getStamp(), atomicReference.getStamp() + 1);
12 }, "t2").start();
13 new Thread(() -> {
14 int stamp = atomicReference.getStamp();//拿到最开始的版本号
15 try {
16 TimeUnit.SECONDS.sleep(3);// 睡3秒，让t2线程的ABA操作执行完
17 } catch (InterruptedException e) {
18 e.printStackTrace();
19 }
20 System.out.println(atomicReference.compareAndSet("A", "C", stamp, stamp + 1));
21 }, "t1").start();
22 }
23}
初始版本号为1，t2线程每执行一次版本号加。等t1线程执行的时候，发现当前版本号不是自己一开始拿到的1了，所以set失败，输出false。这就解决了ABA问题。
总结：
1.什么是CAS? ------ 比较并交换，主内存值和工作内存值相同，就set为更新值。
2.CAS原理是什么？------ UnSafe类和自旋锁。理解那个do while循环。
3.CAS缺点是什么？------ 循环时间长会消耗大量CPU资源；只能保证一个共享变量的原子性操作；造成ABA问题。
4.什么是ABA问题？------ t2线程先将A改成B，再改回A，此时t1线程以为没人修改过。
5.如何解决ABA问题？------ 使用带时间戳的原子引用。
