并发编程之CASAtomic原子操作

什么是CAS？

CAS 原子操作的三大问题

ABA问题

循环时间长开销大

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

jdk中的原子操作类

AtomicInteger

AtomicLong

AtomicReference

LongAdder

什么是CAS？

CAS是“比较并交换”（Compare and Swap）的缩写。CAS是一种多线程同步的技术，用于实现多线程环境下的原子操作，常用于实现无锁的数据结构和线程安全算法。

CAS 操作过程都包含三个运算符：一个内存地址 V，一个期望的值 A 和一个新值 B，操作的时候如果这个地址上存放的值等于这个期望的值 A，则将地址上的值赋为新值 B，否则不做任何操作。

CAS 的基本思路就是，如果这个地址上的值和期望的值相等，则给其赋予新值，否则不做任何事儿，但是要返回原值是多少。自然 CAS 操作执行完成时，在业务上不一定完成了，这个时候我们就会对 CAS 操作进行反复重试，于是就有了循环 CAS。很明显，循环 CAS 就是在一个循环里不断的做 cas 操作，直到成功为止。Java 中的 Atomic 系列的原子操作类的实现则是利用了循环 CAS 来实现。

CAS 原子操作的三大问题

ABA问题

ABA问题是指在多线程环境下，一个值由A变为B，再由B变回A，这时如果仅使用CAS来判断值是否变化，可能无法正确地捕捉到中间的变化，从而导致不正确的结果。ABA问题包含以下步骤：

1. 初始时，某共享变量的值为A。

2. 线程1读取该共享变量的值为A，然后线程1被阻塞或者挂起。

3. 线程2将该共享变量的值由A改为B，再改回A。

4. 线程1恢复执行，使用CAS检查共享变量的值是否仍然为A，由于共享变量的值此时确实为A，CAS操作成功。

在以上过程中，线程1没有察觉到共享变量B发生过变化，因为CAS只检查共享变量的当前值和预期值是否相等。

解决ABA问题，可以使用带有版本号的变量，也被称为版本号引用。比如使用Atomic包下工具类AtomicStampedReference：

import java.util.concurrent.atomic.AtomicStampedReference;public class ABATest {public static void main(String[] args) {// 初始值为A，初始版本号为0AtomicStampedReference<String> atomicRef = new AtomicStampedReference<>("A", 0);// 线程1读取当前值和版本号int[] stampHolder = new int[1];String value1 = atomicRef.get(stampHolder);// 线程2修改值为B，并增加版本号atomicRef.compareAndSet(value1, "B", stampHolder[0], stampHolder[0] + 1);// 线程1再次尝试CAS，但由于版本号已经变化，不再匹配，不会发生CAS成功boolean success = atomicRef.compareAndSet("A", "C", stampHolder[0], stampHolder[0] + 1);System.out.println("CAS success: " + success);  // 输出false，表示CAS操作失败}
}

循环时间长开销大

自旋 CAS 如果长时间不成功，会给 CPU 带来非常大的执行开销。

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

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

jdk中的原子操作类

AtomicInteger

get():获取当前值。

set(int newValue):设置为给定值。

getAndIncrement():获取当前值并递增。

compareAndSet(int expect, int update):比较当前值是否等于预期值，若相等则更新为新值。

import java.util.concurrent.atomic.AtomicInteger;public class AtomicIntegerExample {private static AtomicInteger counter = new AtomicInteger(0);public static void main(String[] args) {System.out.println("Initial value: " + counter.get());int newValue = 10;counter.set(newValue);System.out.println("Set new value: " + counter.get());int oldValue = counter.getAndIncrement();System.out.println("Old value: " + oldValue + ", After increment: " + counter.get());int expectedValue = 10;int updateValue = 20;boolean updated = counter.compareAndSet(expectedValue, updateValue);System.out.println("Value updated? " + updated + ", Current value: " + counter.get());}
}

AtomicLong

get()：获取当前值。

incrementAndGet()：递增并获取新值。

getAndSet(long newValue)：设置为给定值，并返回旧值。

import java.util.concurrent.atomic.AtomicLong;public class AtomicLongExample {private static AtomicLong counter = new AtomicLong(0);public static void main(String[] args) {System.out.println("Initial value: " + counter.get());long newValue = 10;counter.set(newValue);System.out.println("Set new value: " + counter.get());long incrementedValue = counter.incrementAndGet();System.out.println("Incremented value: " + incrementedValue);long oldValue = counter.getAndSet(20);System.out.println("Old value: " + oldValue + ", Current value: " + counter.get());}
}

AtomicReference

get()：获取当前引用对象。

set(V newValue)：设置为给定值。

compareAndSet(V expect, V update):比较当前引用对象是否等于预期值,若相等则更新为新值。

import java.util.concurrent.atomic.AtomicReference;public class AtomicReferenceExample {public static void main(String[] args) {// 初始值为 "Hello"AtomicReference<String> atomicReference = new AtomicReference<>("Hello");// 获取当前值String currentValue = atomicReference.get();System.out.println("Current Value: " + currentValue);// 尝试更新值，如果当前值是 "Hello"，则更新为 "World"boolean updated = atomicReference.compareAndSet("Hello", "World");System.out.println("Updated: " + updated);// 获取更新后的值currentValue = atomicReference.get();System.out.println("Current Value: " + currentValue);// 尝试更新值，如果当前值是 "Hello"，则更新为 "World123"updated = atomicReference.compareAndSet("Hello", "World123");System.out.println("Updated: " + updated);// 获取更新后的值currentValue = atomicReference.get();System.out.println("Current Value: " + currentValue);}
}

更多原子类可以去jdk的java.util.concurrent.atomic包下去查看。

LongAdder

LongAdder 是 Java 中 java.util.concurrent.atomic 包下的原子操作类，用于高并发环境下对long类型的加法操作。它是在JDK8引入的，相比于 AtomicLong，LongAdder 在高并发情况下表现更好，因为它将内部的值分散到多个变量中，从而降低了竞争。LongAdder引入的初衷解决高并发环境下 AtomicLong 的自旋瓶颈问题。