JAVA并发编程（五）原子操作CAS

1. CAS的由来

JDK 1.5之前Java语言是靠synchronized关键字进行并发控制的。而synchronized本质上是排它锁/独占锁、悲观锁。这会导致以下问题：
a.在多线程竞争下，加锁、释放锁会导致较多的上下文切换和调度延时，引起性能问题。
b.同一时间仅有一个线程可持有对象A的锁，其它需要锁线程都会进入阻塞状态。即使线程间的操作互不影响。
并发情况下，volatile关键字可保障共享变量的可见性，但是不能保证原子性。并发控制最终还是要靠锁机制来解决。乐观锁应运而生。
所谓乐观锁就是：每次不加锁而是假设没有冲突而去完成某项操作，如果因为冲突失败就重试，直到成功为止。乐观锁用到的机制就是CAS。

2. 什么是CAS

CAS是compare and swap的缩写。翻译一下就是比较然后交换
硬件很早就在芯片中加入了大量直至并发操作的原语，从而在硬件层面提升效率。在intel的CPU中，使用cmpxchg指令。CAS基于这些指令实现。
CAS理论是java.util.concurrent并发工具包实现的基石。此处又要致敬Doug Lea。
CAS 操作包含三个操作数：内存位置（V）、预期原值（A）和新值(B)。 如果内存位置的值与预期原值相匹配，那么将该位置值更新为新值 。否则，不做任何操作。

通常将 CAS 用于同步的方式是从地址 V 读取值 A，执行多步计算来获得新值 B，然后使用 CAS 将 V 的值从 A 改为 B。如果 V 处的值尚未同时更改，则 CAS 操作成功。否则失败。

3. CAS存在的问题

CAS虽然很高效的解决原子操作，但是CAS也存在一些问题：
3.1. ABA问题
CAS 操作修改值的时候检查下V地址的值有没有发生变化，如果没有发生变化则更新。
例如：V地址原值为A，线程1、线程2同时取得V地址的原值A，作为预期值进行CAS操作。线程1先完成了CAS操作，将值改为B。线程2尚未完成CAS操作。在线程2进行比较替换操作前线程3又将V地址的值从B改回了A。随后线程2可以顺利通过CAS的比较替换操作：比较V地址的值确实等于A，然后将值改为C。
虽然线程二的CAS操作顺利执行完成。但确是有问题的。因为线程二进行CAS操作期间V地址的值发生了变化。
做个比喻：James喝水之前会检测下杯中的水有没有被动过。过程是这样的：James将杯子接满水，取到预期值：杯子是满的。然后喝水时检测一下杯子是否是满的，如果是则喝掉。接完水后James和Mark聊了一会。这期间别人用了James的杯子喝了水，并把杯中的水又接满了。按照CAS方法：James喝水前检查杯子里的水是满的，于是将杯中的水喝掉了。
ABA问题的解决思路就是使用版本号。在变量前面追加上版本号，每次变量更新的时候把版本号加一，那么A-B-A 就会变成1A-2B-3A。
从Java1.5开始JDK的atomic包里提供了2个类AtomicMarkableReference、AtomicStampedReference来解决ABA问题：AtomicMarkableReference可判断原子对象是否被修改过；AtomicStampedReference可通过版本号变更判断原子变量被修改过几次。

栗子：

import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicStampedReference;

/**
 * @author Ryan Lee
 */
public class TestABA {
    private static AtomicInteger atomicInt = new AtomicInteger(100);
    private static AtomicStampedReference atomicStampedRef =
            new AtomicStampedReference<>(100, 0);

