深入理解CAS

Ascend1797

已于 2023-04-19 16:02:23 修改

阅读量96

点赞数

分类专栏：并发编程文章标签： java 开发语言

于 2023-04-19 16:01:11 首次发布

本文链接：https://blog.csdn.net/Ascend1977/article/details/130245647

版权

并发编程专栏收录该内容

12 篇文章 2 订阅

订阅专栏

CAS（CompareandSwap）是一种乐观锁技术，常用于实现线程安全的原子操作。它包括比较和交换两个阶段，只有当内存地址的值与期望值相同时才会更新。Java中的Atomic类利用CAS来实现线程安全，但存在ABA问题、自旋开销和并发度限制。解决这些问题的方法包括使用带版本号的CAS和调整自旋策略等。

摘要由CSDN通过智能技术生成

什么是CAS

CAS（Compare and Swap，比较并交换）是一种乐观锁技术，用于实现多线程环境下的原子操作。CAS操作包括三个参数：内存地址V、期望值A和新值B。当且仅当V的值等于A时，才将V的值设置为B，否则什么也不做。即针对一个变量，首先比较它的内存值与某个期望值是否相同，如果相同，就给它赋一个新值。

CAS 的逻辑用伪代码描述如下：

if (value == expectedValue){
     2 value = newValue; 3
}

以上伪代码描述了一个由比较和赋值两阶段组成的复合操作。

CAS操作是由硬件指令支持的，因此具有很高的性能和安全性。在Java中，CAS操作通常使用Atomic类来实现，例如AtomicInteger、AtomicLong、AtomicReference等。

CAS操作可以用于解决多线程环境下的竞态条件问题，例如计数器、队列、缓存等数据结构的实现。但是，CAS操作也存在一些限制，例如ABA问题、自旋开销大、并发度不高等，需要在使用时进行注意和处理。

CAS应用

在Java中，CAS操作是由Unsafe类提供支持的。Unsafe类是JDK中不稳定、不建议使用的类，但是它提供了一些底层操作方法，如CAS操作，用于支持Java并发编程。

Unsafe类提供了几种针对不同类型变量的CAS操作，包括：

compareAndSwapObject(Object obj, long offset, Object expect, Object update)：用于对象引用类型的CAS操作。
compareAndSwapInt(Object obj, long offset, int expect, int update)：用于整型类型的CAS操作。
compareAndSwapLong(Object obj, long offset, long expect, long update)：用于长整型类型的CAS操作。

它们都是 native 方法，由 Java 虚拟机提供具体实现，这意味着不同的 Java 虚拟机对它们的实现可能会略有不同。

CAS操作通常通过Atomic类来实现，例如AtomicInteger、AtomicLong、AtomicReference等。这些类提供了一系列原子操作方法，可以保证线程安全地进行加减、比较、设置等操作。

以下是一些常见的CAS操作方法：

compareAndSet(expectedValue, newValue)：如果当前值等于期望值，则将其设置为新值，并返回true；否则不做任何事情，并返回false。
getAndIncrement()：获取当前值，并将其增加1，返回增加前的值。
getAndAdd(delta)：获取当前值，并将其增加delta，返回增加前的值。
getAndSet(newValue)：获取当前值，并将其设置为新值，返回设置前的值。

这些方法都是原子操作，可以确保线程安全。需要注意的是，在使用CAS操作时有可能会出现ABA问题（即在操作过程中值先被A修改成B，再被B修改成A），因此需要根据具体情况进行评估和处理。

CAS缺陷

ABA问题：如果一个值在执行CAS操作前后都被改为了相同的值，那么CAS就可能误认为它没有发生改变。这种情况称为ABA问题。

@Slf4j
public class ABATest {

    public static void main(String[] args) {
        AtomicInteger atomicInteger = new AtomicInteger(1);

        new Thread(()->{
            int value = atomicInteger.get();
            log.debug("Thread1 read value: " + value);

            // 阻塞1s
            LockSupport.parkNanos(1000000000L);

            // Thread1通过CAS修改value值为3
            if (atomicInteger.compareAndSet(value, 3)) {
                log.debug("Thread1 update from " + value + " to 3");
            } else {
                log.debug("Thread1 update fail!");
            }
        },"Thread1").start();

        new Thread(()->{
            int value = atomicInteger.get();
            log.debug("Thread2 read value: " + value);
            // Thread2通过CAS修改value值为2
            if (atomicInteger.compareAndSet(value, 2)) {
                log.debug("Thread2 update from " + value + " to 2");

                // do something
                value = atomicInteger.get();
                log.debug("Thread2 read value: " + value);
                // Thread2通过CAS修改value值为1
                if (atomicInteger.compareAndSet(value, 1)) {
                    log.debug("Thread2 update from " + value + " to 1");
                }
            }
        },"Thread2").start();
    }