CAS原理

由于JVM的synchronized重量级锁设计操作系统内核态下的互斥锁的使用，其线程的阻塞和唤醒在内核态和用户态频繁切换，导致重量级锁的开销很大，性能低。JVM为synchronized提供了轻量级锁，通过CAS（compare and swap）比较交换，进行自旋抢锁，CAS是CPU指令级别的原子操作，并且处于用户状态下，开销比较小。

下面我们来了解一下什么是CAS

1.什么是CAS

JDK 5 所增加的 JUC（java.util.concurrent）并发包对操作系统的底层的CAS原子操作进行了封装，为上层Java程序提供了CAS操作的API

CAS（Compare and Swap）是一种并发编程中的原子操作，用于实现多线程环境下的无锁同步。CAS操作包含三个参数：内存位置（或者说是要操作的变量的引用）、期望值和新值。

CAS操作的执行过程如下：

1. 首先，读取内存位置的当前值，这是期望值。
2. 然后，将期望值与内存位置的当前值进行比较。如果相等，则说明内存位置的值没有被其他线程修改，可以进行更新操作。
3. 如果相等，将内存位置的当前值修改为新值。如果不相等，说明内存位置的值已经被其他线程修改，CAS操作失败。
4. 最后，CAS操作返回执行结果，通常是一个布尔值，表示操作是否成功。

CAS操作是原子的，意味着整个操作在执行期间不会被其他线程中断。如果多个线程同时执行CAS操作，只有一个线程会成功，其他线程会根据操作结果进行重试或进行其他处理。

2.Unsafe类中的CAS方法

Unsafe是位于sum.misc包下面的一个类，主要提供一些执行级别低，不安全的底层操作逻辑。如直接访问系统内存资源，自主管理内存资源等。

Unsafe中的大量方法都是原生（naticve）方法，基于C++语言实现，这些方法在提升Java运行效率上起了很大作用，但是在一般的开发中不会涉及此类，Java官方也不建议直接在应用程序中使用。

操作系统层面的CAS是一条CPU原子指令（compxchg）指令，UnSafe提供的CAS方法直接通过native方式（封装的C++代码）调用了底层CPU指令的compxchg。

在Java应用层，CAS操作主要是通过调用sun.misc.Unsafe类中的方法来实现的。Unsafe类提供了一些底层的、直接操作内存和执行CAS操作的方法。下面是使用Unsafe类进行CAS操作的一般流程：

1. 获取Unsafe实例：
   Unsafe类的构造函数是私有的，因此无法直接实例化它。通常可以通过反射或者调用Unsafe.getUnsafe()方法来获取Unsafe的实例。
2. 获取要操作的变量的偏移量：
   在执行CAS操作之前，需要获取要操作的变量在内存中的偏移量。偏移量表示变量相对于对象头的位置。可以使用Unsafe.objectFieldOffset()方法来获取变量的偏移量。
3. 执行CAS操作：
   通过调用Unsafe.compareAndSwapXXX()方法来执行CAS操作，其中XXX表示要操作的数据类型（如Int、Long、Object等）。compareAndSwapXXX()方法接收四个参数：要操作的对象、变量的偏移量、期望值和新值。方法会比较对象内存中偏移量处的值与期望值是否相等，如果相等，则将该位置的值更新为新值，并返回操作是否成功的布尔值。
4. 锁定和解锁：
   在执行CAS操作期间，不需要使用锁来保护共享资源，因为CAS操作本身是原子的。它使用底层硬件指令实现的原子性保证。因此，CAS操作可以避免传统的锁机制所带来的开销和竞争。

需要注意的是，使用Unsafe类进行CAS操作需要谨慎，因为直接操作内存可能会导致不安全的结果。此外，Unsafe类在Java 9中被标记为不推荐使用，并且在未来的版本中可能会被移除。因此，在实际应用中，建议使用更高级的并发工具和类库，如java.util.concurrent.atomic包中的原子类来实现线程安全的操作

2.1.获取UnSafe实例

@Test
@DisplayName("获取UnSafe实例")
public void test() {try {Field theUnsafe = Unsafe.class.getDeclaredField("theUnsafe");theUnsafe.setAccessible(true);Unsafe unsafe = (Unsafe) theUnsafe.get(null);log.error("unsafe : {}",unsafe);} catch (NoSuchFieldException e) {throw new RuntimeException(e);} catch (IllegalAccessException e) {throw new RuntimeException(e);}
}

