Java CAS与Atomic原子操作核心原理详解

2023-05-16 14:05:18 原理原子详解

什么是原子操作

Mysql事务中的原子性就是一个事务中执行的多条sql，要么同时成功，要么同时失败，他们不可拆分。并发中的原子操作也一样，多个线程中，站在线程A的角度看线程B的操作，线程B的操作就是一个原子的；站在线程B的角度看线程A，线程A的操作是原子的。一整个操作要么全部执行完了，要么就没有执行，中间不能拆分。

那么要怎么实现原子性嘞？可以使用synchronized锁来保证一段代码的原子性，但是加锁影响性能，甚至还有死锁方面的问题需要考虑。

所以锁机制是比较重量级的，粒度较大的一种机制，比如对于计数器方面的操作来说，可能加锁的耗时都比整个计算的耗时还要高。Java 就提供了 Atomic 系列的原子操作类，在java.util.concurrent.atomic包下

这些原子操作类是基于处理器的CAS指令来实现原子性的，Compare and swap。比较并且交换

CAS

每个CAS操作过程基本上都包含三个部分：内存地址V、期望值A、新值B

期望值就是旧值，首先会去内存地址中进行比较，我期望当前这个内存地址中的值是我期望的旧值，如果是则把新值赋值到这个内存地址中，如果不是则不做任何事。在一般的使用中我们会不断尝试去进行CAS操作，直到成功为止。

Java 中的 Atomic 系列的原子操作类的实现则是利用了循环 CAS 来实现。

使用CAS实现原子操作的几个问题

ABA问题

ABA问题在大多数场景下，不解决其实也没什么影响。

解决思路：添加版本戳，在变量前面追加上版本号，每次变量更新的时候把版本号加 1，那么 A-->B-->A 就会变成 1A-->2B-->3A

循环时间长，对于cpu来说开销较大

只能保证一个共享变量的原子操作

对于多个共享变量操作时就无法使用CAS来保证原子性了，这个时候还是需要用锁。

还有一个取巧的办法，就是把多个共享变量合并成一个共享变量来操作。比如，有两个共享变量 i＝2，j=a，合并一下 ij=2a，然后用 CAS 来操作 ij。

从 Java 1.5开始，jdk 提供了AtomicReference类来保证引用对象之间的原子性，就可以把多个变量放在一个对象里来进行 CAS 操作。

相关原子操作类的使用

这些类的用户都大同小异，这里就拿几个典型来举例

AtomicInteger

// 以原子方式将给定值添加到当前值，然后将相加后的结果返回
public final int addAndGet(int delta){}
// 指定期望值与修改后的值，如果期望值和当前值相同则进行更新操作
public final boolean compareAndSet(int expect, int update) {}
// 先返回当前值，然后再进行原子自增1
public final int getAndIncrement() {}
// 先返回当前值，然后进行原子更新操作
public final int getAndSet(int newValue) {}

案例：

public class UseAtomicInt {
    static AtomicInteger ai = new AtomicInteger(10);
    public static void main(String[] args) {
        ai.getAndIncrement();
        ai.incrementAndGet();
        //ai.compareAndSet();
        ai.addAndGet(24);
    }
}

AtomicIntegerArray

提供原子的方式更新数据中的整形，常用方法如下：

// 以原子方式将给定值添加到索引 i 处的元素。然后返回更新后的值
public final int addAndGet(int i, int delta){}
// 先比较，期望值和当前值相同再执行更新操作
public final boolean compareAndSet(int i, int expect, int update) {}

案例：

public class AtomicArray {
    static int[] value = new int[] { 1, 2 };
    static AtomicIntegerArray ai = new AtomicIntegerArray(value);
    public static void main(String[] args) {
        ai.getAndSet(0, 3);
        System.out.println(ai.get(0));
        //原数组不会变化
        System.out.println(value[0]);
        }
}
Process finished with exit code 0

// 输出结果
3
1

需要注意的是，数组 value 通过构造方法传递进去，然后 AtomicIntegerArray会将当前数组复制一份，所以当 AtomicIntegerArray 对内部的数组元素进行修改时，不会影响传入的数组。

更新引用类型

如果要同时更新多个原子变量就需要使用更新引用类型提供的类了。Atomic提供了三个类：

AtomicReference

原子更新引用类型

案例：

public class UseAtomicReference {
    public static AtomicReference<UserInfo> atomicUserRef;
    public static void main(String[] args) {
        //要修改的实体的实例
        UserInfo user = new UserInfo("Mark", 15);
        atomicUserRef = new AtomicReference(user);
        // 再创建一个对象
        UserInfo updateUser = new UserInfo("Bill",17);
        // 期望值和当前值相同就进行修改
        atomicUserRef.compareAndSet(user,updateUser);
        System.out.println(atomicUserRef.get());
        System.out.println(user);
        
    }
    
