CAS

CAS你知道吗？

CAS是java提供的一种轻量级的同步机制

CAS是什么？

比较并交换(Compare and Swap),

CAS底层原理？如果知道，谈谈你对Unsafe的理解

java里面是利用UnSafe类来实现的CAS,用里面的native方法完成比较并交换

底层原理：

• List itemcas是一条CPU并发原语，判断内存某个位置的是否为预期值，如果是则更改为新的值这个过程是原子的
• CAS有三个关键值：内存值V，旧的预期值A，要修改的新值B。当且仅当预期值A和内存值V相同时，将内存值V修改为B，否则什么都不做。

CAS缺点

• 循环时间长，开销大（如果CAS失败，会一直进行尝试，如果CAS长时间不成功，开销很大）
• 只能保证一个共享变量的操作（如果多个，必须加synchnorized）
• ABA问题（最重要）

CAS调用举例

以 atomicInteger.incrementAndGet()方法为例

 atomicInteger.incrementAndGet();

incrementAndGet方法参数：

• valueOffset ： 当前对象的内存偏移地址
• this ： 当前对象（atomicInteger）

public final int incrementAndGet() {
        return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
}

在Unsafe类中的getAndAddInt方法使用CAS和自旋锁的方法来实现线程安全

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

原子更新引用和ABA问题

ABA问题

ABA问题： 简单的可以用狸猫换太子来类比

总共有两个线程A和B,操作同一个数据 a = 3

1. A线程把A改成5,再把5改成3
2. B线程看到的值是3,虽然看到的是3，但是之前已经被人给改过，过程有变动

原子引用（AtomicReference类）

问题：
除了AtomicInteger类这种已经定义好的资源类外，如果我们自定义的资源类Provider/User类要实现CAS应该怎么办呢？

解决方法：

• 使用AtomicReference类，AtomicReference类在初始化的时候有一个泛型，new AtomicReference对象的时候可以把我们的对象注入到AtomicReference里面去

private volatile V value;

 public AtomicReference(V initialValue) {
        value = initialValue;
}

User u1 = new User("张三", 12);
new AtomicReference<User>(u1);

• 先new 一个 AtomicReference对象，然后使用它的构造方法注入到对象里面去

User u2 = new User("李四", 23);
atomicReference.set(u2);

public final void set(V newValue) {
        value = newValue;
 }

解决ABA问题

有的介意ABA,有的不介意ABA,是否解决ABA问题看具体的业务情况分析！！！
具体的解决方案：

• 原子引用 + 新增一种机制，那就是修改版本号（类似事件戳），除了比较值之外，还需要比较版本号是否一致，JUC里面通过AtomicStampedReference类来实现

举例说明思路：

1. T1 ： 100 1
2. T2 :    100 1  -> 101 2 -> 100 3
3. T1的 100 1 和 T2的 100 3比较，不符合要求，更改失败

代码验证及实现：

//ABA问题的解决
public class TimeStampAtomicReferenceDemo {

    static AtomicReference atomicReference = new AtomicReference(100);
    static AtomicStampedReference<Integer> atomicStampedReference = new AtomicStampedReference<>(100, 1);

    public static void main(String[] args) {

        //ABA问题的产生
        System.out.println("ABA问题的产生");

        new Thread(() -> {
            atomicReference.compareAndSet(100,101);
            atomicReference.compareAndSet(101,100);
        },"t1").start();

        new Thread(() -> {
            try {
                //保证t1先完成,让T1先完成ABA操作
                TimeUnit.SECONDS.sleep(5);
                System.out.println(atomicReference.compareAndSet(100, 2019) + "\t"+atomicReference.get());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"t2").start();


        //ABA问题的解决
        System.out.println("ABA问题的解决");

        new Thread(() ->  {
            int stamp = atomicStampedReference.getStamp();
            System.out.println(Thread.currentThread().getName()+"\t第一次版本号: "+stamp);
            //暂停1秒钟t3线程
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            atomicStampedReference.compareAndSet(100,101,atomicStampedReference.getStamp(),atomicStampedReference.getStamp()+1);
            System.out.println(Thread.currentThread().getName()+"\t第二次版本号: "+atomicStampedReference.getStamp());
            atomicStampedReference.compareAndSet(101,100,atomicStampedReference.getStamp(),atomicStampedReference.getStamp()+1);
            System.out.println(Thread.currentThread().getName()+"\t第三次版本号: "+atomicStampedReference.getStamp());
        },"t3").start();

        new Thread(() ->  {
            int stamp = atomicStampedReference.getStamp();
            System.out.println(Thread.currentThread().getName()+"\t第一次版本号: "+stamp);
            //暂停三秒钟t4线程,保证T3线程完成了一次ABA操作
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            boolean result = atomicStampedReference.compareAndSet(100, 2019, stamp, stamp + 1);
            System.out.println(Thread.currentThread().getName()+"\t修改成功否： "+result+"\t当前实际最新版本号 "+atomicStampedReference.getStamp());

        },"t4").start();

    }

}