CAS原理

最新推荐文章于 2025-05-02 08:35:56 发布

原创最新推荐文章于 2025-05-02 08:35:56 发布 · 321 阅读

0 ·

CC 4.0 BY-SA版权

Java 专栏收录该内容

53 篇文章

订阅专栏

CAS（Compare and Swap）是一种保证原子性的系统原语，常用于实现无锁编程。JDK的Atomic类通过CAS实现原子操作，但存在只能保证单个共享变量原子性、循环时间长开销大和ABA问题等缺点。Java并发包（concurrent）利用CAS和volatile实现线程间通信和同步，解决ABA问题的方法包括AtomicStampedReference和AtomicMarkableReference。

CAS

CAS（Compare and Swap）有3个操作数，内存值V，旧的预期值A，要修改的新值B。当且仅当预期值A和内存值V相同时，将内存值V修改为B，否则什么都不做。CAS是一种系统原语，原语属于操作系统用于范畴，是由若干条指令组成，用于完成某个功能的一个过程,并且原语的执行必须是连续的，在执行过程中不允许中断，即CAS是一条原子指令，不会造成所谓的数据不一致的问题。
JDK里面提供了很多atomic类，它们是通过CAS完成原子性。对于AtomicInteger的incrementAndGet()方法：
在这里插入图片描述
再看Unsafe类的getAndAddInt()方法：

这里面调用了Unsafe类中的compareAndSwapInt()方法：

compareAndSwapInt()希望达到的目标是对于var1对象，如果当前的值var2和底层的值var5相等，那么把它更新成后面的值（var5+var4） compareAndSwapInt核心就是CAS核心。

CAS通过调用JNI的代码实现的，而compareAndSwapInt是借助C++来调用CPU底层指令实现的。Unsafe中对CAS的实现底层调用了Atomic::cmpxchg方法。程序会根据当前处理器的类型来决定是否为cmpxchg指令添加lock前缀。如果程序是在多处理器上运行，就为cmpxchg指令加上lock前缀（lock cmpxchg）。反之，如果程序是在单处理器上运行，就省略lock前缀（单处理器自身会维护单处理器内的顺序一致性，不需要lock前缀提供的内存屏障效果）。

CAS的缺点

只能保证一个共享变量的原子操作
当对一个共享变量执行操作时，可以使用循环CAS的方式来保证原子操作，但是对多个共享变量操作时，循环CAS就无法保证操作的原子性，这个时候就可以用锁。从Java1.5开始JDK提供了AtomicReference类来保证引用对象之间的原子性，可以把多个变量放在一个对象里来进行CAS操作
循环时间长开销大
自旋CAS如果长时间不成功，会给CPU带来非常大的执行开销
ABA问题
因为CAS需要在操作值的时候检查下值有没有发生变化，如果没有发生变化则更新，但是如果一个值原来是A，变成了B，又变成了A，那么使用CAS进行检查时会发现它的值没有发生变化，但是实际上却变化了。ABA问题的解决思路就是使用版本号。在变量前面追加上版本号，每次变量更新的时候把版本号加一，那么A－B－A 就会变成1A-2B－3A
从Java1.5开始JDK的atomic包里提供了一个类AtomicStampedReference来解决ABA问题。
AtomicStampedReference里的compareAndSet()实现：

而在AtomicInteger里compareAndSet()实现：

AtomicStampedReference的compareAndSet方法作用是首先检查当前引用是否等于预期引用，并且当前标志是否等于预期标志，如果全部相等，则以原子方式将该引用和该标志的值设置为给定的更新值

concurrent包的实现

Java的CAS会使用现代处理器上提供的高效机器级别原子指令，这些原子指令以原子方式对内存执行读-改-写操作，这是在多处理器中实现同步的关键。同时，volatile变量的读/写和CAS可以实现线程之间的通信。把这些特性整合在一起，就形成了整个concurrent包得以实现的基石。对于concurrent包的源代码实现，会发现一个通用化的实现模式：

首先，声明共享变量为volatile
然后，使用CAS的原子条件更新来实现线程之间的同步
同时，配合以volatile的读/写和CAS所具有的volatile读和写的内存语义来实现线程之间的通信

