CAS你知道吗？

CAS你知道吗？

1.CAS是什么？

Compare-And-Swap，是一条CPU并发原语，功能就是判断内存某个位置的值是否为预期值，如果是则更改为新的值，这个过程是原子的。

简单来说四个字，比较交换

来看一段代码：

public class CASDemo {
    public static void main(String[] args) {

        AtomicInteger atomicInteger = new AtomicInteger(5);

        //main线程 do something...

        System.out.println(atomicInteger.compareAndSet(5, 2020) +  "\t currrent data: " + atomicInteger.get());
        
        System.out.println(atomicInteger.compareAndSet(5, 1234) +  "\t currrent data: " + atomicInteger.get());
    }
}

结果：

​ 先比较与主内存中的值，compareAndSet(5,2020)若atomicInteger与期望值5相同则返回true改为2020，若不同返回false

2.为什么用CAS不用synchronized?

automicInteger.getAndIncrement()方法为什么能解决num++问题？

查看源码如下：

/**
 * Atomically increments by one the current value.
 *
 * @return the previous value
 */
public final int getAndIncrement() {
    return unsafe.getAndAddInt(this, valueOffset, 1);
}

那么UnSafe类是什么?

1. UnSafe
   是CAS的核心类 由于Java 方法无法直接访问底层 ,需要通过本地(native)方法来访问,UnSafe相当于一个后面,基于该类可以直接操作特额定的内存数据.UnSafe类在于sun.misc包中,其内部方法操作可以向C的指针一样直接操作内存,因为Java中CAS操作的助兴依赖于UnSafe类的方法.
   注意UnSafe类中所有的方法都是native修饰的,也就是说UnSafe类中的方法都是直接调用操作底层资源执行响应的任务

2. 变量ValueOffset,便是该变量在内存中的偏移地址,因为UnSafe就是根据内存偏移地址获取数据的

   举个例子：老师上课提问，不用知道同学具体叫什么名字，直接叫第三排第二个座位的同学起立回答问题即可。

   unsafe.getAndAddInt(this, valueOffset, 1);

   第一个参数指的是调用方法的对象，第二个参数是到内存中找到要操作的对象的位置，第三个参数就是具体操作，这里指+1操作

3. 变量value和volatile修饰,保证了多线程之间的可见性.

​ atomicInteger调用的是getAndIncrement（）而源码中返回的是return unsafe.getAndAddInt(this,valueOffset,1);所以继续看源码：

• 实际上do循环中var5的值就是get操作从主内存中获取var1(this) 对象在var2(ValueOffset)位置的值，即期望值。

• while中就是比较var1对象，var2位置的值和刚才在工作内存中获取到的var5相同否?如果相同就交换为var5+var4 那么在unsafe.getAndAddInt(this,valueOffset,1)中显然var4=1

• 循环条件为true 取反之后跳出循环，返回之前获得的var5，实际+1（因为是getAndIncrement先获得再加1）

如果修改成功跳出循环，如果修改失败（也就是说比较失败）循环条件是false再次进入循环

​ **那么回到主题，为什么不用synchronized？因为synchronized加锁同一时间段只有一个线程进入，一致性保证，并发性下降。CAS没有加锁但是保证了一致性也保证了并发性。**举例

---

假设线程A和线程B两个线程同时执行getAndAddInt操作(分别在不同的CPU上):

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总是能够看到,线程A继续执行compareAndSwapInt方法进行比较替换,直到成功.

---

3.CAS缺点

• 循环时间长开销大：如果CAS失败，会一直尝试会给CPU带来很大压力
• 只能保证一个共享变量的原子性，解决方法用加锁来保证
• 引出ABA问题

引申：ABA问题

​ ABA问题就是线程操作时期望值是A但是它获取到A之前可能A发生过改变又变回来的，线程不知道而已。

解决方法：

1. 原子引用
2. 版本号（类似时间戳）

举例：

T1 100 1 100 3

T2 100 1 101 2 100 3

代码演示：

package CAS;

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

/**
 * Description: ABA问题的解决
 **/
public class ABADemo {
    private static AtomicReference<Integer> atomicReference = new AtomicReference<>(100);
    private static AtomicStampedReference<Integer> stampedReference = new AtomicStampedReference<>(100, 1);

    public static void main(String[] args) {
        System.out.println("===以下是ABA问题的产生===");
        new Thread(() -> {
            atomicReference.compareAndSet(100, 101);
            atomicReference.compareAndSet(101, 100);
        }, "t1").start();

        new Thread(() -> {
            //先暂停1秒 保证完成ABA
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(atomicReference.compareAndSet(100, 2019) + "\t" + atomicReference.get());
        }, "t2").start();
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }


        System.out.println("===以下是ABA问题的解决===");

        new Thread(() -> {
            int stamp = stampedReference.getStamp();
            System.out.println(Thread.currentThread().getName() + "\t 第1次版本号" + stamp + "\t值是" + stampedReference.getReference());
            //暂停1秒钟t3线程让t4线程获取版本号
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            stampedReference.compareAndSet(100, 101, stampedReference.getStamp(), stampedReference.getStamp() + 1);
            System.out.println(Thread.currentThread().getName() + "\t 第2次版本号" + stampedReference.getStamp() + "\t值是" + stampedReference.getReference());
            stampedReference.compareAndSet(101, 100, stampedReference.getStamp(), stampedReference.getStamp() + 1);
            System.out.println(Thread.currentThread().getName() + "\t 第3次版本号" + stampedReference.getStamp() + "\t值是" + stampedReference.getReference());
        }, "t3").start();

        new Thread(() -> {
            int stamp = stampedReference.getStamp();
            System.out.println(Thread.currentThread().getName() + "\t 第1次版本号" + stamp + "\t值是" + stampedReference.getReference());
            //保证线程3完成1次ABA
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            boolean result = stampedReference.compareAndSet(100, 2019, stamp, stamp + 1);
            System.out.println(Thread.currentThread().getName() + "\t 修改成功否" + result + "\t最新版本号" + stampedReference.getStamp());
            System.out.println("最新的值\t" + stampedReference.getReference());
        }, "t4").start();
    }
}