Java并发编程之CAS（比较并交换）

最新推荐文章于 2023-04-09 15:52:35 发布

是田同学啊

最新推荐文章于 2023-04-09 15:52:35 发布

阅读量428

点赞数

分类专栏： Java并发编程文章标签： java 多线程并发编程

本文链接：https://blog.csdn.net/qq_43318391/article/details/113730892

版权

Java并发编程专栏收录该内容

4 篇文章 0 订阅

订阅专栏

文章目录

1、compareAndSet方法

先以AtomicInteger为例看源码：

/**
     * Atomically sets the value to the given updated value
     * if the current value {@code ==} the expected value.
     *
     * @param expect the expected value
     * @param update the new value
     * @return {@code true} if successful. False return indicates that
     * the actual value was not equal to the expected value.
     */
    public final boolean compareAndSet(int expect, int update) {
        return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
    }

该原子类中的方法 compareAndSet(expect, update) 作用是：如果主物理内存的值与期望值 expect 相同，则将工作内存的值修改为 update 值后写回主物理内存，并且方法返回 true ；反之如果主物理内存的值与期望值不同，则本次修改不成功，方法返回 false 。

public class CASDemo1 {
    public static void main(String[] args) {
        AtomicInteger atomicInteger = new AtomicInteger(5);
        System.out.println(atomicInteger.compareAndSet(5, 6) + "\t atomicInteger的值为" +atomicInteger);
        System.out.println(atomicInteger.compareAndSet(5, 7)+ "\t atomicInteger的值为" +atomicInteger);
    }
}

运行结果如下：

true	 atomicInteger的值为6
false	 atomicInteger的值为6

2、Unsafe类

从上面的源码中可以看到，compareAndSet 方法中调用了 unsafe 对象的 compareAndSwapInt 方法，而这个 unsafe 对象是属于 Unsafe 类。

在 Java关键字之volatile 这篇文章里面有提到采用 AtomicInteger.getAndIncrement() 可以解决 n++ 带来的线程不安全问题，之所以能保证操作的原子性，也是因为调用了底层的 Unsafe类。

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

Unsafe 类是CAS核心类，由于Java方法无法直接访问底层系统，需要通过本地（native）方法来访问，Unsafe相当于一个后门，基于该类可以直接操作特定内存数据。Unsafe类存在于sun.misc包中，其内部方法操作可以像C的指针一样直接操作内存，因为Java中CAS操作的执行依赖于Unsafe类的方法。

Unsafe类中的所有方法都是native修饰的，也就是说Unsafe类中的方法都直接调用操作系统底层资源执行相应任务

unsafe.getAndAddInt(this, valueOffset, 1) 中的 valueOffset 是该变量值在内存中的 地址偏移量 ，Unsafe 直接通过地址来精确获取内存数据，从而保证了线程安全。

/*Unsafe类中的方法，var1 是操作的对象，如AtomicInteger对象
var2 是对象的地址偏移量
var4 是需要变动的数据大小，在getAndIncrement方法中就是固定为1，即加一
var5 是通过var1 var2找出的主内存中真实的值

如果var2 地址对应的值与var5相同，则对对象var1进行加var4操作后返回；
如果不同，则一直循环取值比较直到成功
*/
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;
    }

3、CAS是什么

CAS全称呼Compare-And-Swap，它是一条CPU并发原语。

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

CAS并发原语体现在JAVA语言中就是sun.misc.Unsafe类中各个方法。调用Unsafe类中的CAS方法，JVM会帮我们实现CAS汇编指令。这是一种完全依赖于硬件的功能，通过他实现了原子操作。由于CAS是一种系统原语，原语属于操作系统用语范畴，是由若干条指令组成的，用于完成某个功能的一个过程，并且原语的执行必须是连续的，在执行过程中不允许被中断，也就是说CAS是一条CPU的原子指令，不会造成数据不一致问题。

在上面的 getAndAddInt 方法中就采用了CAS进行值的修改，保证数据的线程安全性问题。

举例：

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

AtomicInteger里面的value原始值为3，即主内存中AtomicInteger的value为3，根据JMM模型，线程A和线程B各自持有一份值为3的value的副本分别到各自的工作内存。
线程A通过getIntVolatile(var1, var2)拿到value值3，这时线程A被挂起。
线程B也通过getlntVolatile(var1, var2)方法获取到value值3，此时刚好线程B没有被挂起并执行compareAndSwaplnt方法比较内存值也为3，成功修改内存值为4，线程B打完收工，一切OK。
这时线程A恢复，执行compareAndSwapInt方法比较，发现自己手里的值数字3和主内存的值数字4不一致，说明该值已经被其它线程抢先一步修改过了，那A线程本次修改失败，只能重新读取重新来一遍了。
线程A重新获取value值，因为变量value被volatle修饰，所以其它线程对它的修改，线程A总是能够看到，线程A继续执行compareAndSwapInt进行比较替换，直到成功。
```
private volatile int value;		//AtomicInteger类中value被volatile修饰
```

4、CAS优缺点

优点：

