2023面试高手

这个屌丝很懒，什么也没留下！

热门标签

深入理解CAS_cas cdsn

作者：2023面试高手 | 2024-03-23 07:19:14

踩

cas cdsn

1、什么是CAS?

CAS（Compare And Swap，比较并交换），通常指的是这样一种原子操作：针对一个变量，首先比较它的内存值与某个期望值是否相同，如果相同，就给它赋一个新值。 CAS 的逻辑用伪代码描述如下：


if (value == expectedValue) { // 1-比较
    value = newValue;  // 2-交换
}

以上伪代码描述了一个由比较和赋值两阶段组成的复合操作，CAS 可以看作是它们合并后的整体。所以CAS是一个不可分割的原子操作，并且其原子性直接在硬件层面得到保障。

同时CAS可以看做是乐观锁（对比数据库的悲观、乐观锁）的一种实现方式，Java原子类中的递增操作就通过CAS自旋实现的。 CAS是一种无锁算法，在不使用锁（没有线程被阻塞）的情况下实现多线程之间的变量同步。// 用户模式下的线程同步，非内核模式

2、使用Java中的CAS

在 Java 中，CAS 操作由 Unsafe 类提供支持，该类定义了三种针对不同类型变量的 CAS 操作，如图

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

以 compareAndSwapInt 为例，Unsafe 的 compareAndSwapInt 方法接收 4 个参数，分别是：对象实例、内存偏移量、字段期望值、字段新值。该方法会针对指定对象实例中的相应偏移量的字段执行 CAS 操作。

用户使用Java中的CAS，需要通过反射获取Java中的 Unsafe 对象，用来执行CAS操作


