CAS实现原理

不羁的fang少年

已于 2024-02-05 17:34:28 修改

阅读量1.4k

点赞数 1

分类专栏： java后端文章标签：后端 java

于 2019-11-02 00:06:19 首次发布

本文链接：https://blog.youkuaiyun.com/qq_27610647/article/details/102865747

版权

java后端专栏收录该内容

28 篇文章

订阅专栏

1，什么是CAS

CAS（Compare and Swap）是无锁化编程的常用方法。CAS 实现了区别于 sychronized 同步锁的一种乐观锁。

2，作用

（1）当线程尝试使用 CAS 同时更新同一个变量时，只有其中一个线程能更新变量的值，而其它线程都失败，失败的线程并不会被挂起，而是被告知这次竞争中失败，并可以再次尝试。

（2）CAS 有 3 个操作数，内存值 V（主线程中共享变量的值），旧的预期值 A（JWM中变量的值），要修改后的新值 B。当且仅当预期值 A 和内存值 V 相同时，将内存值 V 修改为 B，否则什么都不做。其实 CAS 也算是有锁操作，只不过是由 CPU 来触发，比 synchronized 性能好的多。CAS 是非阻塞算法的一种常见实现。

3，实现原理

一个线程间共享的变量，首先在主存中会保留一份，然后每个线程的工作内存也会保留一份副本。这里说的预期值，就是线程保留的副本。当该线程从主存中获取该变量的值后，主存中该变量可能已经被其他线程刷新了，但是该线程工作内存中该变量却还是原来的值，这就是所谓的预期值了。当你要用 CAS刷新该值的时候，如果发现线程工作内存和主存中不一致了，就会失败，如果一致，就可以更新成功。

4，JUC（java.util.concurrent）

java.util.concurrent.Atomic 包提供了一系列原子类。这些类可以保证多线程环境下，当某个线程在执行 atomic 的方法时，不会被其他线程打断，而别的线程就像自旋锁一样，一直等到该方法执行完成，才由 JVM 从等待队列中选择一个线程执行。Atomic 类在软件层面上是非阻塞的，它的原子性其实是在硬件层面上借助相关的指令来保证的。

5，案例

AtomicInteger 来研究在没有锁的情况下是如何做到数据正确性的：
来看看++i 是怎么做到的。

public final int incrementAndGet() {
    for (;;) {
        int current = get();
        int next = current + 1;
        if (compareAndSet(current, next))
            return next;
    }
}

在这里采用了 CAS 操作，每次从内存中读取数据然后将此数据和+1 后的结果进行 CAS 操作，如果成功就返回结果，否则重试直到成功为止。而 compareAndSet 利用 JNI 来完成 CPU 指令的操作，非阻塞算法。

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

其中，unsafe.compareAndSwapInt（）是一个 native 方法，正是调用CAS 原语完成该操作。首先假设有一个变量 i，i 的初始值为 0。每个线程都对 i 进行+1 操作。CAS是这样保证同步的：假设有两个线程，线程 1 读取内存中的值为 0，current = 0，next = 1，然后挂起，线程 2 对 i 进行操作，将 i 的值变成了 1（即主内存的i值为 1 ）。线程 2 执行完，回到线程 1，进入 if 里的 compareAndSet 方法，该方法进行的操作的逻辑是，（1）如果操作数的值在内存中没有被修改，返回 true，然后 compareAndSet 方法返回 next 的值（2）如果操作数的值在内存中被修改了，则返回 false，重新进入下一次循环（重新从主内存中读取），重新得到 current 的值为 1，next 的值为 2，然后再比较，由于这次没有被修改，所以直接返回 2。

那么，为什么自增操作要通过 CAS 来完成呢？仔细观察
incrementAndGet()方法，发现自增操作其实拆成了两步完成的：
int current = get();
int next = current + 1;
由于 volatile 只能保证读取或写入的是最新值，那么可能出现以下情况：
1.A 线程执行 get()操作，获取 current 值（假设为 1）
2.B 线程执行 get()操作，获取 current 值（为 1）
3.B 线程执行 next = current + 1 操作，next = 2
4.A 线程执行 next = current + 1 操作，next = 2
这样的结果明显不是我们想要的，即volatile不具备原子性。所以，自增操作必须采用 CAS 来完成。