2.2.调用UnSafe提供的CAS方法

Unsafe类中的提供了三个CAS操作方法：compareAndSwapObject()、compareAndSwapInt()和compareAndSwapLong()。

这三个方法的作用是原子地更新Java变量的值，只有在当前值等于期望值时才进行更新。它们的共同特点是具有volatile读写的内存语义。

• compareAndSwapObject()方法用于原子地更新对象引用类型的变量。它接收四个参数：要操作的对象、变量的偏移量、期望值和新值。如果对象内存中偏移量处的值等于期望值，则将该位置的值更新为新值，并返回操作是否成功的布尔值。

  • @ForceInline
    public final boolean compareAndSwapObject(Object o, long offset,Object expected,Object x) {return theInternalUnsafe.compareAndSetReference(o, offset, expected, x);
    }
    

• compareAndSwapInt()方法用于原子地更新int类型的变量。它的参数和行为与compareAndSwapObject()方法类似，只是操作的数据类型不同。

  • @ForceInline
    public final boolean compareAndSwapInt(Object o, long offset,int expected,int x) {return theInternalUnsafe.compareAndSetInt(o, offset, expected, x);
    }
    

• compareAndSwapLong()方法用于原子地更新long类型的变量。它的参数和行为与compareAndSwapObject()方法类似，只是操作的数据类型不同。

  • @ForceInline
    public final boolean compareAndSwapLong(Object o, long offset,long expected,long x) {return theInternalUnsafe.compareAndSetLong(o, offset, expected, x);
    }
    

这些CAS操作方法在底层都使用了Unsafe类内部的方法，如compareAndSetReference()、compareAndSetInt()和compareAndSetLong()，这些方法是基于硬件指令实现的原子操作。

UnSafe的CAS操作会将 第一个参数（对象的指针，地址）和第二个参数（字段偏移量）组合一起，计算出最终内存操作地址

2.3.调用Unsafe提供的偏移量相关

Unsafe类提供了两个方法来获取字段的偏移量：staticFieldOffset()和objectFieldOffset()。

1. staticFieldOffset()

   @ForceInline
   public long staticFieldOffset(Field f) {if (f == null) {throw new NullPointerException();}Class<?> declaringClass = f.getDeclaringClass();if (declaringClass.isHidden()) {throw new UnsupportedOperationException("can't get field offset on a hidden class: " + f);}if (declaringClass.isRecord()) {throw new UnsupportedOperationException("can't get field offset on a record class: " + f);}return theInternalUnsafe.staticFieldOffset(f);
   }
   // 最终调用 
   private native long staticFieldOffset0(Field f);

   staticFieldOffset()方法用于获取静态字段的偏移量。它接收一个Field对象作为参数，表示要获取偏移量的字段。该方法返回一个long类型的值，表示字段在内存中的偏移量。

   在使用staticFieldOffset()方法之前，需要确保传入的字段对象不为null。方法内部还会进行一些额外的检查，例如检查字段所在的类是否是隐藏类或记录类。

2. objectFieldOffset()

   @ForceInline
   public long objectFieldOffset(Field f) {if (f == null) {throw new NullPointerException();}Class<?> declaringClass = f.getDeclaringClass();if (declaringClass.isHidden()) {throw new UnsupportedOperationException("can't get field offset on a hidden class: " + f);}if (declaringClass.isRecord()) {throw new UnsupportedOperationException("can't get field offset on a record class: " + f);}return theInternalUnsafe.objectFieldOffset(f);
   }// 最终调用 
   private native long objectFieldOffset0(Field f);
   

   objectFieldOffset()方法用于获取对象字段的偏移量。它的使用方式和staticFieldOffset()方法类似，接收一个Field对象作为参数，并返回字段的偏移量。

   同样，使用objectFieldOffset()方法之前，需要确保传入的字段对象不为null。方法内部也会进行类的隐藏性和是否为记录类的检查。

这些偏移量可以在CAS操作中使用，通过偏移量可以直接访问和修改字段的值，而无需通过对象引用。但是需要注意的是，直接使用偏移量进行字段操作需要非常小心，因为它绕过了Java语言的访问控制机制，可能会导致不安全或破坏封装性的操作。在正常情况下，应该使用正式的访问方法（getter和setter）来访问和修改字段的值。

