CAS-Compare And Swap

CAS基本概念

CAS(Compare And Swap)，比较交换，是一种无锁的原子算法。

CAS映射到操作系统上就是一条cmpxchg硬件汇编指令（保证原子性）。

CAS作用是当指定内存的值与预期值一致时，便让CPU将指定内存的值改为新值。CAS操作无需用户态和内核天切换，直接在用户态对内存进行读写操作（不会阻塞 and 不会发生线程上下文切换）

/**
 * V 待更新的内存值
 * E 预期值
 * N 新值
 * 当V = E 时，才会将V更新成N，如果V和E不等，则不做更新
 */
CAS(V, E, N)

CAS需要使用者额外给出一个期望值，也就是使用者认为这个变量现在应该是什么样子的，如果变量不是使用者想象的那样，说明它已经被别人修改过了，使用者只需要重新读取，设置新期望值，再次尝试修改就好了。

CAS如何保证原子性

原子性即一个或者多个操作在CPU执行的过程中不被中断的，要么都执行，要都不执行，不能执行到一半（不可被中断的一个或一系列操作）。

总线锁定

总线

总线（BUS）是计算机组件间的传输数据方式，分为3种：数据总线，控制总线，地址总线。即CPU与其他组件连接传输数据是靠总线完成的，比如CPU读写内存。

总线锁定

CPU在总线上输出LOCK#信号时，其他CPU的总线请求将被阻塞，该CPU就可以独占使用总线（操作共享内存需要经过总线，独占总线相当于独占共享内存）。

CPU在总线上输出LOCK#信号的行为就是使用总线锁。

缓存锁定

总线锁定虽然保证了原子性，但是在锁定期间，会导致大量阻塞（对于其他共享内存的访问都不能进行），增加系统的性能开销。

所以现代CPU为了提升性能，通过锁定范围缩小的思想设计出了缓存行锁定（缓存行是CPU高速缓存存储的最小单位）。

缓存锁定是指CPU对缓存行进行锁定。当缓存行中的共享变量回写到内存时，其他CPU会通过总线嗅探机制感知该共享变量是否发生变化，如果发生变化，让自己对应的共享变量缓存行失效，重新从内存读取最新的数据。

缓存锁定是基于缓存一致性机制来实现的，因为缓存一致性机制会阻止两个以上CPU同时修改同一个共享变量（现代CPU基本都支持和使用缓存锁定机制）。

CAS问题

CAS和锁都解决了原子性问题，和锁相比没有阻塞、线程上下文切换、死锁，所以CAS要比锁拥有更优越的性能，但是CAS同样存在缺点。

只能保证一个共享变量的原子操作

CAS只能针对一个共享变量使用，如果多个共享变量就只能使用锁了，当然如果有办法把多个变量整成一个变量，利用CAS也不错，例如

1. 读写锁中state的高低位；
2. 有两个共享变量i＝2，j=a，合并一下：ij=2a，然后用CAS来操作ij；

从Java1.5开始JDK提供了AtomicReference类来保证引用对象之间的原子性，可以把多个变量放在一个对象里来进行CAS操作。

自旋时间太长（建立在自旋锁的基础上）

当一个线程获取锁时失败，不进行阻塞挂起，而是间隔一段时间再次尝试获取，直到成功为止，这种循环获取的机制被称为自旋锁(spin lock)。

自旋锁好处是，持有锁的线程在短时间内释放锁，那些等待竞争锁的线程就不需进入阻塞状态（无需线程上下文切换/无需用户态与内核态切换），只需要等一等（自旋），等到持有锁的线程释放锁之后即可获取，这样就避免了用户态和内核态的切换及线程上下文切换的开销。

自旋锁坏处显而易见，线程在长时间内持有锁，等待竞争锁的线程一直自旋，即CPU一直空转，资源浪费在毫无意义的地方，所以一般会限制自旋次数。

最后来说自旋锁的实现，实现自旋锁可以基于CAS实现，先定义lockValue对象默认值1，1代表锁资源空闲，0代表锁资源被占用，代码如下

public class SpinLock {
    
    //lockValue 默认值1
    private AtomicInteger lockValue = new AtomicInteger(1);
    
    //自旋获取锁
    public void lock(){

        // 循环检测尝试获取锁
        while (!tryLock()){
            // 空转
        }

    }
    
    //获取锁
    public boolean tryLock(){
        // 期望值1，更新值0，更新成功返回true，更新失败返回false
        return lockValue.compareAndSet(1,0);
    }
    
    //释放锁
    public void unLock(){
        if(!lockValue.compareAndSet(1,0)){
            throw new RuntimeException("释放锁失败");
        }
    }

}

获取锁tryLock

1. 期望值1，更新值0
2. CAS更新
3. 如果期望值与lockValue值相等，则lockValue值更新为0，返回true，否则执行下面逻辑
4. 如果期望值与lockValue值不相等，不做任何更新，返回false

释放锁unlock

1. 期望值0，更新值1
2. CAS更新
3. 如果期望值与lockValue值相等，则lockValue值更新为1，返回true，否则执行下面逻辑
4. 如果期望值与lockValue值不相等，不做任何更新，返回false

自旋获取锁lock

执行tryLock函数，返回true停止，否则一直循环

可以看到，只有tryLock成功的线程（把lockValue更新为0），才会执行代码块，其他线程个tryLock自旋等待lockValue被更新成1，tryLock成功的线程执行unLock（把lockValue更新为1），自旋的线程才会tryLock成功。

ABA问题

CAS需要检查待更新的内存值有没有被修改，如果没有则更新，但是存在这样一种情况，如果一个值原来是A，变成了B，然后又变成了A，在C A S检查的时候会发现没有被修改。

假设有两个线程，线程1读取到内存值A，线程1时间片用完，切换到线程2，线程2也读取到了内存值A，并把它修改为B值，然后再把B值还原到A值，简单说，修改次序是A->B->A，接着线程1恢复运行，它发现内存值还是A，然后执行CAS操作，这就是著名的ABA问题，但是好像又看不出什么问题。

只是简单的数据结构，确实不会有什么问题，如果是复杂的数据结构可能就会有问题了（使用java.util.concurrent.atomic.AtomicReference可以把CAS使用在对象上），以链表数据结构为例，两个线程通过CAS删除头节点，假设现在链表有A->B节点

1. 线程1删除A节点，B节点成为头节点，正要执行CAS(A, A, B)时，时间片用完，切换到线程2，链表：A -> B -> null
2. 线程2删除A、B节点，链表：null
3. 线程2头插法加入C、A节点，链表：A -> C -> null
4. 线程1重新获取时间片，执行CAS(A, A, B)，丢失C节点，链表：B -> null

如何解决ABA问题

只要追加版本号即可，每次改变时加1，即A -> B -> A，变成1A -> 2B -> 3A，在Java中提供了java.util.concurrent.atomic.AtomicStampedReference可以实现这个方案。

参考：

由浅入深C A S，小白也能与BAT面试官对线