CAS 简介

 compare and swap
 一种思想、一种用来实现线程安全的算法。
 同时也是一种 CPU 指令： compare and swap（比较和交换），一种不会被打断的操作组合。

实现思路
 我认为V的值应该是A，如果是的话我就把它修改成B，如果不是A（说明被别人修改过），那我就不修改了，避免多人同时修改导致出错。
 CAS 有三个操作数：内存值V、预期值A、要修改的值B，当且仅当预期值 A 和内存值 V 相同时，才将内存值修改为 B，否则什么都不做。最后返回现在的值。

* CPU 的特殊指令保证了原子性

CAS 等价代码（Java）

/**
 * 描述：     Java 代码 模拟CAS操作，等价代码
 */
public class SimulatedCAS {
    private volatile int value;
    
    //整个方法作用相当于 CPU 的一条指令（CAS 指令）
    public synchronized int compareAndSwap(int expectedValue, int newValue) {
        int oldValue = value;
        if (oldValue == expectedValue) {//compare
            value = newValue;//swap
        }
        return oldValue;
    }
}

案例演示

 断掉调试，观察不同线程运行情况。

import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicIntegerArray;

/**
 * 描述：     模拟CAS操作，等价代码
 */
public class TwoThreadsCompetition implements Runnable {

    private volatile int value;

    public synchronized int compareAndSwap(int expectedValue, int newValue) {
        int oldValue = value;
        if (oldValue == expectedValue) {
            value = newValue;
        }
        return oldValue;
    }

    @Override
    public void run() {
        compareAndSwap(0, 1);
    }

    public static void main(String[] args) throws InterruptedException {
        TwoThreadsCompetition r = new TwoThreadsCompetition();
        r.value = 0;
        Thread t1 = new Thread(r,"Thread 1");
        Thread t2 = new Thread(r,"Thread 2");
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(r.value);
    }
}

应用场景

• 乐观锁
• 并发容器
• 原子类

* AtomicInteger 加载 Unsafe 工具，用来直接操作内存数据。
* 用 Unsafe 来实现底层操作（Unsafe是CAS的核心类，Java无法直接访问底层操作系统，而是通过本地方法native 来访问。尽管如此，JVM还是开了一个后门，JDK中有一个类Unsafe，它提供了硬件级别的原子操作。）
* 用 volatile 修饰 value 字段，保证可见性
* getAndAddInt() 方法分析

实现原理

 Unsafe 类中的 compareAndSwapInt()

* 方法中先想办法拿到变量 value 在内存中的地址。
* 通过Atomic:cmpxchg 实现原子性的比较和替换，其中参数x 是即将更新的值，参数 e 是原内存的值。至此，最终完成了 CAS 的全过程。

缺点

• ABA问题。（解决办法使用增加版本号）
• 自旋时间过长