CAS

原子类

java.util.concurrent.atomic包下的所有相关类和API

没有CAS之前

多线程环境不使用原子类保证线程安全i++（基本数据类型），需要用到synchronized锁，但是它比较重，效率不高。

public class Test {
    volatile int number = 0;
    
    /**
     * 读取
     */
    public int getNumber() {
        return number;
    }

    /**
     * 写入加锁保证原子性
     */
    public synchronized void setNumber() {
        number++;
    }
}

使用CAS之后

多线程情况下使用原子类保证线程安全（基本数据类型），类似于乐观锁。可以看到没有使用到 synchroized

public class CasDemo {

    AtomicInteger atomicInteger = new AtomicInteger();

    
    public int getAtomicInteger() {
        return atomicInteger.get();
    }

    public void setAtomicInteger() {
        atomicInteger.getAndIncrement(); //先读再加
    }
}

CAS是什么

compare and swap的缩写，中文翻译成比较并交换实现并发算法时常用到的一种技术。
它包含三个操作数一一内存位置、预期原值及更新值。执行CAS操作的时候，将内存位置的值与预期原值比较:
- 如果相匹配，那么处理器会自动将该位置值更新为新值
- 如果不匹配，处理器不做任何操作，多个线程同时执行CAS操作只有一个会成功。

CAS原理

CAS (CompareAndSwap)，CAS有3个操作数，位置内存值V，旧的预期值A，要修改的更新值B。当且仅当旧的预期值A和内存值V相同时，将内存值V修改为B，否则什么都不做或重来当它重来重试的这种行为成为----自旋! !

现有A、B、C三个线程, 内存值为5, A线程执行++等于6将值写回的时候发现旧的预期值与内存值不想等了, 所以就不更新了, 但是会发生自旋去执行他这步++操作

CASDemo代码

第一次执行为true说明修改成功因为第一次的预期值和初始值是一样的，第二次执行为false修改失败因为第一次已经将值成功修改为2022了，所以导致预期值和内存值不匹配修改失败。

public class CasDemo {

    public static void main(String[] args) {

        AtomicInteger atomicInteger = new AtomicInteger(5);

        /**
         * atomicInteger.compareAndSet
         * 第一个参数：预期值
         * 第二个参数：更新值
         */
        System.out.println(atomicInteger.compareAndSet(5, 2022) + "\t" + atomicInteger.get());
        System.out.println(atomicInteger.compareAndSet(5, 2022) + "\t" + atomicInteger.get());
    }
}

// 结果
true	2022
false	2022

硬件级别保证

CAS是JDK提供的非阻塞原子性操作，它通过硬件保证了比较-更新的原子性。它是非阻塞的且自身原子性，也就是说这玩意效率更高且通过硬件保证，说明这玩意更可靠。
CAS是一条CPU的原子指令（cmpxchg指令），不会造成所谓的数据不一致问题，Unsafe提供的CAS方法（如compareAndSwapXXX）底层实现即为CPU指令cmpxchg。
执行cmpxchg指令的时候，会判断当前系统是否为多核系统，如果是就给总线加锁，只有一个线程会对总线加锁成功，加锁成功之后会执行cas操作，也就是说CAS的原子性实际上是CPU实现的，其实在这一点上还是有排他锁的，只是比起用synchronized，这里的排他时间要短的多，所以在多线程情况下性能会比较好

源码分析

// 调用了Unsafe类
public final boolean compareAndSet(int expect, int update) {
    return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}

// 调用了native方法
public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);

public final native boolean compareAndSwapObject(Object var1, long var2, Object var4, Object var5);

public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);

public final native boolean compareAndSwapLong(Object var1, long var2, long var4, long var6);

上面三个方法都是类似的，主要对4个参数做一下说明。
- var1：表示要操作的对象
- var2：表示要操作对象中属性地址的偏移量
- var4：表示需要修改数据的期望的值
- var5/var6：表示需要修改为的新值

CAS底层原理？如果知道，谈谈你对UnSafe的理解

UnSafe.class

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;
}

1. UnSafe

