JUC CAS 和原子操作类

发布时间：2024年01月15日

文章目录

CAS（Compare-and-Swap）
java.util.concurrent.atomic 包中的类
- AtomicInteger 示例1：getAndIncrement 方法实现原子的 i++ 操作
CAS 的 ABA 问题示例
- 原子累加器
CAS 的优缺点

CAS（Compare-and-Swap）

CAS 是在多线程环境下操作共享资源，用于保证线程安全的技术。其是一种乐观锁的算法实现，本身不加锁。

CAS操作包含三个操作数

内存位置（V）
预期原值（A）
新值（B）

如果内存位置V的值与预期原值A相匹配，则将内存位置的值更新为B，并返回true；否则，不做任何操作并返回false。

比如原值为 V=10，线程1修改值为 B = 5，线程2修改值为 b = 3，CAS 操作的过程为

时间	线程1	线程2
1	读取内存值为预期值A = 10
2	判断当前的内存值与预期值是否相等 A == B	读取内存值为预期值A = 10
3	相等，更新内存值为B，则V = 5，返回 true	判断当前的内存值与预期值是否相等 A == B
4		不相等，不操作，返回 false

CAS 的判断和更新操作是原子的，意味着在线程1判断和更新之后线程2才能判断和更新。

java.util.concurrent.atomic 包中的类

基本数字类型的原子操作类
- AtomicInteger
- AtomicLong
- AtomicBoolean

常用方法有：

get()：获取原子类当前的值
getAndSet(int newValue)：设置当前值为newValue，并返回原值（CAS实现）
getAndIncrement()：设置当前值为当前值加1，并返回原值（CAS实现）
getAndDecrement()：设置当前值为当前值减1，并返回原值（CAS实现）
getAndAdd(int delta)：设置当前值为当前值加 delta，并返回原值（CAS实现）
getAndUpdate(IntUnaryOperator updateFunction)：设置当前值为当前值加 updateFunction.applyAsInt 方法返回值，并返回原值，updateFunction.applyAsInt 方法的参数为原值（CAS实现）
getAndAccumulate(int x, IntBinaryOperator accumulatorFunction)：有两个参数，第一个参数为原值，第二个参数为x。getAndAccumulate 表示修改当前值为 accumulatorFunction 执行之后的值（CAS实现）

incrementAndGet()：先加1再返回，返回的是修改后的值
decrementAndGet()：先减1再返回
addAndGet(int delta)：先加 delta 再返回
updateAndGet(IntUnaryOperator updateFunction)
accumulateAndGet(int x, IntBinaryOperator accumulatorFunction)

compareAndSet(int expect, int update) ：expect 表示修改时的原值，update 表示要修改为的值，如果修改成功方法返回 true，如果修改失败，方法返回 false。其底层使用了 Unsafe 类的 compareAndSwapInt 方法实现，可以说，以上的所有方法的实现都依赖于 unsafe.compareAndSwapInt 方法（具体可查看源码，源码其实非常简单）。

public final boolean compareAndSet(int expect, int update) {
   // this：当前对象，valueOffset：value属性的内存偏移量
   // （this和valueOffset应该能知道当前内存中value的值是多少就是，内存位置V）
   // expect 当前修改前读取到的值，这就是预期原值 A
   // 当前修改需要修改为的值，这就是新值 B
   return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}

Unsafe 对象大多数方法都是 native 方法，Unsafe 对象的 compareAndSwapXXX 方法对应操作系统底层的 cmpxchg 指令。所以，我们的原子操作，依赖于 unsafe 对象对应的底层操作系统指令来保证原子性。

我们再来看看 getAndUpdate(UnaryOperator<V> updateFunction)方法的源码：

public final V getAndUpdate(UnaryOperator<V> updateFunction) {
    V prev, next;
    do {
        prev = get();// 获取原值（在这之后，此原值可能被其他线程修改）
        next = updateFunction.apply(prev);// 计算出要修改为的值
    } while (!compareAndSet(prev, next));
    // compareAndSet 判断，如果此线程获取的原值已经被其他线程修改，compareAndSet 返回 false ，继续循环直到操作成功
    // 此 while 循环其实就是自旋
    return prev;
}
// 以上整个方法其实就是 CAS 的代码实现

