java并发之CAS(Compare and swap)

news2024/11/26 17:36:19

1. 简介

CAS的底层调用native方法，最终是利用CPU的一个特殊指令，该指令由CPU保证了原子性，而且包含多个操作，比如先比较再更新。

原理：

（1）需要读写的内存值（V）、原值（A）和新值(B)。如果V的值与原值A相匹配，那么把B设置给V，否则处理器不做任何操作。
（2）无论哪种情况，都返回V内存值。
（3）原子类里，当失败时，就一直循环，直到成功。

（1）、（2）是在CPU和内存的层面来说的，（3）是在Java层面说的

比如 AtomicInteger中的源码中，就使用到了 CAS：

public final int getAndAddInt(Object var1, long var2, int var4) {
    int var5;
    do {
        var5 = this.getIntVolatile(var1, var2);
    } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));

    return var5;
}

2. CAS的等价代码

自己实现CAS:

/**
  *      模拟CAS操作，等价代码
 */
public class SimulatedCAS {
    private int value;

    /**
     * 模拟CAS操作
     * @param expectedValue 预期值
     * @param newValue 修改值
     * @return 原值
     */
    public synchronized int compareAndSwap(int expectedValue, int newValue) {
        int oldValue = value;

        if (oldValue == expectedValue) {
            value = newValue;
        }
        return oldValue;
    }
}

在多线程中调用上面自己实现的CAS：

/**
  *      两个线程竞争,其中一个修改落败
 */
public class TwoThreadCompetition implements Runnable{
    private int value;

    /**
     * 模拟CAS操作
     * @param expectedValue 预期值
     * @param newValue 修改值
     * @return 旧值
     */
    public synchronized int compareAndSwap(int expectedValue, int newValue) {
        int oldValue = value;

        if (oldValue == expectedValue) {
            value = newValue;
            System.out.println(Thread.currentThread().getName()+"将值从"+oldValue+"修改成"+newValue);

        }
        return oldValue;
    }

    //主函数
    public static void main(String[] args) throws InterruptedException {
        TwoThreadCompetition r = new TwoThreadCompetition();
        r.value=0;//默认值
        Thread thread1 = new Thread(r,"线程1");
        thread1.start();
        thread1.join();
        System.out.println(r.value);
        Thread thread2 = new Thread(r,"线程2");
        thread2.start();
        thread2.join();
        System.out.println(r.value);
    }

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

打印结果显示，只有第一个线程对 value 进行了修改，第二个线程没有修改，符合CAS的逻辑。

3. 应用场景

（1）乐观锁

乐观锁的实现就是利用CAS原理，比如数据库在修改时，是利用version字段来判断是否应该执行修改，而不是加锁。

（2）并发容器

如ConcurrentHashMap类中的put()方法…

（4）原子类

这里以 AtomicInteger 的 getAndIncrement()方法为例剖析如何利用CAS实现原子性的

AtomicInteger加载Unsafe工具,用来直接操作内存数据
用Unsafe工具来实现底层操作
用volatile修饰value字段，保证可见性

上面使用到了 Unsafe 类，那么他是个什么呢？

Unsafe是CAS的核心类。Java一般无法直接访问底层操作系统，而是通过本地(native)方法来访问。不过尽管如此，JVM还是开了一个后门，JDK中有一个类Unsafe，它提供了硬件级别的原子操作。
valueOffset表示的是变量值在内存中的偏移地址，因为Unsafe就是根据内存偏移地址获取数据的原值的，这样我们就能通过unsafe来实现CAS了

总结：

总之，getAndIncrement() 的实现原理是：先获取 value 在内存中的地址，然后使用该地址拿到原值，再调用 compareAndSwapInt 方法，将内存地址value，原值，和新值传进去，执行 CAS 方法，compareAndSwapInt 是 native 方法，由c++实现，如下