CAS

CAS

cas是什么

Compare-And-Swap 比较并交换，是一条CPU的并发原语

判断内存中某个位置的值是否为预期值，如果是则更改为新的值，这个过程是原子的

如果主内存中的值和期望中的值一样，就修改为现在想要的值，如果主内存中的值和期望中的值不一样，就不修改

package com.audition.cas;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * Created with IntelliJ IDEA.
 *
 * @Auther: 两杯水
 * @Date: 2021/03/01/10:11
 * @Description:
 * cas是什么？比较并交换
 *
 */
public class CasDemo1 {
    public static void main(String[] args) {
        //得到的默认值是5
        AtomicInteger atomicInteger = new AtomicInteger(5);
        //compareAndSet：比较内存中的值是否是5，如果是就修改为2021
        System.out.println(atomicInteger.compareAndSet(5, 2021)+ "\t current data:" +atomicInteger.get());
        System.out.println(atomicInteger.compareAndSet(5, 1234)+ "\t current data:" +atomicInteger.get());
    }
}

cas的底层原理

比较当前工作内存中的值和主内存中的值，如果相同则执行规定操作，否则继续比较，直到主内存中的值和工作内存中的值一致为止

自旋锁和UnSafe类

UnSafe类：CAS核心类，Java无法直接访问底层系统，其内部方法可以向C指针一样操作内存，java CAS操作依靠于UnSafe类，UnSafe根据内存偏移地址获取数据的，

所以说cas是一种系统原语，原语的执行必须是连续的，在执行过程中不能被终端，CAS是cpu的原子指令，所以不会造成数据不一致问题

CAS应用：

CAS有3个操作数，内存值V，旧的预期值A，要修改的更新值B

当且仅当预期值A和内存值V相同时，将内存值V修改为B，否则什么都不做

CAS缺点：

循环时间长：如果CAS失败，会一直进行尝试，会给CPU造成很大开销

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

引来ABA问题

ABA问题：

两个线程同时取主物理内存中的同一内存中的数据，但是由于其中一个线程比另一个线程快，中间修改了内存数据多次，在另一个线程访问之前，又把内存数据修改为第一次获取值，。当另一个线程回去访问时，并不知道数据已经修改了多次了，只看到数据一样

解决ABA问题

代码示例：

package com.audition.cas;

import lombok.*;

import java.util.concurrent.atomic.AtomicReference;

/**
 * Created with IntelliJ IDEA.
 *
 * @Auther: 两杯水
 * @Date: 2021/03/01/11:24
 * @Description:原子引用  AtomicReference
 */
@Getter
@Setter
@AllArgsConstructor
@ToString
class User{
    String userName;
    int age;
}
public class CasDemo2 {
    public static void main(String[] args) {
        User z3 = new User("z3",23);
        User li4 = new User("li4",25);
        AtomicReference<User> reference = new AtomicReference<>();
        reference.set(z3);
        System.out.println(reference.compareAndSet(z3, li4)+"\t" +reference.get().toString());
        System.out.println(reference.compareAndSet(z3, li4)+"\t" +reference.get().toString());


    }

}

新增一种机制，修改版本号（类似时间戳）

package com.audition.cas;

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

/**
 * Created with IntelliJ IDEA.
 *
 * @Auther: 两杯水
 * @Date: 2021/03/01/11:34
 * @Description:  AtomicStampedReference
 */
public class ABADemo {
     static AtomicReference<Integer> atomicReference = new AtomicReference<>(100);
     static AtomicStampedReference<Integer> atomicStampedReference = 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(()->{
            //暂停一秒钟，保证t1线程完成了一次ABA操作
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(atomicReference.compareAndSet(100,200)+"\t"+atomicReference.get());
        },"t2").start();
        //暂停一会线程
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        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第二次版本号"+stamp);
            atomicStampedReference.compareAndSet(101,100,atomicStampedReference.getStamp(),atomicStampedReference.getStamp()+1);
            System.out.println(Thread.currentThread().getName()+"\t第三次版本号"+stamp);
        },"t3").start();

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

        },"t4").start();
    }
}