6，CAS的优缺点

CAS 由于是在硬件层面保证的原子性，不会锁住当前线程，它的效率是很高的。但是它依然存在三个问题。
(1)ABA 问题
CAS 在操作值的时候检查值是否已经变化，没有变化的情况下才会进行更新。但是如果一个值原来是 A，变成 B，又变成 A，那么 CAS 进行检查时会认为这个值没有变化，操作成功。ABA 问题的解决方法是使用版本号。在变量前面追加上版本号，每次变量更新的时候把版本号加一，那么 A－B－A就变成 1A-2B－3A。从 Java1.5 开始 JDK 的 atomic 包里提供了一个类AtomicStampedReference 来解决 ABA 问题。这个类的 compareAndSet 方法作用是首先检查当前引用是否等于预期引用，并且当前标志是否等于预期标志，如果全部相等，则以原子方式将该引用和该标志的值设置为给定的更新值。CAS 算法实现一个重要前提是需要取出内存中某时刻的数据，而在下一时刻把取出后的数据和内存中原始数据比较并替换，那么在这个时间差内会导致数据的变化。比如说一个线程 one 从内存位置 V 中取出 A，这时候另一个线程 two 也从内存中取出 A，并且 two 进行了一些操作变成了 B，然后 two 又将 V 位置的数据变成 A，这时候线程 one 进行 CAS 操作发现内存中仍然是 A，然后 one 操作成功。尽管线程 one 的 CAS 操作成功，但是不代表这个过程就是没有问题的。如果链表的头在变化了两次后恢复了原值，但是不代表链表就没有变化。因此前面提到的原子操作AtomicStampedReference/AtomicMarkableReference 就很有用了。这允
许一对变化的元素进行原子操作。
ABA解决方案
ABA 问题带来的隐患，各种乐观锁的实现中通常都会用版本号 version 来对记录或对象标记，避免并发操作带来的问题。在 Java 中，AtomicStampedReference<E>也实现了这个作用，它通过包装[E,Integer]的元组来对对象标记版本戳 stamp，从而避免 ABA 问题。
(2)循环时间长开销大
自旋 CAS 如果长时间不成功，会给 CPU 带来非常大的执行开销。因此 CAS 不适合竞争十分频繁的场景。
(3)只能保证一个共享变量的原子操作
当对一个共享变量执行操作时，我们可以使用循环 CAS 的方式来保证原子操作，但是对多个共享变量操作时，循环CAS 就无法保证操作的原子性，这个时候就可以用锁。这里粘贴一个，模拟 CAS 实现的计数器：

class SimilatedCAS {
    private int value;
    public int getValue() {
        return value;
    }
    // 这里只能用 synchronized 了,毕竟无法调用操作系统的 CAS
    public synchronized boolean compareAndSwap(int expectedValue, int newValue) {
        if (value == expectedValue) {
            value = newValue;
            return true;
        }
        return false;
    }
}
public class CASCount implements Runnable {
    private SimilatedCAS counter = new SimilatedCAS();

    public void run() {
        for (int i = 0; i < 10000; i++) {
            System.out.println(this.increment());
        }
    }

    public int increment() {
        int oldValue = counter.getValue();
        int newValue = oldValue + 1;
        while (!counter.compareAndSwap(oldValue, newValue)) {
            //如果 CAS 失败,就去拿新值继续执行 CAS
            oldValue = counter.getValue();
            newValue = oldValue + 1;
        }
        return newValue;
    }
    public static void main(String[] args) {
        Runnable run = new CASCount();
        new Thread(run).start();
        new Thread(run).start();
        new Thread(run).start();
        new Thread(run).start();
        new Thread(run).start();
    }
}

实例：

如果我们使用两个循环CAS操作来实现这一点，可能会遇到以下问题：