与 synchronized 相比来说，采用CAS可以提高并发量，因为它并没有加锁，允许多个线程同时访问。

缺点：

可能出现循环时间长导致比较大的开销（自旋锁）
由于CAS是一个do…while循环，如果比较不成功，则会持续进行取值比较，这样会给CPU带来很大的开销。
只能保证一个共享变量的原子操作
对多个共享变量操作时，循环CAS无法保证操作的原子性，这个时候就只能通过加锁来保证原子性。
引发ABA问题

5、CAS存在的ABA问题

5.1 ABA的产生

CAS算法实现一个重要前提需要去除内存中某个时刻的数据并在当下时刻比较并替换，那么在这个时间差类会导致数据的变化。

比如线程1从内存位置V取出A，线程2同时也从内存取出A，并且线程2进行一些操作将值改为B，然后线程2又将V位置数据改成A，这时候线程1进行CAS操作发现内存中的值依然时A，然后线程1操作成功。

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

5.2 原子引用

JDK已经提供了基本类型数据的原子类，如果自定义类也需要是原子的，那么可以通过原子引用类 AtomicReference 来实现。

代码如下：

//自定义Person类
public class Person {

    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
 //省略Get/Set和toString()   
}

public class AtomicReferenceDemo {
    public static void main(String[] args) {
        
        Person p1 = new Person("zhangsan", 19);
        Person p2 = new Person("lisi", 30);

        AtomicReference<Person> reference = new AtomicReference<>();
        reference.set(p1);
        System.out.println(reference.compareAndSet(p1, p2) + "\t" + reference.get());
        System.out.println(reference.compareAndSet(p1, p2) + "\t" + reference.get());
    }
}

输出结果：

true	Person{name='lisi', age=30}
false	Person{name='lisi', age=30}

5.2 ABA的解决办法

采用带有版本号的原子引用类可以彻底解决ABA问题，相当于为每次的CAS操作添加一个时间戳认证。

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

        AtomicInteger atomicInteger = new AtomicInteger(10);
        AtomicStampedReference stampedReference = new AtomicStampedReference(10, 1);

        System.out.println("***********ABA产生************");

        new Thread(()->{
            System.out.println(atomicInteger.compareAndSet(10, 20) + "\t 线程A把atomicInteger的值修改为" + atomicInteger);
            System.out.println(atomicInteger.compareAndSet(20, 10)+ "\t 线程A把atomicInteger的值修改为" + atomicInteger);
        },"A").start();

        new Thread(()->{
            //暂停3秒线程，确保atomicInteger经过了线程A的两次修改
            try { TimeUnit.SECONDS.sleep(2); } catch (InterruptedException e) { e.printStackTrace(); }
            System.out.println(atomicInteger.compareAndSet(10, 30) + "\t 线程B把atomicInteger的值修改为" + atomicInteger);
        },"B").start();

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

        System.out.println("\n\n***********ABA解决************");
        new Thread(()->{
            int stamp1 = stampedReference.getStamp();    //获取到初始版本号
            System.out.println(Thread.currentThread().getName() + "线程第一次拿到的版本号" + stamp1);
            //暂停1秒钟，确保线程D也能拿到初始版本号
            try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }
            stampedReference.compareAndSet(10, 20, stamp1, stamp1 + 1);
            System.out.println(Thread.currentThread().getName() + "线程第一次修改stampedReference为20，当前版本号为" + stampedReference.getStamp());
            stampedReference.compareAndSet(20, 10, stampedReference.getStamp(), stampedReference.getStamp() + 1);
            System.out.println(Thread.currentThread().getName() + "线程第二次修改stampedReference为10，当前版本号为" + stampedReference.getStamp());
        },"C").start();

        new Thread(()->{
            int stamp1 = stampedReference.getStamp();    //获取到初始版本号
            System.out.println(Thread.currentThread().getName() + "线程第一次拿到的版本号" + stamp1);
            //暂停3秒钟确保线程C完成一次ABA操作
            try { TimeUnit.SECONDS.sleep(3); } catch (InterruptedException e) { e.printStackTrace(); }
            boolean b = stampedReference.compareAndSet(10, 30, stamp1, stampedReference.getStamp() + 1);
            System.out.println(Thread.currentThread().getName() + "线程第二次获取到的版本号为" + stampedReference.getStamp());
            System.out.println(Thread.currentThread().getName() + "线程第一次修改stampedReference的值为30" + (b ? "成功" : "失败"));
        },"D").start();

    }
}

运行结果：

从下面的运行结果来看，采用带有版本号的原子引用类就能有效解决ABA问题了。

***********ABA产生************
true	 线程A把atomicInteger的值修改为20
true	 线程A把atomicInteger的值修改为10
true	 线程B把atomicInteger的值修改为30


***********ABA解决************
C线程第一次拿到的版本号1
D线程第一次拿到的版本号1
C线程第一次修改stampedReference为20，当前版本号为2
C线程第二次修改stampedReference为10，当前版本号为3
D线程第二次获取到的版本号为3
D线程第一次修改stampedReference的值为30失败