Java中CAS基本原理

一、什么是原子操作

原子操作就是: 不可中断的一个或者一系列操作, 也就是不会被线程调度机制打断的操作, 运行期间不会有任何的上下文切换(context switch)。

原子操作可以是一个步骤，也可以是多个操作步骤，但是其顺序不可以被打乱，也不可以被切割而只执行其中的一部分。

假设有两个操作A和B，如果从执行A的线程来看，当另一个线程执行B时，要么将B全部执行完，要么完全不执行B，那么A和B对彼此来说是原子的。

二、怎么实现原子操作

1.锁实现原子操作

实现原子操作可以使用锁，java在1.5之前都是靠synchronized关键字保证同步，synchronized保证了无论哪个线程持有共享变量的锁，都会采用独占的方式来访问这些变量，也就是说当一个线程拥有锁的时候，访问同一个资源的其他线程需要等待，直到该线程释放锁。

这种情况下存在的问题：

1.在多线程竞争下，加锁、释放锁会导致较多的上下文切换和调度延时，CPU将会花费大量时间来处理这些竞争,系统的性能开销大

2.如果被阻塞的线程优先级很高，优先级低的线程一直占着锁，会引起性能风险；

3.如果获得锁的线程不释放锁，可能会造成死锁之类的情况。

2.CAS实现原子操作

实现原子操作还可以使用现代CPU基本都支持的CAS指令（compare and swap 比较并替换），每一个CAS操作过程都包含三个运算符——内存地址V、期望值A、新值B，如果内存地址上存放的值等于这个期望值A，则将地址上的值赋为新值B，否则不做任何操作。

CAS的基本思路就是，如果这个地址上的值和期望的值相等，则给其赋予新值，否则不做任何事，但是要返回原值是多少。CAS就是在一个循环里不断的做自旋，直到成功为止。

CAS对于synchronized阻塞算法，在性能上有了很大的提升。

三、CAS实现原子操作的三大问题（缺陷）

1.ABA问题

线程one操作变量A使其变成B，线程two也操作了这个变量A先变成B再变回A，这时使用CAS进行检查时会发现A的值没有发生变化，但是实际上却变化了(A->B->A)。

ABA问题的解决思路就是使用版本号，在变量前面追加上版本号，每次变量更新的时候把版本号加一，那么A－B－A 就会变成1A-2B－3A。

解决方法：从Java1.5开始JDK的atomic包里提供了一个类AtomicStampedReference来解决ABA问题。这个类的compareAndSet方法作用是首先检查当前引用是否等于预期引用，并且当前标志是否等于预期标志，如果全部相等，则以原子方式将该引用和该标志的值设置为给定的更新值。

    /**
     * Atomically sets the value of both the reference and stamp
     * to the given update values if the
     * current reference is {@code ==} to the expected reference
     * and the current stamp is equal to the expected stamp.
     *
     * @param expectedReference 引用的预期值
     * @param newReference 引用的新值
     * @param expectedStamp 预期标记
     * @param newStamp 更新后的标志
     * @return {@code true} if successful
     */
    public boolean compareAndSet(V   expectedReference,
                                 V   newReference,
                                 int expectedStamp,
                                 int newStamp) {

        Pair<V> current = pair;
        return
            expectedReference == current.reference &&
            expectedStamp == current.stamp &&
            ((newReference == current.reference &&
              newStamp == current.stamp) ||
             casPair(current, Pair.of(newReference, newStamp)));   
    }

2.多次循环开销大

CAS操作不成功，就会一直循环执行，直到成功，如果长时间不成功，会给CPU带来非常大的执行开销。

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

当对一个共享变量执行操作时，我们可以使用循环CAS的方式来保证原子操作，但是对多个共享变量操作时，循环CAS就无法保证操作的原子性。

解决方法：把多个变量放在一个对象里来进行CAS操作，从Java 1.5开始，JDK提供了AtomicReference类来保证引用对象之间的原子性。

    /**
     * Atomically sets the value to the given updated value
     * if the current value {@code ==} the expected value.
     * @param expect 期望值
     * @param update 新值
     * @return {@code true} 
    public final boolean compareAndSet(V expect, V update) {
        return U.compareAndSwapObject(this, VALUE, expect, update);
    }

四、Jdk中相关原子操作类的使用

1.AtomicInteger

int addAndGet（int delta）：以原子方式将输入的数值与实例中的值（AtomicInteger里的value）相加，并返回结果。

boolean compareAndSet（int expect，int update）：如果输入的数值等于预期值，则以原子方式将该值设置为输入的值。

int getAndIncrement()：以原子方式将当前值加1，注意，这里返回的是自增前的值。

int getAndSet（int newValue）：以原子方式设置为newValue的值，并返回旧值。

2.AtomicIntegerArray

主要是提供原子的方式更新数组里的整型，其常用方法如下。

•int addAndGet（int i，int delta）：以原子方式将输入值与数组中索引i的元素相加。

•boolean compareAndSet（int i，int expect，int update）：如果当前值等于预期值，则以原子方式将数组位置i的元素设置成update值。

需要注意的是，数组value通过构造方法传递进去，然后AtomicIntegerArray会将当前数组复制一份，所以当AtomicIntegerArray对内部的数组元素进行修改时，不会影响传入的数组。

3.AtomicReference

原子更新引用类型。

4.AtomicStampedReference

利用版本戳的形式记录了每次改变以后的版本号，这样的话就不会存在ABA问题了。这就是AtomicStampedReference的解决方案。AtomicMarkableReference跟AtomicStampedReference差不多， AtomicStampedReference是使用pair的int stamp作为计数器使用，AtomicMarkableReference的pair使用的是boolean mark。 还是那个水的例子，AtomicStampedReference可能关心的是动过几次，AtomicMarkableReference关心的是有没有被人动过，方法都比较简单。

5.AtomicMarkableReference

原子更新带有标记位的引用类型。可以原子更新一个布尔类型的标记位和引用类型。构造方法是AtomicMarkableReference（V initialRef，booleaninitialMark）