Java并发编程第10讲——CAS相关知识点详解

举个例子：

@Data
public class IntegerUpdaterDemo {
    //字段必须是 volatile 类型的
    private volatile int score;
    //创建AtomicIntegerFieldUpdater 实例
    private static final AtomicIntegerFieldUpdater SCORE_UPDATER =
            AtomicIntegerFieldUpdater.newUpdater(IntegerUpdaterDemo.class, "score");
​
    public static void main(String[] args) {
        IntegerUpdaterDemo demo = new IntegerUpdaterDemo();
        demo.setScore(80);
        //使用AtomicIntegerFieldUpdater进行原子性更新操作
        int newValue = 90;
        int oldValue = SCORE_UPDATER.getAndSet(demo, newValue);
        System.out.println("原始值: " + oldValue + ", 更新后的值: " + demo.getScore());  //原始值: 80, 更新后的值: 90 
    }
}

四、CAS实现原理

下面以AtomicInteger原子整型类为例，分析一下CAS底层实现机制。

4.1 AtomicInteger的getAndIncrement方法

上面解决i++问题的时候用到了AtomicInteger的getAndIncrement方法，通过方法调用，可以发现getAndIncrement方法调用了getAndAddInt方法，最后调用的是Unsafe类的compareAndSwapInt方法，也就是我们今天要介绍的CAS：

​

compareAndSwapInt方法参数解释：

• var1：Unsafe对象本身，需要通过这个类获取value的内存偏移地址。
• var2：value变量的内存偏移地址。
• var4：需要增加或减少的数。
• var5：内存位置的最新值。
• var5+var4：要更新的最新值。

就是拿到内存位置的最新值var5，使用CAS尝试将内存位置的值修改为目标值var5+var4，如果修改失败，则获取改内存位置的新值var5，然后继续尝试，直到成功。

4.2 Unsafe类

读到这我们知道Java中Atomic类的实现都是基于Unsafe类实现的，那么Unsafe类是什么呢？

4.2.1 什么是Unsafe类

Unsafe类是CAS的核心类。因为Java无法直接访问底层操作系统，而是通过本地（native）方法来访问。不过JVM还是开了一个后门，JDK中有一个Unsafe类，他提供了硬件级别的原子操作，说白了Unsafe类就是跟底层硬件CPU指令通讯的复制工具。

Unsafe类包含了很多基础操作，比如数组操作、对象操作、内存操作、CAS操作、线程（park）操作，栅栏（Fence）操作，JUC包以及一些三方框架都是用Unsafe类来保证线程安全。

Unsafe类在jdk源码的多个类中用到，这个类提供了一些绕开JVM的更底层的功能，基于它的实现可以提高效率。不过，正如它名字那样——不安全类，他所分配的内存需要手动free（不会被GC回收）。

Unsafe类提供了硬件级别的操作，主要有以下功能：

• 通过Unsafe类可以分配内存，可以释放内存。
• 可以定位对象某字段的内存位置，也可以修改对象的字段值，即使它是私有的。
• 将线程进行挂起与恢复。
• CAS操作。

4.2.2 举个例子

Unsafe被设计的初衷，并不是希望被一般开发者调用，它的构造方法是私有的，所以我们不能通过new或工厂方法实例化Unsafe对象，通常用反射来获取Unsafe示例：

private static Unsafe getUnsafeInstance() throws NoSuchFieldException, IllegalAccessException {
    //Unsafe类中提供了一个静态的getUnsafe方法，可以返回一个Unsafe实例
    Field unsafeField = Unsafe.class.getDeclaredField("theUnsafe");
    unsafeField.setAccessible(true);
    return (Unsafe) unsafeField.get(null);
}

来看一下分配内存的例子：

