14.CAS原理

小饭团~

于 2024-05-13 06:50:36 发布

阅读量974

点赞数 10

分类专栏：多线程文章标签： Java

本文链接：https://blog.csdn.net/q1372302825/article/details/138781092

版权

多线程专栏收录该内容

28 篇文章 0 订阅

订阅专栏

文章目录

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

在这里插入图片描述

小饭团~

关注

10
点赞
踩
23

收藏

觉得还不错? 一键收藏
0
评论
14.CAS原理

JDK 5 所增加的 JUC（java.util.concurrent）并发包对操作系统的底层的CAS原子操作进行了封装，为上层Java程序提供了CAS操作的APICAS（Compare and Swap）是一种并发编程中的原子操作，用于实现多线程环境下的无锁同步。内存位置（或者说是要操作的变量的引用）、期望值和新值。首先，读取内存位置的当前值，这是期望值。然后，将期望值与内存位置的当前值进行比较。如果相等，则说明内存位置的值没有被其他线程修改，可以进行更新操作。
复制链接

扫一扫