CAS这个理念，落地就是Unsafe类。它是CAS的核心类，由于Java方法无法直接访问底层系统，需要通过本地（native）方法来访问，Unsafe相当于一个后门，基于该类可以直接操作特定内存的数据。Unsafe类存在于sun.misc包中，其内部方法操作可以像C的指针一样直接操作内存，因为Java中CAS操作的执行依赖于Unsafe类的方法。

UnSafe类的位置：你的jdk包位置 -> jre -> lib -> 解压rt.jar -> sun -> misc -> UnSafe.class

注意Unsafe类中的所有方法都是native修饰的，也就是说Unsafe类中的方法都直接调用操作系统底层资源执行相应任务。

2. valueOffse

表示该变量值在内存中的偏移地址，因为Unsafe就是根据内存偏移地址获取数据的。

public final int getAndIncrement() {
    // this：当前对象、valueOffset：偏移地址、1：加一
    return unsafe.getAndAddInt(this, valueOffset, 1);
}

3. value

保证了多线程之间的内存可见性

我们知道i++线程不安全的，那atomicInteger.getAndIncrement()

CAS的全称为Compare-And-Swap，它是一条CPU并发原语。它的功能是判断内存某个位置的值是否为预期值，如果是则更改为新的值，这个过程是原子的。

AtomicInteger 类主要利用 CAS (compare and swap) + volatile 和 native 方法来保证原子操作，从而避免 synchronized 的高开销，执行效率大为提升。

CAS并发原语体现在JAVA语言中就是sun.misc.Unsafe类中的各个方法。调用UnSafe类中的CAS方法，JVM会帮我们实现出CAS汇编指令 。这是一种完全依赖于硬件的功能，通过它实现了原子操作。再次强调，由于CAS是一种系统原语，原语属于操作系统用语范畴，是由若干条指令组成的，用于完成某个功能的一个过程，并且原语的执行必须是连续的，在执行过程中不允许被中断，也就是说CAS是一条CPU的原子指令，不会造成所谓的数据不一致问题。

源码分析

调用 AtomicInteger().getAndIncrement(); 方法

new AtomicInteger().getAndIncrement();

查看底层方法AtomicInteger.java文件

public final int getAndIncrement() {
    return unsafe.getAndAddInt(this, valueOffset, 1);
}

UnSafe.class

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;
}

UnSafe.class

public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);

OpenJDK源码中查看Unsafe.java，这里while体现了自旋的思想

/**
 * Atomically adds the given value to the current value of a field
 * or array element within the given object <code>o</code>
 * at the given <code>offset</code>.
 *
 * @param o object/array to update the field/element in
 * @param offset field/element offset
 * @param delta the value to add
 * @return the previous value
 * @since 1.8
 */
public final long getAndAddLong(Object o, long offset, long delta) {
    long v;
    do {
        v = getLongVolatile(o, offset);
    } while (!compareAndSwapLong(o, offset, v, v + delta));
    return v;
}

原理
假设线程A和线程B两个线程同时执行getAndAddInt操作（分别跑在不同CPU上）：

AtomicInteger里面的value原始值为3，即主内存中AtomicInteger的value为3，根据JMM模型，线程A和线程B各自持有一份值为3的value的副本分别到各自的工作内存。
线程A通过getIntVolatile(var1, var2)拿到value值3，这时线程A被挂起。
线程B也通过getIntVolatile(var1, var2)方法获取到value值3，此时刚好线程B没有被挂起并执行compareAndSwapInt方法比较内存值也为3，成功修改内存值为4，线程B打完收工，一切OK。
这时线程A恢复，执行compareAndSwapInt方法比较，发现自己手里的值数字3和主内存的值数字4不一致，说明该值已经被其它线程抢先一步修改过了，那A线程本次修改失败，只能重新读取重新来一遍了：自旋。
线程A重新获取value值，因为变量value被volatile修饰，所以其它线程对它的修改，线程A总是能够看到，线程A继续执行compareAndSwapInt进行比较替换，直到成功。

底层汇编

