CAS及其执行流程

​ CAS（Compare and Swap）是一种轻量级的同步操作，也是乐观锁的一种实现，它用于实现多线程环境下的并发算法。CAS 操作包含三个操作数：内存位置（或者说是一个变量的引用）、预期的值和新值。如果内存位置的值和预期值相等，那么处理器会自动将该位置的值更新为新值，否则不进行任何操作。

在多线程环境中，CAS 可以实现非阻塞算法，避免了使用锁所带来的上下文切换、调度延迟、死锁等问题，因此被广泛应用于并发编程中。

CAS 示例

在 Java 中，CAS 操作被封装在 Atomic 类中，例如 AtomicInteger 类就是利用了 CAS 操作来实现线程安全的自增操作。同时，Java 还提供了一些工具类来支持 CAS 操作，例如 Unsafe 类，它提供了一些原始的 CAS 操作方法，供 JVM 内部使用，比如以下是基于 Unsafe 类的 CAS 示例：

import sun.misc.Unsafe;

import java.lang.reflect.Field;
import java.util.concurrent.TimeUnit;

public class CASDemo {
    private volatile int value = 0;
    private static Unsafe unsafe;
    private static long valueOffset;

    static {
        try {
            // 通过反射获取rt.jar包中的Unsafe类，默认Unsafe类是不能使用的
            Field field = Unsafe.class.getDeclaredField("theUnsafe");
            field.setAccessible(true);
            unsafe = (Unsafe) field.get(null);
            valueOffset = unsafe.objectFieldOffset(CASDemo.class.getDeclaredField("value"));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public void addOne() {
        int current;
        do {
            current = unsafe.getIntVolatile(this, valueOffset);
        } while (!unsafe.compareAndSwapInt(this, valueOffset, current, current + 1));
    }

    public static void main(String[] args) throws InterruptedException {
        final CASDemo casDemo = new CASDemo();
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                for (int j = 0; j < 1000; j++) {
                    casDemo.addOne();
                }
            }).start();
        }
        TimeUnit.SECONDS.sleep(5);
        System.out.println(casDemo.value);
    }
}

以上程序的执行结果为：

10000

程序开启了 10 个线程，每个线程调用 1000 次，最终执行的结果是 10000，说明以上程序是线程安全的。

CAS 执行流程

CAS 执行的具体流程如下：

1. 将需要修改的值从主内存中读入本地线程缓存（工作内存）；
2. 执行 CAS 操作，将本地线程缓存中的值与主内存中的值进行比较；
3. 如果本地线程缓存中的值与主内存中的值相等，则将需要修改的值在本地线程缓存中修改；
4. 如果修改成功，将修改后的值写入主内存，并返回修改结果；如果失败，则返回当前主内存中的值；
5. 在多线程并发执行的情况下，如果多个线程同时执行 CAS 操作，只有一个线程的 CAS 操作会成功，其他线程的 CAS 操作都会失败，这也是 CAS 的原子性保证。
   ​​
   

​