搞定CAS的原理，看这一篇就够了！

一、什么是CAS？

CAS （compareAndSwap），中文叫比较交换，是一种无锁原子算法，映射到操作系统就是一条CPU的原子指令，其作用是让CPU先进行比较两个值是否相等，然后原子地更新某个位置的值，其实现方式是基于硬件平台的汇编指令，在intel的CPU中，使用的是cmpxchg指令，就是说CAS是靠硬件实现的，从而在硬件层面提升效率。

执行过程是这样：它包含 3 个参数 CAS（V，E，N），V表示要更新变量的值，E表示预期值，N表示新值。仅当 V值等于E值时，才会将V的值设为N，如果V值和E值不同，则说明已经有其他线程完成更新，则当前线程则什么都不做，最后CAS 返回当前V的真实值。

当多个线程同时使用CAS 操作一个变量时，最多只有一个会胜出，并成功更新，其余均会失败。失败的线程不会挂起，仅是被告知失败，并且允许再次尝试（自旋），当然也允许实现的线程放弃操作。基于这样的原理，CAS 操作即使没有锁，也可以避免其他线程对当前线程的干扰。

与锁相比，使用CAS会使程序看起来更加复杂一些，但是使用无锁的方式完全没有锁竞争带来的线程间频繁调度的开销和阻塞，它对死锁问题天生免疫，因此他要比基于锁的方式拥有更优越的性能。

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

 

二、CAS底层原理

这样归功于硬件指令集的发展，实际上，我们可以使用同步将这两个操作变成原子的，但是这么做就没有意义了。所以我们只能靠硬件来完成，硬件保证一个从语义上看起来需要多次操作的行为只通过一条处理器指令就能完成。这类指令称为原子指令，常用的有：

1. 测试并设置（Tetst-and-Set）

2. 获取并增加（Fetch-and-Increment）

3. 交换（Swap）

4. 比较并交 换（Compare-and-Swap）

5. 加载链接/条件存储（Load-Linked/Store-Conditional）

 

三、CPU 实现原子指令的两种方式

1. 通过总线锁定来保证原子性。

总线锁定其实就是处理器使用了总线锁，所谓总线锁就是使用处理器提供的一个 LOCK# 信号，当一个处理器在总线上输出此信号时，其他处理器的请求将被阻塞住，那么该处理器可以独占共享内存。但是该方法成本太大。因此有了下面的方式。

2、通过缓存锁定来保证原子性。

所谓 缓存锁定 是指内存区域如果被缓存在处理器的缓存行中，并且在Lock 操作期间被锁定，那么当他执行锁操作写回到内存时，处理器不在总线上声言 LOCK# 信号，而时修改内部的内存地址，并允许他的缓存一致性机制来保证操作的原子性，因为缓存一致性机制会阻止同时修改两个以上处理器缓存的内存区域数据（这里和 volatile 的可见性原理相同），当其他处理器回写已被锁定的缓存行的数据时，会使缓存行无效。

注意：有两种情况下处理器不会使用缓存锁定：

• 当操作的数据不能被缓存在处理器内部，或操作的数据跨多个缓存行时，则处理器会调用总线锁定。
• 有些处理器不支持缓存锁定，对于 Intel 486 和 Pentium 处理器，就是锁定的内存区域在处理器的缓存行也会调用总线锁定

 

四、CAS举例

JUC下的atomic类都是通过CAS来实现的，下面就以AtomicInteger为例来阐述CAS的实现，一个使用普通整型变量的自增，一个利用原子类进行自增，如下：

利用javap将class文件反汇编成机器指令后，可以发现他们的区别如上。

Atomic原子类中都调用了Unsafe类中的CAS方法实现变量的原子性操作，因此阅读原子类直接阅读Unsafe类即可。

 

五、CAS源码分析

首先来看原子类中的主要组成部分：

 

Unsafe是CAS的核心类，Java无法直接访问底层操作系统，而是通过本地（native）方法来访问。不过尽管如此，JVM还是开了一个后门：Unsafe，它提供了硬件级别的原子操作。

例如 AtomicInteger 类调用incrementAndGet（）方法实现原子性的自增，内部调用Unsafe的getAndAddInt方法：

public final int incrementAndGet() {
    return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
}

在Unsafe类的getAndAddInt方法中主要是看compareAndSwapInt方法：

public final int getAndAddInt(Object var1, long var2, int var4) {
    int var5;
    do {
        var5 = this.getIntVolatile(var1, var2);
    } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
    return var5;
}

我们可以看到Unsafe类中的compareAndSwapInt是一个native本地方法：

public final native boolean compareAndSwapInt(Object var1, long var2, 
                                              int var4, int var5);

既然Unsafe类里的是本地方法，我们就要到具体实现的虚拟机（HotSpot）中去查看C++源码：

 

我们可以查看Atomic::cmpxchg函数的具体实现：

（ASM是C++中的一个关键字,用于在C++源码中内嵌汇编语言）

 

不难发现，cmpxchg这条汇编语言可以直接操作内存进行数据交换，实现CAS最终目的。

（一条汇编指令对应一条CPU指令，是单步操作，自然是原子性的，因此谁CAS实现是硬件层面上的）

这里看到有一个LOCK_IF_MP，作用是如果是多处理器，在指令前加上LOCK前缀，因为在单处理器中，是不会存在缓存不一致的问题的，所有线程都在一个CPU上跑，使用同一个缓存区，也就不存在缓存与主内存不一致的问题，不会造成可见性问题。

（缓存在CPU上，主内存不在CPU上，CPU是通过缓存去读取主内存的，每个CPU对应一个缓存，不同缓存对应不同CPU，这里要结合前面的JMM模型和硬件架构理一理）

然而在多核处理器中，需要遵循缓存一致性协议通知其他处理器更新自己的缓存。

Lock在这里的作用：

• 在cmpxchg执行期间，锁住内存地址[edx]，其他处理器不能访问该内存，保证原子性。

（这个就是保证CAS原子性的关键所在）

• 写内存屏障，保证每个线程的本地空间与主存一致。
• 禁止cmpxchg与前后任何指令重排序，防止指令重排序。

以使用AtomicInteger对变量进行自增操作为例，可以得到如下主要流程：

 

六、CAS缺点

CAS虽然高效地解决了原子操作，但是还是存在一些缺陷的，主要表现在三个方面：

1.自旋时间太长

如果CAS一直不成功呢？这种情况绝对有可能发生，如果自旋CAS长时间地不成功，则会给CPU带来非常大的开销。在JUC中有些地方就限制了CAS自旋的次数，例如BlockingQueue的SynchronousQueue。

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

看了CAS的实现就知道这只能针对一个共享变量，如果是多个共享变量就只能使用锁了，当然如果你有办法把多个变量整成一个变量，利用CAS也不错。例如读写锁中state的高低位。（https://www.cnblogs.com/wait-pigblog/p/9350569.html）

3.ABA问题

CAS需要检查操作值有没有发生改变，如果没有发生改变则更新。但是存在这样一种情况：如果一个值原来是A，变成了B，然后又变成了A，那么在CAS检查的时候会发现没有改变，但是实质上它已经发生了改变，只是又回到了原来的值而已，这就是所谓的ABA问题。对于ABA问题其解决方案是加上版本号，即在每个变量都加上一个版本号，每次改变时加1，即A —> B —> A，变成1A —> 2B —> 3A，采用AtomicStampedRdference类可以实现这个方案。