【多线程】有了解过 CAS 和原子操作吗？

SueWakeup

已于 2024-03-23 18:25:44 修改

阅读量1.4k

点赞数 42

分类专栏：为祖国的科技进步添砖Java 学习Java 文章标签： java CAS 原子操作乐观锁悲观锁

于 2024-03-23 18:14:29 首次发布

本文链接：https://blog.csdn.net/LikewaterwithLi/article/details/136968392

版权

为祖国的科技进步添砖Java 同时被 2 个专栏收录

43 篇文章 1 订阅

订阅专栏

学习Java

16 篇文章 0 订阅

订阅专栏

个人主页：SueWakeup

系列专栏：学习Java

个性签名：人生乏味啊，我欲令之光怪陆离

前言

在高并发的业务场景下，线程安全可以通过 synchronized 或 Lock 来保证同步，从而达到线程安全的目的。但是， synchronized 或 Lock 都是基于互斥锁的思想实现，加锁和释放锁的过程中都会带来性能损耗问题。

除了 synchronized 或 Lock 以外，还可以通过 JUC（java.util.concurrent.xxx）提供的 CAS 机制实现无锁的解决方案，它是基于乐观锁的思想方案，实现非阻塞的同步方式，从而保证线程安全。

悲观锁和乐观锁

悲观锁
- 在持有数据的时候将资源或数据加锁，认为数据很可能会被其他人所修改（线程冲突）
- 适用于写多读少的场景，避免频繁失败和重试影响性能
乐观锁
- 程序不加锁，认为资源和数据不会被别人所修改（线程冲突），但在进行写入操作的时候会判断当前数据是否被修改过，一旦有冲突发生，通常采用一种称为 CAS 的技术保证线程执行的安全性
- 适用于读多写少的场景，避免加锁影响性能

什么是 CAS ?

CAS 全称 “比较并交换”（Compare And Swap）。是一种原子操作
现代 CPU 广泛支持的一种对内存中的共享数据进行操作的特殊指令。进行读写操作时， CPU 会比较内存中某个值是否和预期的值相同，如果相同则将这个值更新为新值，不相同则不做更新
无锁的线程同步解决方案，基于 “乐观锁” 思想的操作，保证多线程并发中保障共享资源的原子操作，相对于 synchronized 或 Lock 来说，是一种轻量级的实现方案
使用案例：
- Java 的核心类库中 AtomicInteger、ConcurrentHashMap 都是基于 CAS 机制实现原子操作（Java 中的 CAS 机制是通过 Unsafe 类提供的 compareAndSwapXXX() 等 CAS 方法实现，底层通过 CPU 指令 cmpxchg 实现）

什么是原子操作？

原子操作是指不能被线程调度打断的操作。通常是一系列操作，该系列操作从执行开始到执行结束期间不会发生线程切换（原子操作不能被中断）。

CAS 执行流程

假设内存中存在一个变量 i，它在内存中对应的值是 A（第一次读取），此时经过业务计算处理后，结算结果为新值 B，在更新之前会再去读 i 现在的值 C。如果 A 和 C 相同，代表业务计算处理的过程中 i 的值并没有发生变化，才会把 i 更新（交换）为新值 B。如果不相同，那说明在业务计算时，i 的值发生了变化，则不进行更新操作。最后 CPU 会将旧的数值返回。

总结：要更新的值是否等于旧值，如果等于，将该值设置为新值；如果不等于，将旧数值返回

Java 中的原子操作类(基于 CAS 的 AtomicInteger)

Java 无法控制线程的切换，所以 Java 中 CAS 操作采用 native 方法，底层采用 C 或 C++ 实现

AtomicInteger 是 java.util.concurrent.atomic 包下的一个子类，该包下还有 AtomicBoolean ,AtomicLong,AtomicLongArray,AtomicReference 等原子类，主要用于在高并发环境下，保证线程安全。

AtomicInteger 常用方法

// AtomicInteger 常用方法

public final int get(); // 获取当前值
public final int getAndSet(int newValue); // 获取当前的值，并设置新的值
public final int getAndIncrement(); // 获取当前的值，并自增 1
public final int getAndDecrement(); // 获取当前的值，并自减 1
public final int getAndAdd(int delta); // 获取当前的值，并自增指定值

AtomicInteger 核心源码

public class AtomicInteger extends Number implements java.io.Serializable {
    //底层访问对象
    private static final Unsafe unsafe = Unsafe.getUnsafe();
    private static final long valueOffset;

    static {
        try {
            //基于 Unsafe 对象获取 value 字段相对当前对象的“起始地址”的偏移量

            valueOffset = unsafe.objectFieldOffset
                (AtomicInteger.class.getDeclaredField("value"));
        } catch (Exception ex) { throw new Error(ex); }
    }

    private volatile int value;

    // 获取当前的值
    public AtomicInteger(int initialValue) {
        value = initialValue;
    }
    

    /* 获取当前的值，并自增 1
     * 1.this:当前的实例
     * 2.valueOffset:value实例变量的偏移量
     * 3.delta:自增 1
    */
    public final int getAndIncrement() {
        return unsafe.getAndAddInt(this, valueOffset, 1);
    }


    /* 获取当前的值，并自增指定值
     * 1.this:当前的实例
     * 2.valueOffset:value实例变量的偏移量
     * 3.delta:自增指定值
    */
    public final int getAndAdd(int delta) {
        return unsafe.getAndAddInt(this, valueOffset, delta);
    }

}

Unsafe

在 AtomicInteger 核心源码中，可以看到 CAS 机制是通过 Unsafe 类实现。

sum.misc.Unsafe 是 JDK 提供的一个底层工具类。它提供内存操作、CAS、对象操作等 “不安全” 的功能，来让 JDK 能够使用 Java 代码来实现原本需要使用 native 本地方法才可以实现的功能。由于，该类不应该在 JDK 核心类库之外使用，所以被命名为 Unsafe（不安全）

Unsafe 实现 CAS 的工作原理

AtomicInteger 类

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

Unsafe 类

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

首先读取当前对象 var1 在主内存中的值，并保存到 var5 中，然后通过循环，判断当前对象在主内存中的值是否等于 var5，如果相同，就自增（交换 var5 与 var5 + var4 两个值），否则继续循环，重新获取 var 值。

在上述逻辑中核心方法是 compareAndSwapInt()方法，它是一个 native 方法，这个方法编译后的 CPU 指令是 cmpxchg，该指令连续执行，不会被打断，所以可以保证原子性。

在 getAndAddInt()方法中通过 do...while 循环操作实现自旋锁：当预期值和主内存中的值不等时，就重新获取主内存中的值。

CAS 的缺点

循环时间长，开销大
- 在 Unsafe 的实现中使用了自旋锁的机制。在该环境如果 CAS 操作失败，就需要循环进行 CAS 操作（do...while 循环同时读取最新的期望值），如果长时间都不成功的话，那么会造成 CPU 极大的开销
只能保证一个共享变量的原子操作
- 在最初的实例中，可以看出是针对一个共享变量使用了 CAS 机制，可以保证原子性操作。但如果存在多个共享变量，或一整个代码块的逻辑需要保证线程安全，CAS 就无法保证原子性操作
- 此时，需要考虑采用加锁方式（悲观锁）保证原子性
ABA 问题
- 线程 P1 在共享变量中读到值 A
- 线程 P1 被抢占，线程 P2 开始执行
- 线程 P2 把共享变量里的值从 A 改成了 B，再改回到 A
- 线程 P2 被抢占，线程 P1 开始执行
- 线程 P1 回来看到共享变量里的值没有被改变，继续执行