java cas机制零基础入门到精通，收藏这篇就够了-程序员充电站

文章目录

概述
CAS的基本概念
CAS基本原理
Java中的CAS实现
- 什么是unsafe
- 原子操作类解析
CAS机制的优缺点
- 优点
- 缺点
CAS应用场景
CAS机制优化
总结

public class AtomicInteger extends Number implements java.io.Serializable { private static final long serialVersionUID = 6214790243416807050L; //由这里可以看出来，依赖jdk.internal.misc.Unsafe实现的 private static final jdk.internal.misc.Unsafe U = jdk.internal.misc.Unsafe.getUnsafe(); private static final long VALUE = U.objectFieldOffset(AtomicInteger.class, "value"); private volatile int value; public final boolean compareAndSet(int expectedValue, int newValue) { // 调用 jdk.internal.misc.Unsafe的compareAndSetInt方法 return U.compareAndSetInt(this, VALUE, expectedValue, newValue); } }

Unsafe中的compareAndSetInt使用了@HotSpotIntrinsicCandidate注解修饰，@HotSpotIntrinsicCandidate注解是Java HotSpot虚拟机（JVM）的一个特性注解，它表明标注的方法有可能会被HotSpot JVM识别为“内联候选”，当JVM发现有方法被标记为内联候选时，会尝试利用底层硬件提供的原子指令（比如cmpxchg指令）直接替换掉原本的Java方法调用，从而在运行时获得更好的性能。

public final class Unsafe { @HotSpotIntrinsicCandidate public final native boolean compareAndSetInt(Object o, long offset, int expected, int x); }

compareAndSetInt这个方法我们可以从openjdk的hotspot源码（位置：hotspot/src/share/vm/prims/unsafe.cpp）中可以找到。

hostspot中的Unsafe_CompareAndSetInt函数会统一调用Atomic的cmpxchg函数

UNSAFE_ENTRY(jboolean, Unsafe_CompareAndSetInt(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jint e, jint x)) { oop p = JNIHandles::resolve(obj); jint* addr = (jint *)index_oop_from_field_offset_long(p, offset); // 统一调用Atomic的cmpxchg函数 return (jint)(Atomic::cmpxchg(x, addr, e)) == e; } UNSAFE_END

而Atomic的cmpxchg函数源码(位置：hotspot/src/share/vm/runtime/atomic.hpp)如下:

/** *这是按字节大小进行的`cmpxchg`操作的默认实现。它使用按整数大小进行的`cmpxchg`来模拟按字节大小进行的`cmpxchg`。不同的平台可以通过定义自己的内联定义以及定义`VM_HAS_SPECIALIZED_CMPXCHG_BYTE`来覆盖这个默认实现。这将导致使用特定于平台的实现而不是默认实现。 * exchange_value：要交换的新值。 * dest：指向目标字节的指针。 * compare_value：要比较的值。 * order：内存顺序。 */ inline jbyte Atomic::cmpxchg(jbyte exchange_value, volatile jbyte* dest, jbyte compare_value, cmpxchg_memory_order order) { STATIC_ASSERT(sizeof(jbyte) == 1); volatile jint* dest_int = static_cast<volatile jint*>(align_ptr_down(dest, sizeof(jint))); size_t offset = pointer_delta(dest, dest_int, 1); // 获取当前整数大小的值，并将其转换为字节数组。 jint cur = *dest_int; jbyte* cur_as_bytes = reinterpret_cast<jbyte*>(&cur); // 设置当前整数中对应字节的值为compare_value。这确保了如果初始的整数值不是我们要找的值，那么第一次的cmpxchg操作会失败。 cur_as_bytes[offset] = compare_value; // 在循环中，不断尝试更新目标字节的值。 do { // new_val jint new_value = cur; // 复制当前整数值，并设置其中对应字节的值为exchange_value。 reinterpret_cast<jbyte*>(&new_value)[offset] = exchange_value; // 尝试使用新的整数值替换目标整数。 jint res = cmpxchg(new_value, dest_int, cur, order); if (res == cur) break; // 如果返回值与原始整数值相同，说明操作成功。 // 更新当前整数值为cmpxchg操作的结果。 cur = res; // 如果目标字节的值仍然是我们之前设置的值，那么继续循环并再次尝试。 } while (cur_as_bytes[offset] == compare_value); // 返回更新后的字节值 return cur_as_bytes[offset]; }

cmpxchg指令是多数现代CPU支持的原子指令，它能在多线程环境下确保一次比较和交换操作的原子性，有效解决了多线程环境下数据竞争的问题，避免了数据不一致的情况。例如，在更新一个共享变量时，如果期望值与当前值相匹配，则原子性地更新为新值，否则不进行更新操作，这样就能在无锁的情况下实现对共享资源的安全访问。
我们以java.util.concurrent.atomic包下的AtomicInteger为例，分析其compareAndSet方法。

而由cmpxchg函数中的do...while我们也可以看出，当多个线程同时尝试更新同一内存位置，且它们的期望值相同但只有一个线程能够成功更新时，其他线程的CAS操作会失败。对于失败的线程，常见的做法是采用自旋锁的形式，即循环重试直到成功为止。这种方式在低竞争或短时间窗口内的并发更新时，相比于传统的锁机制，它避免了线程的阻塞和唤醒带来的开销，所以它的性能会更优。

什么是unsafe

什么是unsafe呢？Java语言不像C，C++那样可以直接访问底层操作系统，但是JVM为我们提供了一个后门，这个后门就是unsafe。unsafe为我们提供了硬件级别的原子操作。

CAS是一种原子操作。那么Java是怎样来使用CAS的呢？

我们知道，在Java中，如果一个方法是native的，那Java就不负责具体实现它，而是交给底层的JVM使用c或者c++去实现。

Unsafe类是JDK提供的一个不安全的类，它提供了一些底层的操作，包括内存操作、线程调度、对象实例化等。它的作用是让Java可以在底层直接操作内存，从而提高程序的效率。但是，由于Unsafe类是不安全的，所以只有JDK开发人员才能使用它，普通开发者不建议使用。它里面大多是一些native方法，其中就有几个关于CAS的：

boolean compareAndSwapObject(Object o, long offset,Object expected, Object x); boolean compareAndSwapInt(Object o, long offset,int expected,int x); boolean compareAndSwapLong(Object o, long offset,long expected,long x);

调用compareAndSwapInt、compareAndSwapLong或compareAndSwapObject方法时，会传入三个参数，分别是需要修改的变量V、期望的值A和新值B。
方法会先读取变量V的当前值，如果当前值等于期望的值A，则使用新值B来更新变量V，否则不做任何操作。
方法会返回更新操作是否成功的标志，如果更新成功，则返回true，否则返回false。
由于CAS操作是基于底层硬件支持的原子性指令来实现的，所以它可以保证操作的原子性和线程安全性，同时也可以避免使用锁带来的性能开销。因此，CAS操作广泛应用于并发编程中，比如实现无锁数据结构、实现线程安全的计数器等。

原子操作类解析

看一下AtomicInteger当中常用的自增方法incrementAndGet

public class AtomicInteger extends Number implements java.io.Serializable { private static final long serialVersionUID = 6214790243416807050L; // setup to use Unsafe.compareAndSwapInt for updates private static final Unsafe unsafe = Unsafe.getUnsafe(); private static final long valueOffset; static { try { valueOffset = unsafe.objectFieldOffset (AtomicInteger.class.getDeclaredField("value")); } catch (Exception ex) { throw new Error(ex); } } private volatile int value; /** * Atomically increments by one the current value. * * @return the updated value */ public final int incrementAndGet() { return unsafe.getAndAddInt(this, valueOffset, 1) + 1; } } public final class Unsafe { public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5); 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; } }

这段代码是一个无限循环，也就是CAS的自旋(底层为do-while循环)，循环体中做了三件事：