CAS底层原理

不好意思海底捞月

于 2020-10-09 21:49:47 发布

阅读量273

点赞数

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

本文链接：https://blog.csdn.net/m0_38112165/article/details/108987048

版权

Java 同时被 2 个专栏收录

19 篇文章 0 订阅

订阅专栏

多线程

3 篇文章 0 订阅

订阅专栏

CAS

CAS介绍

CAS: compare and swap（compare and exchange），它的含义就是字面的意思——比较并交换，它是CPU并发原语
JDK1.5之后Java引入了Atomic原子类相关方法，这里面很多方法都是以CAS原理实现的
CAS并发原语体现在Java语言中就是sun.misc.Unsafe类的各个方法。调用UnSafe类中的CAS方法，JVM会帮我们实现出CAS汇编指令，这是一种完全依赖于硬件的功能，通过它实现了原子操作，再次强调，由于CAS是一种系统原语，原语属于操作系统应用范畴，是由若干条指令组成，用于完成某个功能的一个过程，并且原语的执行必须是连续的，在执行过程中不允许被中断，也就是说CAS是一条CPU的原子指令，不会造成所谓的数据不一致的问题，也就是说CAS是线程安全的。
CAS 操作包含三个操作数 —— 原值A的内存偏移位置（V）、预期原值（A）和新值(B)。
cas是一种乐观锁，而且是一种非阻塞的轻量级的乐观锁，什么是非阻塞式的呢？其实就是一个线程想要获得锁，对方会给一个回应表示这个锁能不能获得。在资源竞争不激烈的情况下性能高，相比synchronized重量锁，synchronized会进行比较复杂的加锁，解锁和唤醒操作。

CAS过程

下图中CAS(V, A, B)，参数已经在上面介绍，进行比较交换时，通过A的内存偏移地址获取到内存中的A值，判断这个值是否与预期A值相同，如果相同则更新新值为B，否则说明已经有其他线程更新过A的值，假设其他线程将A更新为A1，那么此时的各个参数就变为CAS(V,A1,B)，在执行比较操作，地址V的值是否和A1相同，直到地址V的值和预期原值相同，才更新新值，这是一个自旋锁的过程。
以一个例子来介绍CAS的过程，假设有两个线程Thread1和Thread2都要执行CAS(V,1,2)，具体的执行过程看图内文字。

CAS源码分析

Atomic里面的很多方法都以CAS原理为基础实现的，我们以AtomicInteger为例进行介绍，下面是AtomicInteger的源码

public class AtomicInteger extends Number implements java.io.Serializable {
    private static final long serialVersionUID = 6214790243416807050L;
    // setup to use Unsafe.compareAndSwapInt for updates
    private static final Unsafe unsafe = Unsafe.getUnsafe();
    private static final long valueOffset;