Unsafe类中的compareAndSwapInt，是一个本地方法，该方法的实现位于UnSafe.cpp中

UNSAFE_ENTRY(jboolean, Unsafe_CompareAndSwapInt(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jint e, jint x))
  UnsafeWrapper("Unsafe_CompareAndSwapInt");
  oop p = JNIHandles::resolve(obj);
  // 先想办法拿到变量value在内存中的地址，根据偏移量valueOffset，计算 value 的地址
  jint* addr = (jint *) index_oop_from_field_offset_long(p, offset);
  // 调用 Atomic 中的函数 cmpxchg 来进行比较交换，其中参数x是要交换的值，e是要比较的值
  // cas成功，返回期望值e，等于e，此方法返回true;
  // cas失败，返回内存中的value值，不等于e，此方法返回false
  return (jint)(Atomic::cmpxchg(x, addr, e)) == e;
UNSAFE_END

// (Atomic::cmpxchg(x, addr, e)) == e：JDK提供的CAS机制，在汇编层级会禁止变量两侧的指令优化，然后使用cmpxchg指令比较并更新变量值（原子性）

cmpxchg是什么 atomic.cpp文件

// 调用 Atomic 中的函数 cmpxchg来进行比较交换，其中参数x是即将更新的值，参数e是原内存的值
return (jint)(Atomic::cmpxchg(x, addr, e)) == e;

unsigned Atomic::cmpxchg(unsigned int exchange_value,
                         volatile unsigned int* dest, unsigned int compare_value) {
  assert(sizeof(unsigned int) == sizeof(jint), "more work to do");
  // 根据操作系统类型调用不同平台下的重载函数，这个在预编译期间编译器会决定调用哪个平台下的重载函数
  return (unsigned int)Atomic::cmpxchg((jint)exchange_value, (volatile jint*)dest, (jint)compare_value);
}

atomic.inline.hpp文件，会根据操作系统和CPU架构选择cmpxchg方法不同的实现我们这边是windows

// Linux
#ifdef TARGET_OS_ARCH_linux_x86
# include "atomic_linux_x86.inline.hpp"
#endif
#ifdef TARGET_OS_ARCH_linux_sparc
# include "atomic_linux_sparc.inline.hpp"
#endif
#ifdef TARGET_OS_ARCH_linux_zero
# include "atomic_linux_zero.inline.hpp"
#endif
#ifdef TARGET_OS_ARCH_linux_arm
# include "atomic_linux_arm.inline.hpp"
#endif
#ifdef TARGET_OS_ARCH_linux_ppc
# include "atomic_linux_ppc.inline.hpp"
#endif

// Solaris
#ifdef TARGET_OS_ARCH_solaris_x86
# include "atomic_solaris_x86.inline.hpp"
#endif
#ifdef TARGET_OS_ARCH_solaris_sparc
# include "atomic_solaris_sparc.inline.hpp"
#endif

// Windows
#ifdef TARGET_OS_ARCH_windows_x86
# include "atomic_windows_x86.inline.hpp"
#endif

// BSD
#ifdef TARGET_OS_ARCH_bsd_x86
# include "atomic_bsd_x86.inline.hpp"
#endif
#ifdef TARGET_OS_ARCH_bsd_zero
# include "atomic_bsd_zero.inline.hpp"
#endif

atomic_windows_x86.inline.hpp文件

inline jint     Atomic::cmpxchg    (jint     exchange_value, volatile jint*     dest, jint     compare_value) {
  // 判断是否是多核CPU
  int mp = os::is_MP();
  __asm {
    // 三个move指令表示的是将后面的值移动到前面的寄存器上
    mov edx, dest
    mov ecx, exchange_value
    mov eax, compare_value
    // CPU原语级别，CPU触发
    LOCK_IF_MP(mp)
    // 比较并交换指令
    // cmpxchg: 即“比较并交换”指令
    // dword: 全称是 double word 表示两个字，一共四个字节
    // ptr: 全称是 pointer，与前面的 dword 连起来使用，表明访问的内存单元是一个双字单元 
    // 将 eax 寄存器中的值（compare_value）与 [edx] 双字内存单元中的值进行对比，
    // 如果相同，则将 ecx 寄存器中的值（exchange_value）存入 [edx] 内存单元中
    cmpxchg dword ptr [edx], ecx
  }
}

