17. JUC你了解CAS吗

*CAS是什么

CAS的全称为Compare-And-Swap ,它是一条CPU并发原语，它的功能是判断内存某个位置的值是否为预期值，如果是则更改为新的值，否则继续比较直到主内存和工作内存中的值一致为止，整个过程是原子的。

CAS并发原语体现在Java语言中就是sun.misc.Unsafe类中的各个方法。

调用Unsafe类中的CAS方法，JVM会帮我们实现CAS汇编指令。

这是一种完全依赖于硬件的功能，通过它实现了原子操作。

再次强调，由于CAS是一种系统原语，原语属于操作系统用语范畴，是由若干条指令组成，用于完成某个功能的一个过程，并且原语的执行必须是连续的，在执行过程中不允许中断，也就是说CAS是一条CPU的原子指令，不会造成所谓的数据不一致问题。

*比较并交换

1. 主物理内存中有1个5，此时有两个线程要对其操作
2. A、B线程都对主物理内存的这个值进行了副本拷贝
3. A线程从主物理内存中取走的时候是5，要写入主物理内存时发现主物理内存的值还是5，这说明没有人动过，此时成功将值修改为2019
4. B线程当它要写入主物理内存，判断拿走的是否与主物理内存一致时，发现主物理内存的值已经被修改过了，则修改失败，主物理内存的值保持不变。

public class CASDemo {
    public static void main(String[] args) {
        AtomicInteger atomicInteger = new AtomicInteger(5);
        System.out.println(atomicInteger.compareAndSet(5, 2021) + "\t" + atomicInteger.get());
        System.out.println(atomicInteger.compareAndSet(5, 2022) + "\t" + atomicInteger.get());
    }
}

结论：如果线程的期望值与主物理内存的真实值一样，那就修改为更新值，返回true，如果不一样，则修改失败，返回false。

*CAS的底层原理

Unsafe类加自旋

*谈谈你对Unsafe的理解

AtomicInteger.java

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();
	
    // 表示该变量在内存中的偏移地址，因为Unsafe就是根据内存偏移地址获取数据的
    private static final long valueOffset;

    static {
        try {
            valueOffset = unsafe.objectFieldOffset
                (AtomicInteger.class.getDeclaredField("value"));
        } catch (Exception ex) { throw new Error(ex); }
    }

    // value用volatile修饰，保证多线程之间的可见性
    private volatile int value;
    
    //...
}

Unsafe存在于sun.misc包中，是CAS的核心类

由于Java 方法无法直接访问底层 ，所以需要通过本地（native）方法来访问

而Unsafe类所有的方法都是native修饰的，它的内部方法可以像C的指针一样直接操作内存

就是直接调用操作系统底层资源执行相应任务，相当于Java直接调用操作系统资源的中间类，所以Java中CAS的执行依赖于Unsafe类的方法

*底层原理详解

AtomicInteger.java

• this：代表当前对象
• valueOffset：内存偏移地址
• 1：需要变动的数量

Unsafe.class

• var1：代表当前对象
• var2：内存偏移地址
• var4：需要变动的数量
• var5：是通过var1跟var2找出的主内存中真实的值

1. AtomicInteger里面的value原始值为3，即主内存中AtomicInteger的value为3，根据JMM模型，线程A和线程B分别在工作内存中持有一份值为3的value的副本
2. 线程A通过getIntVolatile(var1,var2)拿到value值3，这时线程A被挂起
3. 线程B也通过getIntVolatile(var1,var2) 拿到value值3，此时刚好线程B没有被挂起并执行了compareAndSwapInt方法，结果比较内存中的值也是3，成功修改内存值为4，线程B打完收工 ，一切OK
4. 这时线程A恢复，执行compareAndSwapInt方法比较，发现自己手里的数值和内存中的数字4不一致，说明该值已经被其他线程抢先修改了，A线程修改失败，只能重新再来
5. 线程A重新获取value值，因为变量value是volatile修饰，所以修改对其它的线程是可见的，线程A继续执行compareAndSwapInt方法进行比较替换，直到成功

*CAS缺点

1. 循环时间长开销大

   在getAndAddInt方法中有个do while，如果CAS失败，会一直进行尝试，如果CAS长时间一直不成功，则会给CPU带来很大的开销。

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

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

3. 引出来ABA问题？

总结：

1. synchronized加锁，一致性保证，并发性下降
2. CAS不加锁，保证一致性，但是需要多次比较，耗费时间长，开销较大。

*原子类AtomicInteger的ABA问题谈谈?原子更新引用知道吗？

CAS会导致“ABA问题”

CAS算法实现的一个重要前提是需要取出内存中某时刻的数据，并在当下时刻比较并替换，这个时间差会导致数据有变化

举例：

比如说一个线程one从内存位置V中取出A，这时候另一个线程two也从内存中取出A，并且线程two进行了一些操作将值变成了B，

然后线程two又将数据变成A，这时候线程one进行CAS操作时发现内存中仍然是A，然后线程one操作成功。

尽管线程one的CAS操作成功，但是不代表这个过程就没有问题

*写一个产生ABA问题的demo

public class ABADemo{
	static AtomicReference<Integer> ar = new AtomicReference<>(100);
	
	public static void main(String[] args){
		new Thread(() -> {
			ar.compareAndSet(100, 101);
			ar.compareAndSet(101, 100);
		}, "t1").start();
		
		new Thread(() -> {
			try{
				TimeUnit.SECONDS.sleep(1);
			}catch(InterruptedException e){
				e.printStackTrace();
			}
			System.out.println(ar.compareAndSet(100, 2019) + "\t" + ar.get());
		}, "t2").start();
	}
}

*如何解决ABA问题

使用版本号机制

public class ABADemo{
	static AtomicStampedReference<Integer> asr = new AtomicStampedReference(100, 1);
	
	public static void main(String[] args){
		new Thread(() -> {
			int stamp = asr.getStamp();
			System.out.println(Thread.currentThread().getName() + "\t第1次版本号：" + stamp);
			try{
				TimeUnit.SECONDS.sleep(1);
			}catch(InterruptedException e){
				e.printStackTrace();
			}
			asr.compareAndSet(100, 101, asr.getStamp(), asr.getStamp() + 1);
			System.out.println(Thread.currentThread().getName() + "\t第2次版本号：" + asr.getStamp());
			asr.compareAndSet(101, 100, asr.getStamp(), asr.getStamp() + 1);
			System.out.println(Thread.currentThread().getName() + "\t第3次版本号：" + asr.getStamp());            
		}, "t3").start();
		
		new Thread(() -> {
			int stamp = asr.getStamp();
			System.out.println(Thread.currentThread().getName() + "\t第1次版本号：" + stamp);
			try{
				TimeUnit.SECONDS.sleep(3);
			}catch(InterruptedException e){
				e.printStackTrace();
			}
			boolean result = asr.compareAndSet(100, 2021, stamp, stamp + 1);
			System.out.println(Thread.currentThread().getName() + "\t修改成功否：" +
            result + "\t\t当前最新版本号：" + asr.getStamp() + "\t\t当前最新值：" + asr.getReference());            
		}, "t4").start();
	}
}