- Posted by 微博@Yangsc_o
- 原创文章，版权声明：自由转载-非商用-非衍生-保持署名 | Creative Commons BY-NC-ND 3.0
摘要
本文从CAS的基本操作开始，逐步探究CAS的实现原理，本文涉及代码使用JDK1.8版本；
CAS是什么？
CAS是Compare And Swap (Compare And Exchange) 的简称，从因为的意思也很容易理解：比较并交换。
- 先看一段代码，两个线程分别对atomicInteger加100，因为AtomicInteger是可以保证++是原子操作的，所以最终输出结果是：200
public class CasDemo {
public static void main(String[] args) {
AtomicInteger atomicInteger = new AtomicInteger(0);
new Thread(()->{
for (int i = 0; i < 100; i++) {
atomicInteger.incrementAndGet();
}
},"a").start();
new Thread(()->{
for (int i = 0; i < 100; i++) {
atomicInteger.incrementAndGet();
}
},"b").start();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
log.info(atomicInteger.get());
}
}
CAS是如何实现的？
- AtomicInteger类
在AtomicInteger数据定义的部分，实际存储的值是放在value中的，除此之外获取了unsafe实例，并且定义了valueOffset。再看到static块，根据加载过程，static块的加载发生于类加载的时候，是最先初始化的，这时候调用unsafe的objectFieldOffset从Atomic类文件中获取value的偏移量，那么valueOffset其实就是记录value的偏移量的。
public class AtomicInteger extends Number implements java.io.Serializable {
private static final long serialVersionUID = 6214790243416807050L;
// setup to use Unsafe.compareAndSwapInt for updates
private static final Unsafe unsafe = Unsafe.getUnsafe();
private static final long valueOffset;
static {
try {
valueOffset = unsafe.objectFieldOffset
(AtomicInteger.class.getDeclaredField("value"));
} catch (Exception ex) { throw new Error(ex); }
}
private volatile int value;
...
}
- 再看一下incrementAndGet函数
- var5 = this.getIntVolatile(var1, var2); // 取出Object中偏移地址为var2的值var5；
- this.compareAndSwapInt(var1, var2, var5, var5 + var4)比较var1中偏移量为var2的值是否和var5相等？相等则更新为var5 + var4；参数换个名字应该会清晰很多：compareAndSwapInt（obj, offset, expect, update）；
/**
* Atomically increments by one the current value.
*
* @return the updated value
*/
public final int incrementAndGet() {
return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
}
public final int getAndAddInt(Object var1, long var2, int var4) {
int var5;
do {
// 取出Object中偏移地址为var2的值var5；
var5 = this.getIntVolatile(var1, var2);
// 比较var1中偏移量为var2的值是否和var5相等？相等则更新为var5 + var4；
} while (!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
return var5;
}
- 问题来了？比较并交换就是也是两个步骤，怎么能保证线程同步呢？
下载一下Hotspot源码，看到compareAndSwapInt实现的源码如图所示，发现最终调用了Atomic::cmpxchg(x, addr, e)方法。
public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);
翻看源码（如下面两张图所示）可以看到，不同的平台有不同的实现方式；
- 在x86的架构下实现，是通过LOCK_IF_MP加锁的方式实现
- os::is_MP判断当前系统是否为多核系统，如果是就给总线加锁，所以同一芯片上的其他处理器就暂时不能通过总线访问内存，保证了该指令在多处理器环境下的原子性。
- __asm__说明是ASM汇编，__volatile__禁止编译器优化，
// Adding a lock prefix to an instruction on MP machine
#define LOCK_IF_MP(mp) "cmp $0, " #mp "; je 1f; lock; 1: "
在atomic.cpp中则是通过递归实现的；
因为根据IA64手册，X86_64架构下，不跨越cacheline的8byte读写是原子的，如果你有个指针，没有跨越cacheline，那么多线程对这个指针的复制和读取都是不需要加锁的，可以保证原子的读到这8byte；
CAS存在的问题？
-
ABA的问题
CAS需要在操作值的时候检查下值有没有发生变化，如果没有发生变化则更新，但是如果一个值原来是A，变成了B，又变成了A，那么使用CAS进行检查时会发现它的值没有发生变化，但是实际上却变化了。这就是CAS的ABA问题。
常见的解决思路是使用版本号。在变量前面追加上版本号，每次变量更新的时候把版本号加一，那么A-B-A 就会变成1A-2B-3A。
目前在JDK的atomic包里提供了一个类AtomicStampedReference来解决ABA问题。这个类的compareAndSet方法作用是首先检查当前引用是否等于预期引用，并且当前标志是否等于预期标志，如果全部相等，则以原子方式将该引用和该标志的值设置为给定的更新值。 -
循环时间长开销大
如果CAS不成功，则会原地自旋，如果长时间自旋会给CPU带来非常大的执行开销。
