| title | CAS 详解 | |||||||
|---|---|---|---|---|---|---|---|---|
| description | CAS比较并交换深度解析：详解CAS原子操作原理、Unsafe类实现、ABA问题及解决方案、自旋锁机制、与悲观锁性能对比。 | |||||||
| category | Java | |||||||
| tag |
| |||||||
| head |
|
乐观锁和悲观锁的介绍以及乐观锁常见实现方式可以阅读笔者写的这篇文章：乐观锁和悲观锁详解。
这篇文章主要介绍：Java 中 CAS 的实现以及 CAS 存在的一些问题。
在 Java 中，实现 CAS（Compare-And-Swap, 比较并交换）操作的一个关键类是 Unsafe。
Unsafe 类位于 sun.misc 包下，是一个提供低级别、不安全操作的类。由于其强大的功能和潜在的危险性，它通常用于 JVM 内部或一些需要极高性能和底层访问的库中，而不推荐普通开发者在应用程序中使用。关于 Unsafe 类的详细介绍，可以阅读这篇文章：📌Java 魔法类 Unsafe 详解。
sun.misc 包下的 Unsafe 类提供了 compareAndSwapObject、compareAndSwapInt、compareAndSwapLong 方法来实现的对 Object、int、long 类型的 CAS 操作：
/** * 以原子方式更新对象字段的值。 * * @param o 要操作的对象 * @param offset 对象字段的内存偏移量 * @param expected 期望的旧值 * @param x 要设置的新值 * @return 如果值被成功更新，则返回 true；否则返回 false */booleancompareAndSwapObject(Objecto, longoffset, Objectexpected, Objectx);
/** * 以原子方式更新 int 类型的对象字段的值。 */booleancompareAndSwapInt(Objecto, longoffset, intexpected, intx);
/** * 以原子方式更新 long 类型的对象字段的值。 */booleancompareAndSwapLong(Objecto, longoffset, longexpected, longx);Unsafe 在 JDK 8 中提供的这些 CAS 方法是 native 方法。Java 代码通过它们表达原子比较并交换语义，HotSpot 通常会把相关调用识别为 JVM 内部函数（intrinsic），再映射为目标处理器支持的原子指令或等价实现。具体实现依赖 JVM 和 CPU 架构，但不能简单概括为“通过 JNI 调用 C++ 内联汇编”。
java.util.concurrent.atomic 包提供了一些用于原子操作的类。
关于这些 Atomic 原子类的介绍和使用，可以阅读这篇文章：Atomic 原子类总结。
Atomic 类依赖于 CAS 乐观锁来保证其方法的原子性，而不需要使用传统的锁机制（如 synchronized 块或 ReentrantLock）。
AtomicInteger 是 Java 的原子类之一，主要用于对 int 类型的变量进行原子操作。下面的 JDK 8 实现利用 Unsafe 提供的低级别原子操作方法；在较新的 JDK 中，相关 API 和内部实现细节可能不同，应用代码也可以使用标准的 VarHandle 表达原子访问语义。
下面，我们通过解读 AtomicInteger 的核心源码（JDK1.8），来说明 Java 如何使用 Unsafe 类的方法来实现原子操作。
AtomicInteger 核心源码如下：
// 获取 Unsafe 实例privatestaticfinalUnsafeunsafe = Unsafe.getUnsafe();
privatestaticfinallongvalueOffset;
static {
try {
// 获取“value”字段在AtomicInteger类中的内存偏移量valueOffset = unsafe.objectFieldOffset
(AtomicInteger.class.getDeclaredField("value"));
} catch (Exceptionex) { thrownewError(ex); }
}
// 确保“value”字段的可见性privatevolatileintvalue;
// 如果当前值等于预期值，则原子地将值设置为newValue// 使用 Unsafe#compareAndSwapInt 方法进行CAS操作publicfinalbooleancompareAndSet(intexpect, intupdate) {
returnunsafe.compareAndSwapInt(this, valueOffset, expect, update);
}
// 原子地将当前值加 delta 并返回旧值publicfinalintgetAndAdd(intdelta) {
returnunsafe.getAndAddInt(this, valueOffset, delta);
}
// 原子地将当前值加 1 并返回加之前的值（旧值）// 使用 Unsafe#getAndAddInt 方法进行CAS操作。publicfinalintgetAndIncrement() {
returnunsafe.getAndAddInt(this, valueOffset, 1);
}
// 原子地将当前值减 1 并返回减之前的值（旧值）publicfinalintgetAndDecrement() {
returnunsafe.getAndAddInt(this, valueOffset, -1);
}Unsafe#getAndAddInt 源码：
// 原子地获取并增加整数值publicfinalintgetAndAddInt(Objecto, longoffset, intdelta) {
intv;
do {
// 以 volatile 方式获取对象 o 在内存偏移量 offset 处的整数值v = getIntVolatile(o, offset);
} while (!compareAndSwapInt(o, offset, v, v + delta));
// 返回旧值returnv;
}可以看到，getAndAddInt 使用了 do-while 循环：在 compareAndSwapInt 操作失败时，会不断重试直到成功。也就是说，getAndAddInt 方法会通过 compareAndSwapInt 方法来尝试更新 value 的值，如果更新失败（当前值在此期间被其他线程修改），它会重新获取当前值并再次尝试更新，直到操作成功。
由于 CAS 操作可能会因为并发冲突而失败，因此通常会与 while 循环搭配使用，在失败后不断重试，直到操作成功。这就是 自旋锁机制。
ABA 问题是 CAS 算法最常见的问题。
如果一个变量 V 初次读取的时候是 A 值，并且在准备赋值的时候检查到它仍然是 A 值，那我们就能说明它的值没有被其他线程修改过了吗？很明显是不能的，因为在这段时间它的值可能被改为其他值，然后又改回 A，那 CAS 操作就会误认为它从来没有被修改过。这个问题被称为 CAS 操作的 "ABA"问题。
ABA 问题的解决思路是在变量前面追加上版本号或者时间戳。JDK 1.5 以后的 AtomicStampedReference 类就是用来解决 ABA 问题的，其中的 compareAndSet() 方法就是首先检查当前引用是否等于预期引用，并且当前标志是否等于预期标志，如果全部相等，则以原子方式将该引用和该标志的值设置为给定的更新值。
publicbooleancompareAndSet(VexpectedReference,
VnewReference,
intexpectedStamp,
intnewStamp) {
Pair<V> current = pair;
returnexpectedReference == current.reference &&
expectedStamp == current.stamp &&
((newReference == current.reference &&
newStamp == current.stamp) ||
casPair(current, Pair.of(newReference, newStamp)));
}CAS 经常会用到自旋操作来进行重试，也就是不成功就一直循环执行直到成功。如果长时间不成功，会给 CPU 带来非常大的执行开销。
如果 JVM 能够支持处理器提供的 pause 指令，那么自旋操作的效率将有所提升。pause 指令有两个重要作用：
- 延迟流水线执行指令：
pause指令可以延迟指令的执行，从而减少 CPU 的资源消耗。具体的延迟时间取决于处理器的实现版本，在某些处理器上，延迟时间可能为零。 - 避免内存顺序冲突：在退出循环时，
pause指令可以避免由于内存顺序冲突而导致的 CPU 流水线被清空，从而提高 CPU 的执行效率。
CAS 操作仅能对单个共享变量有效。当需要操作多个共享变量时，CAS 就显得无能为力。不过，从 JDK 1.5 开始，Java 提供了 AtomicReference 类，这使得我们能够保证引用对象之间的原子性。通过将多个变量封装在一个对象中，我们可以使用 AtomicReference 来执行 CAS 操作。
除了 AtomicReference 这种方式之外，还可以利用加锁来保证。
在 Java 中，原子类、VarHandle 等 API 可以表达 CAS 操作；JVM 再根据目标平台将其实现为处理器支持的原子指令或等价机制。具体实现依赖 JVM 和 CPU 架构，并不由 Java 规范限定为 JNI 或某一种汇编写法。
CAS 虽然具有高效的无锁特性，但也需要注意 ABA、循环时间长开销大等问题。