    static {
        try {
            valueOffset = unsafe.objectFieldOffset
                (AtomicInteger.class.getDeclaredField("value"));
        } catch (Exception ex) { throw new Error(ex); }
    }
    private volatile int value;
    public final int getAndIncrement() {
        return unsafe.getAndAddInt(this, valueOffset, 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 boolean compareAndSet(int expect, int update) {
        return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
    }
}

源码中，先实现了一个Unsafe实例，UnSafe类是CAS的核心类，由于Java 方法无法直接访问底层，需要通过本地(native)方法来访问

ValueOffset：它是该变量在内存中的偏移地址,因为UnSafe就是根据内存偏移地址获取数据的，这里后面会有讲到。
value：被volatile修饰,保证了多线程之间的可见性.

native、volitale关键字原理可以看我写的博客：

native关键字作用及底层实现

volitale关键字及底层原理

接下来看一下getAndIncrement()方法，这个方法是将原来的value值加1

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

这个方法调用unsafe里的getAndAddInt()方法，this是接下来我们看一下AtomicInteger里面的compareAndSet方法，这个方法里面的参数this就是咱们的原子类AtomicInteger的实例，valueOffset对应的是预期原值expect的内存偏移地址，‘1’是需要进行加法的值。

下面这个方法就是getAndAddInt()方法里的内容，var1是this对象，var2是内存偏移地址，var4是待计算的值，里面var5就是获取内存中地址var2位置对应的值，var5+var4作为CAS参数中的新值。

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

compareAndSet()方法

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

这里面的参数expect就是预期原值，对应的是AtomicInteger中的value，update就是更新后的新值。这个方法里面调unsafe的compareAndSwapInt()方法，仔细一看前面不就是CAS的单词么，接下来看一下unsafe.compareAndSwapInt（）方法的定义。

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

这个方法是native关键字定义的，在这里这个方法的实现是由C++实现的，我们可以在网上找到C++的实现代码

UNSAFE_ENTRY(jboolean, Unsafe_CompareAndSetInt(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jint e, jint x)) {
    oop p = JNIHandles::resolve(obj);
    //获取对象的变量的地址
    jint* addr = (jint *)index_oop_from_field_offset_long(p, offset);
    //调用Atomic操作
    return (jint)(Atomic::cmpxchg(x, addr, e)) == e;
} UNSAFE_END

最后发现是调用了cmpxchg方法

inline jint     Atomic::cmpxchg    (jint     exchange_value, volatile jint*     dest, jint     compare_value) {
  int mp = os::is_MP();
  __asm__ volatile (LOCK_IF_MP(%4) "cmpxchgl %1,(%3)"
                    : "=a" (exchange_value)
                    : "r" (exchange_value), "a" (compare_value), "r" (dest), "r" (mp)
                    : "cc", "memory");
  return exchange_value;
}

可以看到有一个(LOCK_IF_MP(%4) "cmpxchgl %1,(%3)"指令，这里面的LOCK_IF_MP()方法的意思是如果mp（multi processor）为true就lock，也就是多核时为true进行加锁，来实现被修饰指令的原子性，单核就不必加锁。

所以最终汇编调用的指令是lock cmpxchg，这条指令就是对比较替换进行加锁，在替换值的同时不允许其他CPU去修改。

CAS存在的问题及解决办法

ABA问题

问题介绍：执行一次比较时，地址V对应的值是A，与预期值相同，但是在这期间A已经被其他线程改为B，又被一个线程改回A，那么CAS仍然会更新值。也就是说当你获得对象当前数据后，在准备修改为新值前，对象的值被其他线程连续修改了两次，而经过两次修改后，对象的值又恢复为旧值，这样当前线程无法正确判断这个对象是否修改过。

解决办法：JDK1.5可以利用AtomicStampedReference类来解决这个问题，AtomicStampedReference内部不仅维护了对象值，还维护了一个时间戳，相当于添加了一个版本号。当AtomicStampedReference对应的数值被修改时，除了更新数据本身外，还必须要更新时间戳，对象值和时间戳都必须满足期望值，写入才会成功

自旋时间太长的问题

问题介绍：CAS()长时间处于自旋状态，给CPU带来巨大开销

解决办法：JVM支持处理器提供的pause指令，使得效率会有一定的提升

pause指令有两个作用：

第一它可以延迟流水线执行指令,使CPU不会消耗过多的执行资源，
第二它可以避免在退出循环的时候因内存顺序冲突（memory order violation）而引起CPU流水线被清空（CPU pipeline flush），从而提高CPU的执行效率。

CAS只能实现一个变量的原子操作，不能同时实现多个变量的原子操作

问题介绍：CAS()执行时，执行实现一个变量的原子操作，当同时需要对多个变量进行原子操作时，无法实现

解决办法：从Java1.5开始JDK提供了AtomicReference类来保证引用对象之间的原子性，你可以把多个变量放在一个对象里来进行CAS操作。

CAS使用的时机

线程数较少、等待时间短可以采用自旋锁进行CAS尝试拿锁，较于synchronized高效
线程数较大、等待时间长，不建议使用自旋锁，占用CPU较高

参考链接：
https://www.cnblogs.com/youngdeng/p/12869037.html
https://blog.csdn.net/lixinkuan328/article/details/94319775
http://www.mamicode.com/info-detail-2891978.html