Java-CAS学习总结

在前面总结的文章中 详解Java中volatile关键字作用，说到了累加器的线程不安全，不安全的原因就是被累加的成员变量 可见性 和自增时的操作 原子性 上。

可见性问题可以用 volatile 来解决，而原子性问题我们可以采用互斥锁的方案，除了互斥的方案，在文章末尾也使用了 AtomicInteger 来保证了自增操作的原子性。用它来改善累加器方法，就可以输出正确的结果。

采用 AtomicInteger 是一种无锁方案，它相对互斥锁方案，最大的好处就是性能。互斥锁方案为了保证互斥性，需要执行加锁、解锁操作，而加锁、解锁操作本身就消耗性能；同时拿不到锁的线程还会进入阻塞状态，进而触发线程切换，线程切换对性能的消耗也很大。
相比之下，无锁方案则完全没有加锁、解锁的性能消耗，同时还能保证互斥性，既解决了问题，又没有带来新的问题，可谓绝佳方案

可是它是如何做到的呢？

无锁方案的实现原理

AtomicInteger 我们将它称为“原子类”，

原子类性能高的原理很简单，硬件支持而已！CPU为了解决并发问题，提供了CAS指令（CAS，全称是Compare And Swap，即“比较并交换”）。
CAS指令包含3个参数：共享变量的内存地址A、用于比较的值B和共享变量的新值C；并且只有当内存中地址A处的值等于B时，才能将内存中地址A处的值更新为新值C。
作为一条CPU指令，CAS指令本身是能够保证原子性的。

感觉理解起来好难！！！好抽象！！！

不要慌不要急,下面有请-画图解答

图解 count+=1

假设我们 count 的值，就放在内存地址 0x101 这个地方。
当内存地址 0x101 中的值等于5，A 的值就代表内存地址 0x101 也就等于 5，用于和 A 做比较的期望值 B 也等5，而新值C就等于 A+1

我们在执行 CAS 操作的时候，先比较 A 和 B的值，是否相等，如果相等那么就把新值 C 赋值给 A，用代码表示就是：

if(A==B){
	A=C;
}

在执行完这一步操作后，内存中的数据就变成了下面这个样子：

看完图片的解释后，再用代码来模拟CAS的原理，下面的模拟程序中有两个参数，一个是期望值 B，另一个是需要写入的新值 C，只有当目前count的值(也就是A)和期望值 B 相等时，才会将 count 更新为 C。：

public class SimulatedCAS {
    
    int count;
    
    synchronized int CAS(int B, int C){
        // 读目前count的值，赋值给变量 A
        int A = count;
        // 比较目前 A 值是否==期望值 B
        if(A == B){
            // 如果是，则更新count的值
            count = C;
        }
        // 返回写入前的旧值
        return A;
    }
}

对于前面提到的累加器的例子，count += 1 有一个核心问题是：在将 count+1 计算后的值写入内存的时候，很可能此时内存中 count 已经被其他线程更新过了，这样就会导致错误地覆盖其他线程写入的值。

图解 count+=1 并发问题

当我要把 count+=1 的值写入内存地址 0x101 这个地方时，有其他线程比我先更新了内存中 count 值，那进行CAS时数据也就是这样：

那么此时一对比 A 和 B 的值，发现对不上了，那就提交失败了，就这样完了吗？然鹅并没有。

使用CAS来解决并发问题，一般都会伴随着自旋，而所谓自旋，其实就是循环尝试，重新获取内存中的值，直到成功！！！

我们使用程序来模拟 CAS+自旋 就是下面这样的：

public class SimulatedCAS {
    volatile int count;
    // 实现count+=1
    public void addOne(){
        int C = 0;
        do {
            C = count+1;
        }while(count != CAS(count, C));
    }
    // 模拟实现CAS，仅用来帮助理解
    synchronized int CAS( int B, int C){
        // 读目前count的值
        int A = count;
        // 比较目前count值是否==期望值 B
        if(A == B){
            // 如果是，则更新count的值
            count= C;
        }
        // 返回写入前的值
        return A;
    }
}

通过上面的示例代码，可以发现，CAS这种无锁方案，完全没有加锁、解锁操作，即便两个线程完全同时执行addOne()方法，也不会有线程被阻塞，所以相对于互斥锁方案来说，性能好了很多。

但是在CAS方案中，有一个问题可能会常被忽略，那就是ABA的问题。什么是ABA问题呢？

ABA问题

假设 count 原本是A，线程T1在执行CAS之前，有可能 count 被线程T2更新成了B，之后又被T3更新回了A，这样线程T1反应过来执行的时候虽然看到的一直是A，但是其实已经被其他线程更新过了，这就是ABA问题。

关于数值的原子递增可能大多数情况下我们并不关心ABA问题，但也不能所有情况下都不关心，例如原子化的更新对象很可能就需要关心ABA问题，因为两个A虽然相等，但是第二个A的属性可能已经发生变化了。

解决ABA问题的思路其实很简单，增加一个版本号维度就可以了，每次执行CAS操作，附加再更新一个版本号，只要保证版本号是递增的，那么即便A变成B之后再变回A，版本号也不会变回来（版本号递增的）。AtomicStampedReference实现的CAS方法就增加了版本号参数，方法签名如下：

boolean compareAndSet(
  V expectedReference,
  V newReference,
  int expectedStamp,
  int newStamp) 

AtomicMarkableReference的实现机制则更简单，将版本号简化成了一个Boolean值，方法签名如下：

boolean compareAndSet(
  V expectedReference,
  V newReference,
  boolean expectedMark,
  boolean newMark)

Java提供的原子类能够解决一些简单的原子性问题，但你可能会发现，上面我们所有原子类的方法都是针对一个共享变量的，如果你需要解决多个变量的原子性问题，建议还是使用互斥锁方案。原子类虽好，但使用要慎之又慎。

---

技 术 无 他， 唯 有 熟 尔。
知 其 然， 也 知 其 所 以 然。
踏 实 一 些， 不 要 着 急， 你 想 要 的 岁 月 都 会 给 你。

---