public class UnsafeFactory {
    /**
     * 通过反射获取 Unsafe 对象
     * @return
     */
    public static Unsafe getUnsafe() {
        try {
            // 获取私有属性值 private static final Unsafe theUnsafe;
            Field field = Unsafe.class.getDeclaredField("theUnsafe");
            field.setAccessible(true); // 设置私有属性可以访问
            return (Unsafe) field.get(null); // 获取属性值
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
 
    /**
     * 获取字段的内存偏移量
     * @param unsafe
     * @param clazz
     * @param fieldName
     * @return
     */
    public static long getFieldOffset(Unsafe unsafe, Class clazz, String fieldName) {
        try {
            return unsafe.objectFieldOffset(clazz.getDeclaredField(fieldName));
        } catch (NoSuchFieldException e) {
            throw new Error(e);
        }
    }
}

尝试对一个对象的属性进行三次CAS更改，分别试图将它从 0 改成 3、从 3 改成 5、从 3 改成 8


public class CASTest {
 
    public static void main(String[] args) {
 
        EntityObject object = new EntityObject();
 
        Unsafe unsafe = UnsafeFactory.getUnsafe();
        // 获取偏移量
        long offset = UnsafeFactory.getFieldOffset(unsafe, EntityObject.class, "num");
 
        boolean successful;
 
        // 4个参数分别是：对象实例、字段的内存偏移量、字段期望值(比较值)、字段更新值
        // 对象实例+内存偏移量 定位内存地址
        successful = unsafe.compareAndSwapInt(object, offset, 0, 3);// 第一次更改
        System.out.println("是否正确修改:" + successful + " 属性的值:" + object.num);
 
        successful = unsafe.compareAndSwapInt(object, offset, 3, 5);// 第二次更改
        System.out.println("是否正确修改:" + successful + " 属性的值:" + object.num);
 
        successful = unsafe.compareAndSwapInt(object, offset, 3, 8);// 第三次更改
        System.out.println("是否正确修改:" + successful + " 属性的值:" + object.num);
    }
}
 
// 被测试对象
class EntityObject{
    int num;
}

3、CAS源码分析

Hotspot 虚拟机对 compareAndSwapInt 方法的实现如下：


#unsafe.cpp 
UNSAFE_ENTRY(jboolean, Unsafe_CompareAndSwapInt(JNIEnv *env, jobject unsafe, jo bject obj, jlong offset, jint e, jint x)) 
    UnsafeWrapper("Unsafe_CompareAndSwapInt"); 
    oop p = JNIHandles::resolve(obj); 
    // 根据偏移量，计算value的地址 
    jint* addr = (jint *) index_oop_from_field_offset_long(p, offset); 
    // Atomic::cmpxchg(x, addr, e) cas逻辑 x:要交换的值 e:要比较的值 
    // cas成功，返回期望值e，等于e,此方法返回true 
    // cas失败，返回内存中的value值，不等于e，此方法返回false 
    return (jint)(Atomic::cmpxchg(x, addr, e)) == e;
UNSAFE_END

核心逻辑在 Atomic::cmpxchg 方法中，这个根据不同操作系统和不同CPU会有不同的实现。这里我们以linux_64x的为例，查看 Atomic::cmpxchg 的实现


#atomic_linux_x86.inline.hpp 
inline jint Atomic::cmpxchg (jint exchange_value, volatile jint* dest, jint com pare_value) { 
    // 判断当前执行环境是否为多处理器环境 
    int mp = os::is_MP(); 
    // LOCK_IF_MP(%4) 在多处理器环境下，为 cmpxchgl 指令添加 lock 前缀，以达到内存屏障的效果
    // cmpxchgl 指令是包含在 x86 架构及 IA‐64 架构中的一个原子条件指令， 
    // 它会首先比较 dest 指针指向的内存值是否和 compare_value 的值相等， 
    // 如果相等，则双向交换 dest 与 exchange_value，否则就单方面地将 dest 指向的内存值交给exchange_value。
    // 这条指令完成了整个 CAS 操作，因此它也被称为 CAS 指令。 
    __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; 
}

cmpxchgl() 方法的详细执行过程：

首先，输入是"r" (exchange_value)， “a” (compare_value)，“r” (dest)，“r” (mp)，表示compare_value 存入 eax 寄存器，而 exchange_value、dest、mp 的值存入任意的通用寄存器。

嵌入式汇编规定把输出和输入寄存器按统一顺序编号，顺序是从输出寄存器序列从左到右从上到下以“%0”开始，分别记为%0、%1∙∙∙%9。也就是说，输出的 eax 是 %0，输入的 exchange_value、compare_value、dest、mp 分别是%1、%2、%3、%4。因此，cmpxchg %1，(%3) 实际上表示cmpxchg exchange_value，(dest) 。需要注意的是，cmpxchg 有个隐含操作数 eax，其实际过程是先比较 eax 的值(也就是 compare_value ) 和 dest 地址所存的值是否相等，输出是 "=a" (exchange_value)，表示把 eax 中存的值写入 exchange_value 变量中。

Atomic::cmpxchg 这个函数最终返回值是 exchange_value，也就是说，如果 cmpxchgl 执行时compare_value 和 dest 指针指向内存值相等则会使得 dest 指针指向内存值变成 exchange_value，最终 eax 存的 compare_value 赋值给了 exchange_value 变量，即函数最终返回的值是原先的 compare_value 。此时 Unsafe_CompareAndSwapInt 的返回值 (jint) (Atomic::cmpxchg(x, addr, e)) == e 就是 true，表明CAS成功。

如果 cmpxchgl 执行时 compare_value 和 (dest) 不等则会把当前 dest 指针指向内存的值写入 eax，最终输出时赋值给 exchange_value 变量作为返回值，导致 (jint)(Atomic::cmpxchg(x, addr, e)) == e 得到 false，表明CAS失败。

现代处理器指令集架构基本上都会提供 CAS 指令，例如 x86 和 IA-64 架构中的 cmpxchgl 指令和 comxchgq 指令，sparc 架构中的 cas 指令和 casx 指令。不管是 Hotspot 中的 Atomic::cmpxchg 方法，还是 Java 中的 compareAndSwapInt 方法，它们本质上都是对相应平台的 CAS 指令的一层简单封装。CAS 指令作为一种硬件原语，有着天然的原子性，这也正是 CAS 的价值所在。

4、原子类和CAS自旋锁的实现

原子类的操作示例


public class AtomicIntegerTest {
    public static void main(String[] args) {
        AtomicInteger count = new AtomicInteger(0); // 原子类，初始值 0
        count.getAndAdd(5); // 第一次添加
        int andAdd = count.getAndAdd(6); // 第二次添加，返回修改前的值 5 
        System.out.println("新值：" + count.get() + " 旧值：" + andAdd);
    }
}

AtomicInteger 底层使用的是 CAS 操作

自定义CAS自旋锁

此处定义CAS自旋锁，需要借助上边 UnsafeFactory.java 类获取 Unsafe 对象


import sun.misc.Unsafe;
 
public class CASLock {
    private volatile int state; //加锁标记，volatile 保证可见性
    private static final Unsafe UNSAFE;
    private static final long OFFSET;
 
    static {
        try {
            UNSAFE = UnsafeFactory.getUnsafe();
            OFFSET = UnsafeFactory.getFieldOffset(UNSAFE, CASLock.class, "state");
        } catch (Exception e) {
            throw new Error(e);
        }
    }
 
    public boolean cas() { // CAS操作,原值0,更新值1
        return UNSAFE.compareAndSwapInt(this, OFFSET, 0, 1);
    }
 
    public int getState() {
        return state;
    }
    public void setState(int state) {
        this.state = state;
    }
}

CAS锁的使用案例


public class LockTest {
    private volatile static int sum = 0; // 统计总数
    /**
     * 三种锁
     */
    static final Object object = new Object(); // 对象锁
    static ReentrantLock reentrantLock = new ReentrantLock(); // java锁
    static CASLock casLock = new CASLock(); // CAS自旋锁
 
    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 10; i++) {
            Thread thread = new Thread(() -> {// 创建线程
                for (; ; ) { // 自旋
                    if (casLock.getState() == 0 && casLock.cas()) { // CAS操作,原值0,更新为1
                        try {
                            for (int j = 0; j < 10000; j++) {
                                sum++;
                            }
                        } finally {
                            casLock.setState(0); // 最后还原原值->0
                        }
                        break;
                    }
                }
            });
            thread.start();
            thread.join();
            System.out.println(sum);
        }
    }
}

