温故知新-多线程-深入刨析CAS

文章目录

• 摘要
• CAS是什么？
• CAS是如何实现的？
• CAS存在的问题？
• 你的鼓励也是我创作的动力

---

• 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带来非常大的执行开销。

---

你的鼓励也是我创作的动力

打赏地址