18.CAS算法

1) 什么是CAS

1. 应用在并发编程领域
2. CAS有3个操作数：内存值V，预期值A，要修改的值B，当且仅当预期值A和内存值V相同时，才将内存值修改为B，否则什么都不做。最后返回现在的V作为新一轮预期值A。
3. 核心原理是compare and swap: 一个CPU操作指令，不可分割，具有原子性

2. 适用场景

1. 乐观锁
2. 并发容器
3. 原子类

3) 以AtomicInteger为例，分析在Java中是如何利用CAS实现原子操作的？

1. 以AtomicInteger的getAndAdd方法为突破口，分析该类是如何通过CAS实现并发下的累加操作。

public final int getAndAdd(int delta) {
    return unsafe.getAndAddInt(this, valueOffset, delta);
}

2. 这里用到了Unsafe类，Unsafe是CAS的核心类。Java无法直接访问底层操作系统，而是通过本地native方法类访问。不过尽管如此，JVM还是开了一个后门，JDK中有一个Unsafe，提供了硬件级别的原子操作。
3. AtomicInteger加载Unsafe工具，用来直接操作内存数据
   • Unsafe来实现底层操作,Unsafe根据内存偏移地址获取数据的原始值。
   • 用volatile修饰value字段，保证可见性

// setup to use Unsafe.compareAndSwapInt for updates
private static final Unsafe unsafe = Unsafe.getUnsafe();
private static final long valueOffset;

// 类加载时，获取value的内存地址偏移量 (相对对象地址)valueOffset
static {
    try {
        valueOffset = unsafe.objectFieldOffset
            (AtomicInteger.class.getDeclaredField("value"));
    } catch (Exception ex) { throw new Error(ex); }
}

private volatile int value;

valueOffset表示的是变量值在内存中相对对象偏移的地址，Unsafe根据内存偏移地址获取数据的原值，这样我们就能通过unsafe来实现CAS。

4. 接下来研究Unsafe的getAndAddInt方法的实现

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;
}

5. 看着不直接，将变量替换以后

public final int getAndAddInt(Object atomicInteger, long offset, int addNumber) {
    int expect;
    do {
        // 根据对象和偏移量获取内存值
        expect = this.getIntVolatile(atomicInteger, offset);
    // 执行CAS算法,如果不成功，则自旋到成功为止
    } while(!this.compareAndSwapInt(atomicInteger, offset, expect, expect + addNumber));

    return expect;
}

6. Unsafe类中的compareAndSwapInt的native方法部分实现
   • 方法中先想办法拿到变量value在内存中的地址。
   • 通过Atomic::cmpxchg实现原子性的比较和替换，其中参数x是即将更新的值，参数e是内存的值。至此，最终完成了CAS的全过程。

---

compareAndSwapInt的native方法部分实现.png

4) 缺点

1. ABA问题：由于直接对比的为操作值，检查的内存值可能被修改过，只不过刚好与本次期望值相同(显然，标准库中CAS算法的设计认为ABA问题不影响我期望的操作)

   • 解决方式：添加版本号进行比较(业务中在数据库中进行实现)

2. 自旋时间过长