CAS介绍

最新推荐文章于 2024-09-04 20:00:00 发布

原创最新推荐文章于 2024-09-04 20:00:00 发布 · 216 阅读

0 ·

CC 4.0 BY-SA版权

JUC 专栏收录该内容

4 篇文章

订阅专栏

简单概念

CAS简单介绍

CAS的全称是Compare-and-Swap比较并交换，是一条CPU并发原语
主要是判断内存中的某个值是否是预期值，如果是则更改，反之继续比较直到主内存和工作内存值一致为止，并且整个过程式原子性的

CAS并发原语体现在Java语言的是sun.misc.Unsafe的各个方法。通过调用Unsafe的方法，JVM会帮我们实现CAS汇编指令。
这是一种完全依赖硬件的功能，通过它实现了原子操作。

由于CAS是系统原语，而原语属于操作系统的用语范畴，是由若干条指令组成的，用于完成某个功能的一个过程，并且原语的执行必须是连续的，在执行过程中不允许中断，保证了数据的一致性

UnSafe

Unsafe是CAS的核心类，由于Java方法无妨直接访问到底层操作系统，需要本地方法(native)进行访问，Unsafe相当于一个后门，或者说是一个中间件。通过此类可以直接的操作指定内存的数据
Unsafe属于sun.misc包下，内部方法操作可以像C的指针一样直接操作内存，因此Java中的CAS操作需要依赖Unsafe类的方法
由于Unsafe所有方法都是使用native修饰，因此可以认为Unsafe类中的方法可以直接调用操作系统底层资源执行相应任务

Unsafe类中的一些变量，都是使用native修饰，

public native int getInt(Object var1, long var2);

public native void putInt(Object var1, long var2, int var4);

public native Object getObject(Object var1, long var2);

public native void putObject(Object var1, long var2, Object var4);

通过 Unsafe.getUnsafe()获取Unsafe对象
value使用volatile修饰，保证线程间的可见性。如果不懂volatile，可以看volatile关键字解读

private static final Unsafe unsafe = Unsafe.getUnsafe();
private static final long valueOffset;

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

private volatile V value;

valueOffset表示改变量值在内存中的偏移地址，Unsafe是根据内存偏移地址获取数据的

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

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

eg：
假设线程A和线程B同时执行getAndAddInt操作(分别泡在不同的CPU中)

AtomicInteger里面的value原始值为3，即主内存中AtomicInteger的value为3，根据JMM得知，A和B的工作内存都会有一份value为3的副本
线程A通过getIntVolatile(var1,var2)拿到3，并且A被挂起
线程B也拿到3，此时线程B刚好被挂起没有执行compareAndwapint方法，线程A拿到3之后成功修改为4，线程B退出收工
线程B收工之后，线程A恢复，发现自己工作内存的value值已经改变了，那么线程A本次修改失败，重新获取更改
线程A重新获取value值，但由于value被volatile修饰，如果其它线程修改，线程A也会得知，因此线程A会继续调用compareAndwapint方法进行比较替换直到成功

CAS缺点

循环时间长开销大
只能够保证一个共享变量的原子操作(对多个共享变量操作采取加锁的方法)
引发ABA问题

ABA问题

CAS算法实现的一个重要前提是取出内存中的某个时刻的值比较并替换，如果利用时间差就会导致数据的变化
如果线程A和线程B从内存中取出value1，线程A并比较替换成了value2，之后有替换成了value1，对于线程B来说，发现内存中还是value1，线程B也操作成功

public static void main(String[] args) {
    AtomicInteger atomicInteger = new AtomicInteger(5);
    System.out.println(atomicInteger.compareAndSet(5,2019)+"\t current data: "+atomicInteger.get());
    System.out.println(atomicInteger.compareAndSet(2,2019)+"\t current data: "+atomicInteger.get());
    System.out.println(atomicInteger.compareAndSet(2019,209)+"\t current data: "+atomicInteger.get());
}
/*
true    current data: 2019
false   current data: 2019
true    current data: 209
* */

System.out.println("====================以下是ABA方法产生====================");
new Thread(()->{
    atomicReference.compareAndSet(99,100);
    atomicReference.compareAndSet(100,99);
},"t1").start();

new Thread(()->{
    try {
        TimeUnit.SECONDS.sleep(1);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println(atomicReference.compareAndSet(99,100)+"\t"+atomicReference.get());
},"t2").start();

//输出 true 100

对于ABA问题可以采用时间戳原子引用解决

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

new Thread(()->{

    int stamp = atomicStampedReference.getStamp();
    System.out.println(Thread.currentThread().getName()+"\t第一次版本号："+stamp);
    try {
        TimeUnit.SECONDS.sleep(1);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    atomicStampedReference.compareAndSet(99,100,atomicStampedReference.getStamp(),atomicStampedReference.getStamp()+1);
    System.out.println(Thread.currentThread().getName()+"\t第二次版本号："+atomicStampedReference.getStamp());
    atomicStampedReference.compareAndSet(100,99,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);
    try {
        TimeUnit.SECONDS.sleep(3);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }

    //boolean result = atomicStampedReference.compareAndSet(99,111,atomicStampedReference.getStamp(),atomicStampedReference.getStamp()+1);
    boolean result = atomicStampedReference.compareAndSet(99,111,stamp,stamp+1);

    System.out.println(Thread.currentThread().getName()+"修改成功否："+result+"\t最新版本号："+atomicStampedReference.getStamp());
    System.out.println(Thread.currentThread().getName()+"当前实际最新值："+atomicStampedReference.getReference());


},"t4").start();

/*
====================以下是ABA问题解决方法====================
t3 第一次版本号：1
t4 第一次版本号：1
t3 第二次版本号：2
t3 第三次版本号：3
t4修改成功否：false 最新版本号：3
t4当前实际最新值：99
*/