    public static void main(String[] args) throws InterruptedException {
        Thread intT1 = new Thread(() -> {
            atomicInt.compareAndSet(100, 101);
            atomicInt.compareAndSet(101, 100);
            System.out.println(Thread.currentThread().getName()+" 修改atomicInt");
        });

        Thread intT2 = new Thread(() -> {
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            boolean c3 = atomicInt.compareAndSet(100, 101);
            System.out.println(Thread.currentThread().getName() + " atomicInt CAS操作结果：" + c3);        //true

        });
        intT1.start();
        intT2.start();
        TimeUnit.SECONDS.sleep(2);
        Thread refT1 = new Thread(() -> {
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            atomicStampedRef.compareAndSet(100, 101,
                    atomicStampedRef.getStamp(), atomicStampedRef.getStamp() + 1);
            atomicStampedRef.compareAndSet(101, 100,
                    atomicStampedRef.getStamp(), atomicStampedRef.getStamp() + 1);
            System.out.println(Thread.currentThread().getName()+" 修改atomicStampedRef");


        });

        Thread refT2 = new Thread(() -> {
            int stamp = atomicStampedRef.getStamp();
            System.out.println(Thread.currentThread().getName()+" sleep前atomicStampedRef被修改次数: " + stamp);    // stamp = 0
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+" sleep后atomicStampedRef被修改次数: " + atomicStampedRef.getStamp());    // stamp = 0
            boolean c3 = atomicStampedRef.compareAndSet(100, 101, stamp, stamp + 1);
            System.out.println(Thread.currentThread().getName() + " atomicStampedRef CAS操作结果：" + c3);

        });

        refT1.start();
        refT2.start();
    }

}

运行结果

Thread-0 修改atomicInt
Thread-1 atomicInt CAS操作结果：true
Thread-3 sleep前atomicStampedRef被修改次数: 0
Thread-2 修改atomicStampedRef
Thread-3 sleep后atomicStampedRef被修改次数: 2
Thread-3 atomicStampedRef CAS操作结果：false

AtomicStampedReference的compareAndSet方法作用是首先检查当前版本是否等于预期版本，并且当前值是否等于预期值，如果全部相等，则以原子方式将该引用和该标志的值设置为给定的更新值。

3.2. 循环时间长开销大。
自旋CAS如果长时间不成功，会给CPU带来非常大的执行开销。

3.3. 只能保证一个共享变量的原子操作。
当对一个共享变量执行操作时，我们可以使用循环CAS的方式来保证原子操作。但对多个共享变量操作时，CAS就无法保证操作的原子性。从Java1.5开始JDK提供了AtomicReference类来保证引用对象之间的原子性，你可以把多个变量放在一个对象里来进行CAS操作。

栗子：将多个共享变量封装成一个类，调用AtomicReference实现的CAS方法

import java.util.concurrent.atomic.AtomicReference;
/**
 * @author Ryan Lee
 */
public class TestAtomicReference {
    static AtomicReference countryRef = new AtomicReference();

    public static void main(String[] args) {
        Country country = new Country("中国", "CN");//要修改的实体的实例
        countryRef.set(country);
        System.out.println("CAS操作前country："+country.getName()+country.getCode());
        System.out.println("CAS操作前countryRef："+countryRef.get().getName()+countryRef.get().getCode());
        Country otherCountry = new Country("美国", "US");//要变化的新实例
        countryRef.compareAndSet(country, otherCountry);
        System.out.println("CAS操作后country："+country.getName()+country.getCode());
        System.out.println("CAS操作后countryRef："+countryRef.get().getName()+countryRef.get().getCode());
    }
    //定义一个实体类
    static class Country {
        private String name;
        private String code;
        public Country(String name, String code) {
            this.name = name;
            this.code = code;
        }
        public String getName() {
            return name;
        }
        public String getCode() {
            return code;
        }
    }

}

执行结果：

CAS操作前country：中国CN
CAS操作前countryRef：中国CN
CAS操作后country：中国CN
CAS操作后countryRef：美国US

AtomicReference对象countryRef与原有对象country相互独立。

4. 原子操作类

更新基本类型类：AtomicBoolean，AtomicInteger，AtomicLong，AtomicReference
更新数组类：AtomicIntegerArray，AtomicLongArray，AtomicReferenceArray
更新引用类型：AtomicReference，AtomicMarkableReference，AtomicStampedReference
原子更新字段类： AtomicReferenceFieldUpdater，AtomicIntegerFieldUpdater，AtomicLongFieldUpdater