    static class UserInfo {
        private volatile String name;
        private int age;
        public UserInfo(String name, int age) {
            this.name = name;
            this.age = age;
        }
        public String getName() {
            return name;
        }
        public int getAge() {
            return age;
        }
        @Override
        public String toString() {
            return "UserInfo{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }
}

AtomicStampedReference

利用版本戳的形式记录了每次改变以后的版本号，这样的话就不会存在 ABA问题了

AtomicMarkableReference

原子更新带有标记位的引用类型。可以原子更新一个布尔类型的标记位和引用类型。

构造方法是 AtomicMarkableReference（V initialRef，booleaninitialMark）。

AtomicMarkableReference跟 AtomicStampedReference 差不多，

AtomicStampedReference 是使用 pair 的 int stamp 作为计数器使用

AtomicMarkableReference 的使用pair 的boolean mark。

AtomicStampedReference 可能关心的是动过几次，AtomicMarkableReference 关心的是有没有被人动过。

案例：

// 第二个线程，期望的时间戳和当前时间戳不同，所以更新不成功
public class UseAtomicStampedReference {
    static AtomicStampedReference<String> asr = new AtomicStampedReference("mark", 0);
    public static void main(String[] args) throws InterruptedException {
        //拿到当前的版本号(旧)
        final int oldStamp = asr.getStamp();
        final String oldReference = asr.getReference();
        System.out.println(oldReference + "============" + oldStamp);
        Thread rightStampThread = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + ":当前变量值："
                        + oldReference + "-当前版本戳：" + oldStamp + "\n"
                        + asr.compareAndSet(oldReference, oldReference + "+Java", oldStamp, oldStamp + 1));
            }
        });
        Thread errorStampThread = new Thread(new Runnable() {
            @Override
            public void run() {
                String reference = asr.getReference();
                System.out.println(Thread.currentThread().getName() + ":当前变量值："
                        + reference + "-当前版本戳：" + asr.getStamp() + "\n"
                        + asr.compareAndSet(reference, reference + "+C", oldStamp, oldStamp + 1));
            }
        });
        rightStampThread.start();
        rightStampThread.join();
        errorStampThread.start();
        errorStampThread.join();
        System.out.println(asr.getReference() + "============" + asr.getStamp());
    }
}

输出结果

mark============0
Thread-0:当前变量值：mark-当前版本戳：0
true
Thread-1:当前变量值：mark+Java-当前版本戳：1
false
mark+Java============1

原子更新字段类

如果需原子地更新某个类里的某个字段时，就需要使用原子更新字段类

Atomic 包提供了以下 3 个类进行原子字段更新。要想原子地更新字段类需要两步。

因为原子更新字段类都是抽象类，每次使用的时候必须使用静态方法 newUpdater()创建一个更新器，并且需要设置想要更新的类和属性。

更新类的字段（属性）必须使用 public volatile修饰符。

AtomicIntegerFieldUpdater：原子更新整型的字段的更新器。
AtomicLongFieldUpdater：原子更新长整型字段的更新器。
AtomicReferenceFieldUpdater：原子更新引用类型里的字段。

LongAdder

并发量较少，自旋的冲突也就较少。但如果并发很多的情况下，CAS机制就不如synchronized了，因为很多个线程都集中判断一个变量的值，不断的自旋，对cpu的消耗也较大，同一时刻又只会一个线程更新成功。

在JDK1.8就引入了LongAdder类，它在处理上面问题的时候是采用的一种热点数据的分散写

LongAdder中有两个成员变量

// 当为非空时，大小为 2 的幂。
// 如果并发很高就使用cell数组做写热点的分散，其中某些线程共同操作某一个数组中的元素
transient volatile Cell[] cells;
// 当争抢较少时使用这个变量来进行cas，就类似于AtomicInteger类中的value变量
transient volatile long base;

然后调用sum()方法将数组cells和base变量的中做一个汇总，返回当前总和。在没有并发更新的情况下调用将返回准确的结果，但在计算总和时发生的并发更新可能不会合并，所以sum()方法并不能保证强一致性，它返回的只是一个近似值

// 可以看到 sum()方法没有任何加锁的逻辑
public long sum() {
    Cell[] as = cells;
    Cell a;
    long sum = base;
    if (as != null) {
        for (int i = 0; i < as.length; ++i) {
            if ((a = as[i]) != null)
                sum += a.value;
        }
    }
    return sum;
}

到此这篇关于Java CAS与Atomic原子操作核心原理详解的文章就介绍到这了,更多相关Java CAS与Atomic原子操作内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！

相关文章