AQS，非阻塞数据结构和原子变量类（java.util.concurrent.atomic包中的类），这些concurrent包中的基础类都是使用这种模式来实现的，而concurrent包中的高层类又是依赖于这些基础类来实现的。从整体来看，concurrent包的实现示意图如下：
在这里插入图片描述

JUC包中Atomic实现

操作基本类型的原子类有3个：AtomicInteger(操作int类型)、AtomicLong(操作long类型)、AtomicBoolean(操作boolean类型)，都用CAS+volatile关键字实现原子操作。在AtomicInteger的源码中持有一个int类型变量value private volatile int value;，同理AtomicLong和AtomicBoolean也持有它们各自的对应的基本类型变量value。

Java 8的AtomicInteger源码的addAndGet(int delta)方法中的唯一一句代码是unsafe调用了方法getAndAddInt并将方法的返回值（先get再add说明返回的是value）加上delta得到的值作为最终返回结果。

public final int addAndGet(int delta) {
    return unsafe.getAndAddInt(this, valueOffset, delta) + delta;
}

Java 7的AtomicInteger源码的addAndGet方法：

public final int addAndGet(int delta) {
    for (;;) {
        //获取value值赋值给current
        int current = get();
        //将current值（这个可能不会等于value值，因为可能value值已经被其它线程修改）加上delta并赋值给next
        int next = current + delta;
        //比较并设置成功的话就返回结果next，不然又会再次循环
        if (compareAndSet(current, next))
            return next;
    }
}

（1）首先第一步获取value值，并赋值给current，get方法返回value，value被volatile关键字修饰了嘛，说明此时get方法获取到的value一定是最新的

public final int get() {
    return value;
}

（2）然后第二步是，将current加上delta并赋值给next，这里需要注意的是，此时的current可能不会等于value，因为value可能已经被其它线程修改

（3）然后第三步，先来看一下compareAndSet方法

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

这个方法用到了Unsafe的compareAndSwapInt函数。这个方法的作用就是，如果当前AtomicInteger持有的value值等于expect，则将value值设置成update，并返回true，不然就什么都不做返回false。如果compareAndSet方法返回的是true，说明value并没有被其它线程所修改，说此时操作的结果是正确的，即current的值还是等于value的，所以current + delta的结果就是我们想要的，所以直接返回结果。如果是false话，for (;;)自旋开始下一次尝试

操作基本类型的原子类，它们的内部都维护者一个对应的基本类型的成员变量value，这个变量是被volatile关键字修饰的，这可以保证每次一个线程要使用它都会拿到最新的值。然后Unsafe类的CAS函数，一些原子操作就是通过自旋方式，不断地使用CAS函数进行尝试直到达到自己的目的。

ABA问题的解决方法
使用AtomicMarkableReference，AtomicStampedReference。使用上述两个Atomic类进行操作，它们在实现compareAndSet指令的时候除了要比较对象的当前值和预期值以外，还要比较当前（操作的）戳值和预期（操作的）戳值，当全部相同时，compareAndSet方法才能成功。每次更新成功，戳值都会发生变化，戳值的设置是由编程人员自己控制的。对于AtomicMarkableReference而言，戳值是一个布尔类型的变量，而AtomicStampedReference中戳值是一个整型变量。

public boolean compareAndSet(V  expectedReference, V  newReference, 
                            int expectedStamp,int newStamp) {
    Pair<V> current = pair;
    return  expectedReference == current.reference && 
            expectedStamp == current.stamp &&
            ((newReference == current.reference && newStamp == current.stamp) || 
            casPair(current, Pair.of(newReference, newStamp)));
}

这时的compareAndSet 方法需要四个参数expectedReference, newReference, expectedStamp, newStamp，在使用这个方法时要保证期望的戳值和要更新戳值不能一样，通常 newStamp = expectedStamp + 1。注意，由于compareAndSet只能一次改变一个值，无法同时改变newReference和newStamp，所以在实现的时候，在内部定义了一个类Pair类将newReference和newStamp变成一个对象，进行CAS操作的时候，实际上是对Pair对象的操作

private static class Pair<T> {
    final T reference;
    final int stamp;
    private Pair(T reference, int stamp) {
        this.reference = reference;
        this.stamp = stamp;
    }
    static <T> Pair<T> of(T reference, int stamp) {
        return new Pair<T>(reference, stamp);
    }
}