总结
CAS是靠硬件实现的从而在硬件层面提升效率，最底层还是交给硬件来保证原子性和可见性实现方式是基于硬件平台的汇编指令，在intel的CPU中(X86机器上)，使用的是汇编指令cmpxchg指令。核心思想就是：比较要更新变量的值V和预期值E（compare），相等才会将V的值设为新值N（swap）如果不相等自旋再来。

自定义原子引用

上面讲了AtomicInteger原子整型，可否有其他原子类型? 比如AtomicBook、AtomicOrde
答：可以，丢入泛型中Class AtomicReference<V>
案列

@Getter
@ToString
@AllArgsConstructor
class User {

    String userName;

    Integer age;
}

/**
 * @author zjh
 */
public class AtomicReferenceDemo {

    public static void main(String[] args) {

        AtomicReference<User> atomicReference = new AtomicReference<>();

        User zs = new User("zs", 22);
        User ls = new User("ls", 28);

        atomicReference.set(zs);

        System.out.println(atomicReference.compareAndSet(zs, ls) + "\t" + atomicReference.get());
        System.out.println(atomicReference.compareAndSet(zs, ls) + "\t" + atomicReference.get());
    }
}

CAS与自旋锁

概述

CAS 是实现自旋锁的基础，CAS 利用 CPU 指令保证了操作的原子性，以达到锁的效果，至于自旋呢，看字面意思也很明白，自己旋转。是指尝试获取锁的线程不会立即阻寒，而是采用循环的方式去尝试获取锁，当线程发现锁被占用时，会不断循环判断锁的状态，直到获取。这样的好处是减少线程上下文切换的消耗，缺点是循环会消耗CPU

CAS 是实现自旋锁的基础，自旋翻译成人话就是循环，一般是用一个无限循环实现。这样一来，一个无限循环中，执行一个CAS 操作。
- 当操作成功返回 true 时，循环结束:
- 当返回 false 时，接着执行循环，继续尝试 CAS 操作，直到返回 true。

/**
 * Atomically adds the given value to the current value of a field
 * or array element within the given object <code>o</code>
 * at the given <code>offset</code>.
 *
 * @param o object/array to update the field/element in
 * @param offset field/element offset
 * @param delta the value to add
 * @return the previous value
 * @since 1.8
 */
public final long getAndAddLong(Object o, long offset, long delta) {
    long v;
    do {
        v = getLongVolatile(o, offset);
    } while (!compareAndSwapLong(o, offset, v, v + delta));
    return v;
}

实现一个自旋锁

/**
 * @author zjh
 *
 * 题目：实现一个自旋锁
 * 自旋锁好处：循环比较获取没有类似wait的阻塞。
 * 通过CAS操作完成自旋锁，A线程先进来调用myLock方法自己持有锁5秒钟，B随后进来后发现
 * 当前有线程持有锁，不是null，所以只能通过自旋等待，直到A释放锁后B随后抢到。
 */
public class SpinLockDemo {

    AtomicReference<Thread> atomicReference = new AtomicReference<>();

    public void lock() {
        Thread thread = Thread.currentThread();
        System.out.println(Thread.currentThread().getName() + "\t ------come in");
        while (!atomicReference.compareAndSet(null, thread)) {
            // 线程自旋中
            System.out.println(Thread.currentThread().getName() + "\t ------自旋中...");
            try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {throw new RuntimeException(e);}
        }
    }

    public void unlock() {
        Thread thread = Thread.currentThread();
        atomicReference.compareAndSet(thread, null);
        System.out.println(Thread.currentThread().getName() + "\t ------task over, unlock...");
    }

