文章目录
- CAS原理
- 1.什么是CAS
- 2.Unsafe类中的CAS方法
- 2.1.获取UnSafe实例
- 2.2.调用UnSafe提供的CAS方法
- 2.3.调用Unsafe提供的偏移量相关
- 2.4.CAS无锁编程
- 2.4.1.使用cas进行无锁安全自增案例
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操作的执行过程如下：
- 首先，读取内存位置的当前值，这是期望值。
- 然后，将期望值与内存位置的当前值进行比较。如果相等，则说明内存位置的值没有被其他线程修改，可以进行更新操作。
- 如果相等，将内存位置的当前值修改为新值。如果不相等，说明内存位置的值已经被其他线程修改，CAS操作失败。
- 最后，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操作的一般流程：
- 获取
Unsafe实例：
Unsafe类的构造函数是私有的，因此无法直接实例化它。通常可以通过反射或者调用Unsafe.getUnsafe()方法来获取Unsafe的实例。 - 获取要操作的变量的偏移量：
在执行CAS操作之前，需要获取要操作的变量在内存中的偏移量。偏移量表示变量相对于对象头的位置。可以使用Unsafe.objectFieldOffset()方法来获取变量的偏移量。 - 执行CAS操作：
通过调用Unsafe.compareAndSwapXXX()方法来执行CAS操作，其中XXX表示要操作的数据类型（如Int、Long、Object等）。compareAndSwapXXX()方法接收四个参数：要操作的对象、变量的偏移量、期望值和新值。方法会比较对象内存中偏移量处的值与期望值是否相等，如果相等，则将该位置的值更新为新值，并返回操作是否成功的布尔值。 - 锁定和解锁：
在执行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()。
-
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。方法内部还会进行一些额外的检查，例如检查字段所在的类是否是隐藏类或记录类。 -
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操作，可以通过以下三个步骤来说明其流程：
- 获取期望值：
CAS操作首先从内存中读取变量的当前值作为期望值。这个期望值是在进行CAS操作之前由应用程序指定的。它用于比较内存中的原值是否与期望值相等。 - 计算需要替换值：
如果内存中的原值与期望值相等，说明当前变量的值满足CAS操作的条件。在这种情况下，应用程序可以计算出需要替换的新值。这个新值可能基于当前的变量值和其他相关的计算逻辑。 - 更新值：
在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