引用类型的原子操作类（保护引用类型的修改）
- AtomicReference
- AtomicMarkableReference
- AtomicStampedReference
数组类型的原子操作类（保护数组元素的修改）
- AtomicIntegerArray
- AtomicLongArray
- AtomicReferenceArray
对象字段原子操作类（保护类中的字段的修改）
- AtomicIntegerFieldUpdater
- AtomicLongFieldUpdater
- AtomicReferenceFieldUpdater

AtomicInteger 示例1：getAndIncrement 方法实现原子的 i++ 操作

import lombok.Getter;
import lombok.extern.slf4j.Slf4j;

import java.util.Random;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

@Slf4j
public class NumberTest {

    public static void main(String[] args) throws InterruptedException {
        NumberIntContainer c1 = new NumberIntContainer();
        NumberCASContainer c2 = new NumberCASContainer();

        for(int i = 0; i < 10000;i++){
            new Thread(()->{
                c1.add();
                c2.add();
            },"t" + i).start();
        }

        TimeUnit.SECONDS.sleep(5);

        System.out.println("c1：" + c1.getNum());
        System.out.println("c2：" + c2.getNum().get());

    }

}

@Getter
class NumberIntContainer{
    // 此处添加 volatile 是不能解决问题的
    private int num = 0;

    // 如果添加 synchronized 关键字，可以解决问题，但 synchronized 是重量级锁
    public void add(){
        try {
            TimeUnit.MILLISECONDS.sleep(new Random().nextInt(100));
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        num++;
    }
}


@Getter
class NumberCASContainer{
    private AtomicInteger num = new AtomicInteger(0);

    public void add(){
        try {
            TimeUnit.MILLISECONDS.sleep(new Random().nextInt(100));
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        // getAndIncrement 与 i++ 类似，但其是原子操作，i++不是
        num.getAndIncrement();
    }
}

结果：

c1：9962
c2：10000

CAS 的 ABA 问题示例

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;

@Slf4j
public class ABATest {

    public static void main(String[] args) throws InterruptedException {
        // 公司账户 10w 元
        AtomicReference<Integer> num = new AtomicReference<>(10);

        new Thread(()->{
            int pre = num.get();
            try {
                // 等待，表示等
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            boolean rs = num.compareAndSet(pre,pre - 5);
            log.debug("正常出账：{} ",rs);
        },"正常出账").start();

        // 保障正常出账线程，先启动
        TimeUnit.NANOSECONDS.sleep(20);
        new Thread(()->{
            int pre = num.get();
            boolean rs = num.compareAndSet(pre,pre - 6);
            log.debug("挪用 6 万元，{}",rs);
            pre = num.get();
            rs = num.compareAndSet(pre, pre + 6);
            log.debug("填补 6 万元：{}",rs);

        },"有问题的财务").start();
    }

}

示例中，“有问题的财务”线程挪用了公司资金，又在“正常出账”线程之前填补了资金，导致“正常出账”线程也成功执行，而且无察觉且正常执行修改成功，这就是ABA问题。

22:11:57.085 [有问题的财务] DEBUG com.yyoo.thread.atomic.ABATest - 挪用 6 万元，true
22:11:57.089 [有问题的财务] DEBUG com.yyoo.thread.atomic.ABATest - 填补 6 万元：true
22:11:58.081 [正常出账] DEBUG com.yyoo.thread.atomic.ABATest - 正常出账：true

ABA 问题在大多数情况下没有问题，但如我们示例这种在实际应用中其实是有问题的，我们可以通过 AtomicStampedReference 来解决此问题。AtomicStampedReference 引入了 stamp （版本号）来区别每次的修改，即便修改后的值与之前的某个状态的值一致，其版本号也是不同的。AtomicMarkableReference 跟 AtomicStampedReference 的不同点在于，AtomicMarkableReference 的版本号是一个 boolean 值。

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicStampedReference;

@Slf4j
public class ABATest1 {