    public static void main(String[] args) {

        SpinLockDemo spinLockDemo = new SpinLockDemo();

        new Thread(() -> {
            spinLockDemo.lock();
            // 暂停几秒线程
            try {TimeUnit.SECONDS.sleep(5);} catch (InterruptedException e) {throw new RuntimeException(e);}
            spinLockDemo.unlock();
        }, "A").start();

        // 暂停500毫秒, 线程A先于线程B
        try {TimeUnit.MICROSECONDS.sleep(5);} catch (InterruptedException e) {throw new RuntimeException(e);}

        new Thread(() -> {
            spinLockDemo.lock();

            spinLockDemo.unlock();
        }, "B").start();
    }
}

CAS缺点

1. 循环时间长开销很大

do while如果它一直自旋会一直占用CPU时间，如果CAS失败，会一直进行尝试。如果CAS长时间一直不成功，可能会给CPU带来很大的开销。

public final int getAndAddInt(Object o, long offset, int delta) {
    int v;
    do {
        v = getIntVolatile(o, offset);
    } while (!compareAndSwapInt(o, offset, v, v + delta));
    return v;
}

2. 引出来ABA问题

CAS算法实现一个重要前提需要取出内存中某时刻的数据并在当下时刻比较并替换，那么在这个时间差类会导致数据的变化。比如说一个线程1从内存位置V中取出A，这时候另一个线程2也从内存中取出A，并且线程2进行了一些操作将值变成了B，然后线程2又将V位置的数据变成A，这时候线程1进行CAS操作发现内存中仍然是A，然后线程1操作成功。尽管线程1的CAS操作成功，但是不代表这个过程就是没有问题的。

解决

AtomicStampedReference版本号（注意区分前面的Class AtomicReference）
构造方法

正常情况

@NoArgsConstructor
@AllArgsConstructor
@Data
class Book{

    private Integer id;

    private String bookName;
}

/**
 * @author zjh
 */
public class AtomicStampedDemo {

    public static void main(String[] args) {
        Book javaBook = new Book(1, "javaBook");
        AtomicStampedReference<Book> stampedReference = new AtomicStampedReference<>(javaBook,1);
        System.out.println(stampedReference.getReference() + "\t" + stampedReference.getStamp());

        Book mysqlBook = new Book(2, "mysqlBook");

        boolean b;
        b = stampedReference.compareAndSet(javaBook, mysqlBook, stampedReference.getStamp(), stampedReference.getStamp() + 1);
        System.out.println(b + "\t" + stampedReference.getReference() + "\t" + stampedReference.getStamp());
    }
}

// 结果
Book(id=1, bookName=javaBook)	1
true	Book(id=2, bookName=mysqlBook)	2

ABA复现（单线程情况下）

@NoArgsConstructor
@AllArgsConstructor
@Data
class Book{

    private Integer id;

    private String bookName;
}

/**
 * @author zjh
 */
public class AtomicStampedDemo {

    public static void main(String[] args) {
        Book javaBook = new Book(1, "javaBook");
        AtomicStampedReference<Book> stampedReference = new AtomicStampedReference<>(javaBook,1);
        System.out.println(stampedReference.getReference() + "\t" + stampedReference.getStamp());

        Book mysqlBook = new Book(2, "mysqlBook");

        boolean b;
        b = stampedReference.compareAndSet(javaBook, mysqlBook, stampedReference.getStamp(), stampedReference.getStamp() + 1);
        System.out.println(b + "\t" + stampedReference.getReference() + "\t" + stampedReference.getStamp());

        b = stampedReference.compareAndSet(mysqlBook, javaBook, stampedReference.getStamp(), stampedReference.getStamp() + 1);
        System.out.println(b + "\t" + stampedReference.getReference() + "\t" + stampedReference.getStamp());
    }
}

// 结果，第一行和第三行的结果是一样的但是版本号并不一致
Book(id=1, bookName=javaBook)	1
true	Book(id=2, bookName=mysqlBook)	2
true	Book(id=1, bookName=javaBook)	3

ABA复现（多线程情况下）

public class AbaDemo {

    static AtomicInteger atomicInteger = new AtomicInteger(100);

