JUC（9）原子类与CAS

文章目录

一、CAS

1.1java层面的CAS

• CAS：Compare and Swap，即比较再交换。
• jdk5增加了并发包java.util.concurrent.atomic.*,其下面的类使用CAS算法实现了区别于synchronouse同步锁的一种乐观锁。JDK 5之前Java语言是靠synchronized关键字保证同步的，这是一种独占锁，也是是悲观锁。
• 对CAS的理解，CAS是一种无锁算法，CAS有3个操作数，内存值V，旧的预期值A，要修改的新值B。当且仅当预期值A和内存值V相同时，将内存值V修改为B，否则什么都不做。
• CAS比较与交换的伪代码可以表示为：

do{
备份旧数据；
基于旧数据构造新数据；
}while(!CAS( 内存地址，备份的旧数据，新数据 ))

• CAS（比较并交换）是CPU指令级的操作，只有一步原子操作，所以非常快

package com.wlw.cas;

import java.util.concurrent.atomic.AtomicInteger;

public class CASDemo {
    //CAS ：compareAndSet() 这个方法的缩写 比较并交换！
    public static void main(String[] args) {
        //原子类的底层运用了CAS
        AtomicInteger atomicInteger = new AtomicInteger(2020);

        // public final boolean compareAndSet(int expect, int update)
        //如果我期望的值达到了，那么就更新，否则，就不更新，CAS是CPU的并发原语!
        System.out.println(atomicInteger.compareAndSet(2020, 2021)); //true
        System.out.println(atomicInteger.get()); //2021 ,atomicInteger的值更新到了2021

        System.out.println(atomicInteger.compareAndSet(2020, 2021)); //false
        System.out.println(atomicInteger.get()); //2021，此时atomicInteger的值是2021，不更新
    }
}

• 我们来看一下compareAndSet() 方法的源码 (AtomicInteger.java文件中)

public final boolean compareAndSet(int expect, int update) {
    return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}

• 再往里走，看一下 unsafe.compareAndSwapInt() 方法 (这是底层的CAS ,Unsafe.class中 )

public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);

1.2unsafe类

• 来理解一下在之前提到的原子类中说到的 unsafe 类
• AtomicInteger中有个执行+1操作的方法 getAndIncrement() ，它的源码如下：

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

• 这里有一个unsafe ，ctrl+左键，点击一下，到 AtomicInteger.java文件中

• 然后我们看一下unsafe.getAndAddInt(this, valueOffset, 1); 这个方法 （点一下到的是C:\Program Files\Java\jdk1.8.0_144\jre\lib\rt.jar!\sun\misc\Unsafe.class中）

• this就是当前对象赋值给var1，valueoffset是内存地址偏移值赋值给var2，1就是要加的值赋值给var4，通过var1和var2获取当前对象在内存中的值赋值给var5，然后通过compareAndSwapInt （CAS比较并交换,这是一个用native修饰的方法）这个方法来判断当前对象的内存地址偏移值中对应的值如果还是var5 （我期望的值），就执行加1。

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

public final native boolean compareAndSwapLong(Object var1, long var2, long var4, long var6);

• 同时，对于Unsafe类中的getAndAddInt这个方法

1.3小结

• CAS：比较当前工作内存中的值 和 主内存中的值，如果这个值是期望的，那么则执行操作！如果不是就一直循环，使用的是自旋锁。
• CAS优点：自带原子性
• CAS缺点：

• 由于使用了自旋锁，循环会耗时；
• 一次性只能保证一个共享变量的原子性；
• 它会存在ABA问题（CAS实现原子操作的问题）

• 说起CAS，就要提ABA问题（狸猫换太子）

二、原子引用类解决ABA问题

2.1ABA问题

在CAS算法中，需要取出内存中某时刻的数据(由用户完成)，在下一时刻比较并交换(CPU保证原子操作)，这个时间差会导致数据的变化。 假设有以下顺序事件： > 1、线程1从内存位置V中取出A > 2、线程2从内存位置V中取出A > 3、线程2进行了写操作，将B写入内存位置V > 4、线程2将A再次写入内存位置V > 5、线程1进行CAS操作，发现V中仍然是A，交换成功

尽管线程1的CAS操作成功，但线程1并不知道内存位置V的数据发生过改变

• 线程1：期望值是1，要把1变成2；
• 而线程2：进行了两个操作：

• 1、对变量A，进行了cas操作，期望值是1，变成3
• 2、之后又进行了一次cas操作，期望是3，变成1

• 所以对于线程1来说，A的值还是1，所以就出现了问题，骗过了线程1；

public class casDemo {
    //CAS : compareAndSet 比较并交换
    public static void main(String[] args) {
        AtomicInteger atomicInteger = new AtomicInteger(2020);
  
        //boolean compareAndSet(int expect, int update)
        //期望值、更新值
        //如果实际值 和 我的期望值相同，那么就更新
        //如果实际值 和 我的期望值不同，那么就不更新
        //===================捣乱的线程=================
        System.out.println(atomicInteger.compareAndSet(2020, 2021));
        System.out.println(atomicInteger.get());
        System.out.println(atomicInteger.compareAndSet(2021, 2020));
        System.out.println(atomicInteger.get());
        
        //===================期望的线程=================
        System.out.println(atomicInteger.compareAndSet(2020, 2021));
        System.out.println(atomicInteger.get());
    }
}

2.2原子引用类解决ABA问题

• 解决ABA问题，对应的思想：就是使用了乐观锁
• java.util.concurrent.atomic 包下有个类 AtomicReference （原子引用类），它有带版本号的 原子操作！，在进行cas操作时，除了比较期望的值以外，还会比较期望的版本号，如果版本号不同，则修改失败

package com.wlw.cas;

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

public class CASDemo02 {
    public static void main(String[] args) {
        AtomicStampedReference<Integer> atomicInteger = new AtomicStampedReference<Integer>(1,1);

        new Thread(()->{
            int stamp = atomicInteger.getStamp(); //获取版本号
            System.out.println("a1=>"+stamp);

            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println(atomicInteger.compareAndSet(1, 2, atomicInteger.getStamp(), atomicInteger.getStamp() + 1));
            System.out.println("a2=>"+atomicInteger.getStamp());

            System.out.println(atomicInteger.compareAndSet(2, 1, atomicInteger.getStamp(), atomicInteger.getStamp() + 1));
            System.out.println("a3=>"+atomicInteger.getStamp());
        },"A").start();

        //乐观锁的原理
        new Thread(()->{
            int stamp = atomicInteger.getStamp(); //获取版本号
            System.out.println("b1=>"+stamp);

            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println(atomicInteger.compareAndSet(1, 6,
                    stamp, atomicInteger.getStamp() + 1)); //输出false，因为版本号不一致
            System.out.println("b2=>"+atomicInteger.getStamp());
        },"B").start();
    }
}
/*
a1=>1
b1=>1
true
a2=>2
true
a3=>3
false
b2=>3
*/