在此案例中，只有一个线程能够获取到CAS锁（把0修改为1操作成功），其他线程修改失败后会不断自旋。

不过，CAS 虽然高效地解决了原子操作，但是如果自旋 CAS 长时间地不成功，则会给 CPU 带来非常大的开销（CPU 一直空转）。同时，CAS 也存在 ABA 问题。

5、ABA 问题

CAS算法实现一个重要前提需要取出内存中某时刻的数据，而在下一时刻比较并替换，那么在这个时间差内可能会有数据的变化。

什么是ABA问题？

当有多个线程对一个原子类进行操作的时候，某个线程在短时间内将原子类的值 A 修改为 B，又马上将其修改为 A，此时其他线程无感知，还是会修改成功。

ABA 问题案例


import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.LockSupport;
 
public class ABATest {
 
    public static void main(String[] args) {
 
        AtomicInteger atomicInteger = new AtomicInteger(1);
 
        new Thread(()->{ // 线程一
            int value = atomicInteger.get();
            // 阻塞1s
            LockSupport.parkNanos(1000000000L);
 
            // Thread1通过CAS修改value值为 3
            if (atomicInteger.compareAndSet(value, 3)) {
                System.out.println("Thread-1 修改 from " + value + " to 3");
            } else {
                System.out.println("Thread-1 修改失败！");
            }
        },"Thread-1").start();
 
        new Thread(()->{ // 线程二
            int value = atomicInteger.get();
 
            // Thread2通过CAS修改value值为 2
            if (atomicInteger.compareAndSet(value, 2)) {
                System.out.println("Thread-2 修改 from " + value + " to 2");
                // do something
                value = atomicInteger.get();
                // Thread2通过CAS修改value值为 1
                if (atomicInteger.compareAndSet(value, 1)) {
                    System.out.println("Thread-2 修改 from " + value + " to 1");
                }
            }
        },"Thread-2").start();
    }
}

Thread-1 不清楚 Thread-2 对 value 的操作，误以为 value=1 没有被修改过

ABA问题的解决方案

数据库有个锁称为乐观锁，是一种基于数据版本实现数据同步的机制，每次修改一次数据，版本就会进行累加。同样，Java也提供了相应的原子引用类 AtomicStampedReference<V>

reference 是我们实际存储的变量，stamp 是版本，每次修改可以通过 +1 保证版本唯一性。这样就可以保证每次修改后的版本也会往上递增。


import java.util.concurrent.atomic.AtomicStampedReference;
import java.util.concurrent.locks.LockSupport;
 
public class AtomicStampedReferenceTest {
 
    public static void main(String[] args) {
        // 定义AtomicStampedReference：Pair.reference值为 1, Pair.stamp为 1
        AtomicStampedReference atomicStampedReference = new AtomicStampedReference(1, 1);
 
        new Thread(() -> { // 线程一
            int[] stampHolder = new int[1];
            int value = (int) atomicStampedReference.get(stampHolder);
            int stamp = stampHolder[0];
            System.out.println("Thread-1 读取值 value：" + value + ", stamp：" + stamp);
            // 阻塞1s
            LockSupport.parkNanos(1000000000L);
            // Thread-1通过CAS修改value值为 3   stamp是版本，每次修改可以通过+1保证版本唯一性
            if (atomicStampedReference.compareAndSet(value, 3, stamp, stamp + 1)) {
                System.out.println("Thread-1 修改 from " + value + " to 3");
            } else {
                System.out.println("Thread-1 修改失败!");
            }
        }, "Thread-1").start();
 
        new Thread(() -> { // 线程二
            int[] stampHolder = new int[1];
            int value = (int) atomicStampedReference.get(stampHolder);
            int stamp = stampHolder[0];
            System.out.println("Thread-2 读取值 value：" + value + ", stamp：" + stamp);
 
            // Thread-2 通过 CAS 修改value值为 2
            if (atomicStampedReference.compareAndSet(value, 5, stamp, stamp + 1)) {
                System.out.println("Thread-2 修改 from " + value + " to 5");
                // do something
                value = (int) atomicStampedReference.get(stampHolder);
                stamp = stampHolder[0];
                System.out.println("Thread-2 读取值 value：" + value + ", stamp：" + stamp);
                // Thread-2 通过 CAS 修改value值为 1
                if (atomicStampedReference.compareAndSet(value, 1, stamp, stamp + 1)) {
                    System.out.println("Thread-2 修改 from " + value + " to 1");
                }
            }
        }, "Thread2").start();
    }
}

补充：AtomicMarkableReference 可以理解为上面 AtomicStampedReference 的简化版，就是不关心修改次数，仅仅关心是否修改过。因此变量 mark 是 boolean 类型，仅记录值是否有过修改。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/2023面试高手/article/detail/293843