    public static void main(String[] args) {
        new Thread(() -> {
            atomicInteger.compareAndSet(100,101);
            try { TimeUnit.MILLISECONDS.sleep( 10 ); } catch (InterruptedException e) { e.printStackTrace(); };
            atomicInteger.compareAndSet(101,100); //这里中间就有人动过了，虽然值是不变的，假如不检查版本号，CAS就直接能成功了
        },"t1").start();

        new Thread(() -> {
            try { TimeUnit.MILLISECONDS.sleep( 200 ); } catch (InterruptedException e) { e.printStackTrace(); };
            System.out.println(atomicInteger.compareAndSet(100, 2022) + "\t" + atomicInteger.get());
        },"t2").start();
    }
}

// 结果
true	2022

ABA问题解决

/**
 * @author zjh
 */
public class AbaDemo {

    static AtomicStampedReference<Integer> atomicStampedReference = new AtomicStampedReference<>(100, 1);

    public static void main(String[] args) {
        new Thread(() -> {
            int stamp = atomicStampedReference.getStamp();
            System.out.println(Thread.currentThread().getName() + "\t 首次版本号:" + stamp);//1-----------初始获得一样的版本号

            // 暂停500毫秒，保证t4线程初始化拿到的版本号和我一样,
            try { TimeUnit.MILLISECONDS.sleep( 500 ); } catch (InterruptedException e) { e.printStackTrace(); }

            atomicStampedReference.compareAndSet(100,101, atomicStampedReference.getStamp(),atomicStampedReference.getStamp()+1);
            System.out.println(Thread.currentThread().getName() + "\t 2次版本号:" + atomicStampedReference.getStamp());

            atomicStampedReference.compareAndSet(101, 100, atomicStampedReference.getStamp(),atomicStampedReference.getStamp()+1);
            System.out.println(Thread.currentThread().getName() + "\t 3次版本号:" + atomicStampedReference.getStamp());
        },"t3").start();

        new Thread(() -> {
            int stamp = atomicStampedReference.getStamp();//记录一开始的版本号，并且写死
            System.out.println(Thread.currentThread().getName() + "\t 首次版本号:" + stamp);//1------------初始获得一样的版本号

            // 暂停1秒钟线程，等待上面的t3线程，发生了ABA问题
            try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace();}

            // 这个还是初始的版本号，但是实际上版本号被T3修改了，所以会失败
            boolean result = atomicStampedReference.compareAndSet(100, 2019, stamp, stamp + 1);
            System.out.println(Thread.currentThread().getName() + "\t"+result + "\t" + atomicStampedReference.getReference());
        },"t4").start();
    }
}

总结

版本号 + 比较要一起上

posted @ 2023-02-07 11:03 橙香五花肉阅读(81) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· 原子操作类之18罗汉增强

· Java锁

· CAS与自旋锁、ABA问题

· CAS机制与自旋锁

· 【并发】深度解析CAS原理与底层源码

阅读排行：
· DeepSeek 开源周回顾「GitHub 热点速览」
· 物流快递公司核心技术能力-地址解析分单基础技术分享
· .NET 10首个预览版发布：重大改进与新特性概览！
· AI与.NET技术实操系列（二）：开始使用ML.NET
· .NET10 - 预览版1新功能体验（一）

橙香五花肉

CAS

CAS

原子类

没有CAS之前

使用CAS之后

CAS是什么

CAS原理

CASDemo代码

硬件级别保证

源码分析

CAS底层原理？如果知道，谈谈你对UnSafe的理解

UnSafe.class

1. UnSafe

2. valueOffse

3. value

我们知道i++线程不安全的，那atomicInteger.getAndIncrement()

源码分析

底层汇编

自定义原子引用

CAS与自旋锁

概述

实现一个自旋锁

CAS缺点

1. 循环时间长开销很大

2. 引出来ABA问题

解决

正常情况

ABA复现（单线程情况下）

ABA复现（多线程情况下）

ABA问题解决

总结

公告

常用链接

最新随笔

随笔分类 (89)

随笔档案 (96)

阅读排行榜

推荐排行榜

最新评论