public class UnsafeDemo {
    public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException {
        Unsafe unsafe = getUnsafeInstance();
        //分配一个包含10个整数的连续内存空间
        long size = 10 * Integer.BYTES;
        //分配内存
        long memoryAddress = unsafe.allocateMemory(size);
        //在内存中存储值
        for (int i = 0; i < 10; i++) {
            unsafe.putInt(memoryAddress + i * Integer.BYTES, i);
        }
        for (int i = 0; i < 10; i++) {
            //从内存中读取值
            int value = unsafe.getInt(memoryAddress + i * Integer.BYTES);
            System.out.println(value);
        }
        //释放内存
        unsafe.freeMemory(memoryAddress);
    }
    //获取Unsafe实例
    private static Unsafe getUnsafeInstance() throws NoSuchFieldException, IllegalAccessException {
        Field unsafeField = Unsafe.class.getDeclaredField("theUnsafe");
        unsafeField.setAccessible(true);
        return (Unsafe) unsafeField.get(null);
    }
}

同样，也可以用Unsafe类实现一个CAS操作，这里就不做演示了。

4.2.3 Unsafe类的compareAndSwapInt方法

介绍完Unsafe类，我们书接4.1，接着继续深入探讨该方法，该方法在Unsafe中对应的C++源码如下：

​

可以看到调用了Atomic::cmpxchg方法，那么我们再来看看Atomic::cmpxchg方法：

​

标红框的地方就是调用了汇编指令cmpxchg，作用是比较并交换而CAS操作的原理就是基于硬件提供的原子操作指令——cmpxchg指令实现的：

• cmpxchg指令是一条原子指令。在cpu执行cmpxchg指令时，处理器会自动锁定总线，防止其它cpu刚问共享变量，然后执行比较和交换操作，最后释放总线。
• cmpxchg指令在执行期间，cpu会自动禁止中断。这样可以确保CAS操作的原子性，避免中断或其它干扰对操作的影响。
• cmpxchg指令时硬件实现的，可以保证其原子性和正确性。cpu中的硬件电路确保了cmpxchg指令的正确执行，以及对共享变量的访问原子性。

ps：同样是因为cmpxchg指令，这个指令基于cpu缓存一致性协议实现的。在多个cpu中，所有核心的缓存都是一致的。当一个cpu核心执行cmpxchg指令时，其它cpu核心的缓存会自动更新，以确保对共享变量的访问是一致的。

五、CAS存在的问题

任何技术都不是十全十美的，强如硬件级别实现的CAS操作也会有瑕疵。

5.1 ABA问题

CAS算法实现一个重要前提是需要取出内存中某时刻的数据，而在下个时刻进行比较和交换，那么这个时间差会导致数据的变化。

比如，当线程1要修改A时，会先读取A的值，如果此时有一个线程2，经过一系列操作，将A修改为B，再由B修改为A，然后线程1在比较A时，发现A的值没有改变，于是就修改了。但此时A的版本已经不是最先读取的版本了，这就时ABA问题。

如何解决？解决这个问题的办法也很简单，就是添加版本号，修改数据时带上一个版本号，如果版本号我数据的版本号一致就修改（同时修改版本号），否则就失败，或者改用传统的互斥同步方式。

5.2 忙等待问题

上面的getAndAddInt方法就是一个很好的例子，getAndAddInt方法执行时，如果CAS失败，会一直尝试。如果CAS长时间一直不成功，可能会给CPU带来很大的开销。

5.3 只能保证一个共享变量的原子操作

当对一个共享变量操作时，我们可以用CAS的方式来保证原子操作，但是对于多个共享变量操作时，循环CAS就无法保证操作的原子性，这个时候我们可能就会用锁来保证原子性。

六、LongAdder

在5.2中提到的忙等待问题会给CPU带来很大的开销，从而会使性能下降。当然在大部分场景下使用Atomic原子操作类还是绰绰有余的，但在多线程竞争比较激烈，也就是并发冲突比较大的情况下，就得考虑其它方案了，比如LongAddr。

6.1 什么是LongAddr

LongAddr是Java 8中推出的一个新的类，主要是为了解决Atomic原子操作类在多线程竞争激烈的情况下性能并不高的问题，它主要是采用分段+CAS的方式来提升原子操作的性能。