    public static void main(String[] args) throws InterruptedException {
        // 公司账户 10w 元，起始版本为 0
        AtomicStampedReference<Integer> num = new AtomicStampedReference <>(10,0);

        new Thread(()->{
            int pre = num.getReference(); // 获取当前的值
            int stamp = num.getStamp();// 获取当前的版本
            try {
                // 等待，表示等
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 如果原值和原版本号与当前的版本号不对应则修改失败
            boolean rs = num.compareAndSet(pre,pre - 5,stamp,stamp + 1);
            log.debug("正常出账：{} ",rs);
        },"正常出账").start();

        // 保障正常出账线程，先启动
        TimeUnit.NANOSECONDS.sleep(20);
        new Thread(()->{
            int pre = num.getReference();
            int stamp = num.getStamp();
            boolean rs = num.compareAndSet(pre,pre - 6,stamp,stamp + 1);
            log.debug("挪用 6 万元，{}",rs);
            pre = num.getReference();
            stamp = num.getStamp();
            rs = num.compareAndSet(pre, pre + 6,stamp,stamp + 1);
            log.debug("填补 6 万元：{}",rs);

        },"有问题的财务").start();
    }

}

执行结果

22:13:16.470 [有问题的财务] DEBUG com.yyoo.thread.atomic.ABATest1 - 挪用 6 万元，true
22:13:16.473 [有问题的财务] DEBUG com.yyoo.thread.atomic.ABATest1 - 填补 6 万元：true
22:13:17.472 [正常出账] DEBUG com.yyoo.thread.atomic.ABATest1 - 正常出账：false

原子累加器

每次累加（累减），从 0 开始

LongAdder
DoubleAdder

AtomicInt、AtomicLong 也能进行自增、自减，但 LongAdder 的效率更高，因为 LongAdder、DoubleAdder 都继承自 Striped64，Striped64 中包含三个重要的字段


    /**
     * 并发竞争情况下的单元数组
     * 并发情况下可能线程1 累加 cells[0] 而线程2 累加 cells[1] 最后将这些累加的结果结合起来
     * 每次扩容为 2 的次幂
     */
    transient volatile Cell[] cells;

    /**
     * 基本值，在没有竞争的情况下使用 CAS 来累加
     */
    transient volatile long base;

    /**
     * Spinlock (CAS 锁) 当 cells 创建或更改大小时使用
     */
    transient volatile int cellsBusy;

原子累计计算

LongAccumulator
DoubleAccumulator

LongAccumulator 实例化时接收两个参数，LongBinaryOperator accumulatorFunction 和 long identity，accumulatorFunction 为计算函数（里面来定义计算公式），函数第一个值为当前累计的值，第二个值为调用 accumulate(long x) 方法传入的值，identity 是起始值

示例

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.LongAccumulator;
import java.util.concurrent.atomic.LongAdder;

@Slf4j
public class LongAdderTest {

    public static void main(String[] args) throws InterruptedException {

        LongAdder a = new LongAdder();
        // 计算公式为 rs = x + 2*y;
        LongAccumulator b = new LongAccumulator((x,y)-> x + 2 * y,0);


        for(int i = 0; i < 1000; i++){

            // 此处只是示例，工作场景请勿这样创建线程
            new Thread(()->{
                a.add(10);
            },"a" + i).start();

            new Thread(()->{
                // 相当于每次加20
                b.accumulate(10);
            },"b" + i).start();
        }

        TimeUnit.SECONDS.sleep(2);

        log.debug("a 累计：{}",a.longValue());
        log.debug("b 累计：{}",b.longValue());

    }

}

结果：

11:32:33.206 [main] DEBUG com.yyoo.thread.atomic.LongAdderTest - a 累计：10000
11:32:33.212 [main] DEBUG com.yyoo.thread.atomic.LongAdderTest - b 累计：20000

CAS 的优缺点

优点：

由于CAS是非阻塞的，可避免死锁，线程间的互相影响非常小。
没有锁竞争带来的系统开销，也没有线程间频繁调度的开销。

缺点：

如果有线程一直无法成功执行，会导致一直循环，增加 CPU 开销。（如果竞争的线程特别多，此问题会更加明显）
会导致 ABA 问题

所以，在线程数不多的情况下使用 CAS 是比较高效的。

文章来源:https://blog.csdn.net/forlinkext/article/details/134563054
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若内容造成侵权/违法违规/事实不符，请联系我的编程经验分享网邮箱：chenni525@qq.com进行投诉反馈，一经查实，立即删除！

JUC CAS 和 原子操作类