Java CAS

引言

在介绍CAS之前，我们有必要先理解线程安全的三大特性

原子性: 对于涉及共享变量访问的操作，该操作从其执行线程以外的任意线程来看是不可分割的，从而可以让各个线程依次串行访问，但是原子性并不保证可见性
可见性: 修改共享变量时，立即将工作内存中的值同步到主存中，并使该修改对其他线程可见
有序性: 禁止读取共享变量后的代码、修改共享变量前的代码重排序

CAS即compare and swap的缩写，中文翻译成比较并交换。是一种用于在多线程环境下实现同步功能的机制。调用Java CAS需要三个操作数

内存中值的内存位置
预期值
新值

具体实现是通过值的内存位置取到内存中的值并与预期值比较，若相等，则将内存位置处的值替换为新值，若不相等，则不做任何操作返回false。如果大家有了解过悲观锁和乐观锁，可以发现CAS其实是一种乐观锁的实现。

使用CAS的目的

对于实现线程安全，我们用的比较多的应该是synchronized关键字，synchronized其实是一种悲观锁，锁被占用的情况会导致其它所有需要锁的线程挂起，等待持有锁的线程释放锁。CAS是一种乐观锁，每次取数据都不会加锁，更新的时候会进行数据比对，有冲突的话则会自旋重试。可以看到在读操作频繁，更新频率低，冲突概率低的情况下，用CAS的话会更加合理。当然JDK1.6之后，Java对synchronized关键字来了一大波优化（自旋锁，锁消除，锁粗化，偏向锁，轻量级锁），一般情况下使用synchronized是非常稳定的。

CAS的底层实现

现在的CPU都是多核心的，多个核心通过总线来操作内存。那么这里就存在一个问题，就是如果多个核心同时操作一块内存区域，会发生什么问题呢？是的，这里数据就会出现混乱。不过这里我们可以从intel的使用手册中找到答案，对指令加lock前缀可以保证操作的原子性，可见性以及有序性。好了，底层的就不多说了，我们直接去看一下java.util.concurrent.atomic包下的原子类 AtomicInteger的源码实现

AtomicInteger源码

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();
    // value值的内存位置
    private static final long valueOffset;

    static {
        try {
            // 获取value的内存位置
            valueOffset = unsafe.objectFieldOffset
                (AtomicInteger.class.getDeclaredField("value"));
        } catch (Exception ex) { throw new Error(ex); }
    }
      
      // value值 volatile 修饰 保证可见性
    private volatile int value;

    public AtomicInteger(int initialValue) {
        value = initialValue;
    }

    public AtomicInteger() {
    }

    /**
     * 获取value在内存中当前的值
     *
     * @return the current value
     */
    public final int get() {
        return value;
    }
    
    /**
     * 比较并替换 实现在unsafe.compareAndSwapInt中
     * @param expect 期望值
     * @param update 新值
     */
    public final boolean compareAndSet(int expect, int update) {
        return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
    }
    
    /**
     * 自增 实现在unsafe.getAndAddInt中
     */
    public final int incrementAndGet() {
            return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
     }

}

Unsafe.class

public final native boolean compareAndSwapInt(Object o, long valueOffset, int expected, int value);

/**
 * 获取当前值 并加1，返回的是加1前的值
 */
public final int getAndAddInt(Object o, long valueOffset, int addValue) {
    int currentValue;
    do {
        currentValue = this.getIntVolatile(o, valueOffset);
        // 比较当前内存的值和预期值currentValue是否一致，一致的话则设置新值。但是因为当前内存中的值有可能被其他线程修改，会有和预期值不一致的情况，所以这里会循环直到 compareAndSwapInt 返回成功为止，这里的操作也称为CAS自旋
    } while(!this.compareAndSwapInt(o, valueOffset, currentValue, value + addValue));
    return value;
}

AtomicInteger是Java对Integer类型原子性操作的实现，可以看到底层都是调用了CAS compareAndSwapIntnative方法。
这里主要看一下compareAndSwapInt(Object o, long valueOffset, int expect, int update)的四个参数

o 当前操作的对象
valueOffset 操作值所在的内存位置
expect 期望值
update 新值

具体实现是将内存位置处的数值与预期数值相比较，若相等，则将内存位置处的值替换为新值。若不相等，则不做任何操作。
CAS自旋指的是替换新值失败时会进入循环，重新获取期望值，直到期望值和内存位置处的数值相等。

CAS的问题

ABA问题

提到CAS存在的问题，就不得不提ABA问题，什么是ABA问题呢？
举个例子，A是个共享变量，原值是10，线程1从内存中拿到了A，此时值为10，当线程1要对变量A进行CAS操作前，因为其他线程的操作，A从10变为了11，又从11变回了10。此时线程1对变量A执行CAS操作照道理应该是要失败的，但实际却是成功的。这是因为经过了上面的流程，在线程1看来，变量A没有发生任何变化，所以它执行CAS操作是会成功的。

要解决ABA问题，通常的解决方案给对象加上版本号，每经过一次CAS操作就更新一次版本号

总结

本文的目的主要是让自己对java并发包的基础CAS有个简单的了解，以便进行后续的源码分析