但是性能高就意味着要有牺牲，而LongAddr就是典型的以空间换时间的实现方式，所以它需要用到更大的空间，而且LongAddr还可能存在结果不准确的问题，Atomic原子操作类并不会。

将AtomicInteger的例子改造一下：

public class LongAddrDemo {
    public static LongAdder i=new LongAdder();
    public static void increase(){
        i.increment();
    }
    public static void main(String[] args) throws InterruptedException {
        //启动10个线程，每个线程累加1000次
        for (int j = 0; j < 10; j++) {
            new Thread(() -> {
                for (int k = 0; k < 10000; k++) {
                    increase();
                }
            }, String.valueOf(j)).start();
        }
        while (Thread.activeCount() > 2) {
            Thread.yield();
        }
        System.out.println(i.sum());//100000
    }
}

6.2 LongAddr实现原理（源码解析）

Java 8中的LongAddr类继承自抽象类Striped64（也是atomic包下的），这个类也是Java 8新增的，主要的作用就是给并发场景下提供计数支持。

Striped64的设计思路与ConcurrentHashMap类似，都是通过分散竞争的方式来提升并发性能，其中主要依赖了两个字段：

​

解释：

• cells数组：当检测到有base变量被线程占有时，就会尝试暂存在cells数组中。
• base变量：当没有线程竞争时，首先会改变base的值。

最终的结果：base变量+cells数组中value。

通过查看LongAddr中的add方法的代码，我们就能更好地理解：

​

解释：

• 外层if：判断是否需要通过base进行累加

  • 如果cells数组！=null，说明已经存在分段累加器（cells数组），则不需要base进行累加。

  • 如果cells数组==null，即不存在分段累加器，那么就尝试使用cas进行base累加，失败则进入if进行更细粒度的累加。

• 内层if：进一步判断是否需要进行细粒度的累加操作

  • 再一次判断cells数组是否为空，为空则表示没有分段的累加器。不为空进入下一步。

  • cells数组长度m是否小于0。不小于0进入下一步。

  • getProbe()&m通过探针索引获取cells数组中的某个位置的cell对象a，看是否有初始化。不为空进入下一步。

  • 将Cell对象a的value与v+x进行CAS操作。

满足以上四个判断之一，则调用longAccumulate方法进行细粒度的累加操作。

总结一下，首先尝试通过CAS更新base的值，如果再竞争不激烈的情况下，是可以CAS成功的，如果成功，那么就和Atomic原子操作类一样了。如果失败，那么就代表竞争激烈，那么就会尝试通过cells数组来分散计数。Striped64根据线程来计算哈希，然后将不同的线程分散到不同Cell数组的index上，然后这个线程的计数内容就会保存在该Cell的位置上面，最后总计数则是base加上cells数组中的计数内容。

这跟ConcurrentHashMap的分段锁很像吧。最后再来看看它是怎么统计的：

​

很简单，就是将base和cells数组中的值都加起来得到最终的结果。

6.3 LongAddr计算不准确的问题

还是那句话，没有十全十美的技术，那么LongAddr为什么会存在计算不准确的情况呢？

通过查看LongAddr的代码很容易可以发现一个问题，那就是LongAddr的累加结果可能是不准确的，而且sum这个方法的注释上也明确点处了这个问题：

Returns the current sum. The returned value is NOT an atomic snapshot; invocation in the absence of concurrent updates returns an accurate result, but concurrent updates that occur while the sum is being calculated might not be incorporated.

翻译过来就是：返回值不是原子快照；在没有并发更新的情况下调用会返回准确的结果，但是在计算总和时发生并发更新可能不会被纳入计算。举个极端的例子：在并发高的情况下，如果刚好返回sum的时候有其它原子操作进行了累加操作，那么这时候返回的sum就会不准。

总体来说，LongAddr在高并发情况下提供了更好的性能，但牺牲了计算的准确性，所以它更适合应用于并发竞争激烈，但对数据准确度要求并不是百分之百准确的场景，比如微博点赞、文章阅读量的统计等场景。

End：希望对大家有所帮助，如果有纰漏或者更好的想法，请您一定不要吝啬你的赐教🙋。