2.4.CAS无锁编程

CAS是一种无锁算法，该算法依赖两个关键值，期望值 和 新值，底层的CPU利用原子操作判断内存的原值和期望的值是否相等，如果相等，就会给内存的地址赋上新值，否则不做任何操作。

对于CAS操作，可以通过以下三个步骤来说明其流程：

1. 获取期望值：
   CAS操作首先从内存中读取变量的当前值作为期望值。这个期望值是在进行CAS操作之前由应用程序指定的。它用于比较内存中的原值是否与期望值相等。
2. 计算需要替换值：
   如果内存中的原值与期望值相等，说明当前变量的值满足CAS操作的条件。在这种情况下，应用程序可以计算出需要替换的新值。这个新值可能基于当前的变量值和其他相关的计算逻辑。
3. 更新值：
   在CAS操作中，如果内存中的原值与期望值相等，CAS操作会将计算得到的新值尝试写入内存。这个更新操作是原子的，它通过底层的硬件指令保证了操作的原子性和线程安全性。如果更新成功，说明CAS操作成功，变量的值已被更新为新值；否则，说明在CAS操作期间其他线程修改了变量的值，CAS操作失败，需要重新尝试或执行其他的处理逻辑。

下面我们通过一个简单案例来了解一下CAS的一个流程

2.4.1.使用cas进行无锁安全自增案例

package com.hrfan.java_se_base.base.thread.cas.unsafe;import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import sun.misc.Unsafe;import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicInteger;public class SpinLockTest {private static final Logger log = LoggerFactory.getLogger(SpinLockTest.class);private static final Unsafe unsafe = getUnsafe();private static final long valueOffset;private volatile int value = 0;private AtomicInteger failCount = new AtomicInteger(0);static {try {valueOffset = unsafe.objectFieldOffset(SpinLockTest.class.getDeclaredField("value"));log.error("cas偏移量：{}", valueOffset);} catch (NoSuchFieldException e) {throw new Error(e);}}private static Unsafe getUnsafe() {try {java.lang.reflect.Field field = Unsafe.class.getDeclaredField("theUnsafe");field.setAccessible(true);return (Unsafe) field.get(null);} catch (Exception e) {throw new RuntimeException("Failed to obtain Unsafe instance", e);}}// 自旋进行等待 直到赋值成功！public void incrementAndPrint() {// 使用Unsafe的compareAndSwapInt方法进行自增操作int oldValue, newValue;do {// 获取旧的值oldValue = unsafe.getIntVolatile(this, valueOffset);// 设置新的值newValue = oldValue + 1;} while (!unsafe.compareAndSwapInt(this, valueOffset, oldValue, newValue));}public static void main(String[] args) throws InterruptedException {SpinLockTest lock = new SpinLockTest();CountDownLatch latch = new CountDownLatch(10);for (int i = 0; i < 10; i++) {new Thread(() -> {for (int j = 0; j < 1000; j++) {lock.incrementAndPrint();}latch.countDown();}).start();}// 等待全部线程执行完毕latch.await();// 输出最终结果值log.error("最终累加值：{}", lock.value);}
}

注意 为什么每次的偏移量都是12呢？
在 Java 中，每个对象的开头都有一个称为 Mark Word 的特殊字段，用于存储对象的一些标记和状态信息。Mark Word 的大小通常是机器字大小的整数倍，它的确切大小会随着 JVM 的具体实现而有所不同。

在大多数情况下，Mark Word 包含了对象的哈希码、锁状态、GC 信息等。在使用 Unsafe 类进行对象操作时，通过 objectFieldOffset 方法获取到的偏移量实际上是指向了对象中某个字段的相对位置，而这个相对位置是相对于对象起始地址的偏移量。

由于 Mark Word 是对象的头部信息，它的大小会影响到对象中其他字段的偏移量。具体来说，由于 Mark Word 的存在，对象中第一个字段的偏移量通常会是 Mark Word 的大小，因此每次获取对象中字段的偏移量时，相对于对象起始地址的偏移量会是固定的，也就是 Mark Word 的大小。

因此，每次获取的偏移量都是固定的值，是 Mark Word 的大小。其实就是 value属性的内存位置紧挨着Object Header之后，所以value属性的相对偏移量都是 12