14.CAS原理-EW帮帮网

文章目录

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

在这里插入图片描述

14.CAS原理

文章目录

CAS原理

1.什么是CAS

2.Unsafe类中的CAS方法

2.1.获取UnSafe实例

2.2.调用UnSafe提供的CAS方法

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

2.4.CAS无锁编程

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

网站公告

今日签到

热门文章

最新发布