原子类是如何利用 CAS 保证线程安全的？

原子类是如何利用 CAS 保证线程安全的？

前言

本章将会介绍 Java 并发中的原子类，以及原子类是如何使用 CAS 保证线程安全？

项目环境

• jdk 1.8
• github 地址：https://github.com/huajiexiewenfeng/java-concurrent
  • 本章模块：atomic

1.什么是原子类？原子类有什么作用？

原子性意味着 一组操作要么全都操作成功，要么全都失败，不能只操作成功其中的一部分 。

java.util.concurrent.atomic 包下的类，就是具有原子性的类，可以原子性地执行添加、递增、递减等操作。比如之前多线程下的线程不安全的 i++ 问题，到了原子类这里，就可以用功能相同且线程安全的 getAndIncrement 方法来优雅地解决。

原子类的作用和锁有类似之处，是为了保证并发情况下线程安全。不过原子类相比于锁，有一定的优势：

• 粒度更细：原子变量可以把竞争范围缩小到变量级别，通常情况下，锁的粒度都要大于原子变量的粒度。
• 效率更高：除了高度竞争的情况之外，使用原子类的效率通常会比使用同步互斥锁的效率更高，因为原子类底层利用了 CAS 操作，不会阻塞线程。

2.原子类分类

原子类一共可以分为以下这 6 类：

类型	具体类
Atomic* 基本类型原子类	AtomicInteger、AtomicLong、AtomicBoolean
Atomic*Array 数组类型原子类	AtomicIntegerArray、AtomicLongArray、AtomicReferenceArray
Atomic*Reference 引用类型原子类	AtomicReference、AtomicStampedReference、AtomicMarkableReference
Atomic*FieldUpdater 升级类型原子类	AtomicIntegerfieldupdater、AtomicLongFieldUpdater、AtomicReferenceFieldUpdater
Adder 累加器	LongAdder、DoubleAdder
Accumulator 积累器	LongAccumulator、DoubleAccumulator

3.Atomic 基本类型原子类

首先看到第一类 Atomic*，我们把它称为基本类型原子类，它包括三种，分别是 AtomicInteger、AtomicLong 和 AtomicBoolean。

我们来介绍一下最为典型的 AtomicInteger。对于这个类型而言，它是对于 int 类型的封装，并且提供了原子性的访问和更新。也就是说，我们如果需要一个整型的变量，并且这个变量会被运用在并发场景之下，我们可以不用基本类型 int，也不使用包装类型 Integer，而是直接使用 AtomicInteger，这样一来就自动具备了原子能力，使用起来非常方便。

3.1 AtomicInteger

常用方法：

• public final int get() //获取当前的值

• public final int getAndSet(int newValue) //获取当前的值，并设置新的值

• public final int getAndIncrement() //获取当前的值，并自增

• public final int getAndDecrement() //获取当前的值，并自减

• public final int getAndAdd(int delta) //获取当前的值，并加上预期的值

  • delta 这个参数表示原子类需要改变的值，可以是正数也可以是负数，如果是正数就是增加，如果是负数就是减少。而 getAndIncrement 和 getAndDecrement 修改的数值默认为 +1 或 -1，如果不能满足需求，我们就可以使用 getAndAdd 方法来直接一次性地加减我们想要的数值。

• boolean compareAndSet(int expect, int update) //如果输入的数值等于预期值，则以原子方式将该值更新为输入值（update），这个方法也是 CAS 的一个重要体现。

4.Array 数组类型原子类

下面我们来看第二大类 Atomic*Array 数组类型原子类，数组里的元素，都可以保证其原子性，比如 AtomicIntegerArray 相当于把 AtomicInteger 聚合起来，组合成一个数组。这样一来，我们如果想用一个每一个元素都具备原子性的数组的话， 就可以使用 Atomic*Array。

它一共分为 3 种，分别是：

• AtomicIntegerArray：整形数组原子类；
• AtomicLongArray：长整形数组原子类；
• AtomicReferenceArray ：引用类型数组原子类。

5.Atomic\Reference 引用类型原子类

下面我们介绍第三种 AtomicReference 引用类型原子类。AtomicReference 类的作用和AtomicInteger 并没有本质区别， AtomicInteger 可以让一个整数保证原子性，而AtomicReference 可以让一个对象保证原子性。这样一来，AtomicReference 的能力明显比 AtomicInteger 强，因为一个对象里可以包含很多属性。

在这个类别之下，除了 AtomicReference 之外，还有：

• AtomicStampedReference：它是对 AtomicReference 的升级，在此基础上还加了时间戳，用于解决 CAS 的 ABA 问题。
• AtomicMarkableReference：和 AtomicReference 类似，多了一个绑定的布尔值，可以用于表示该对象已删除等场景。

6.Atomic\FieldUpdater 原子更新器

第四类我们将要介绍的是 Atomic\FieldUpdater，我们把它称为原子更新器，一共有三种，分别是。

• AtomicIntegerFieldUpdater：原子更新整形的更新器；
• AtomicLongFieldUpdater：原子更新长整形的更新器；
• AtomicReferenceFieldUpdater：原子更新引用的更新器。

6.1 示例

public class AtomicIntegerFieldUpdaterDemo {

    static Score math = new Score();
    static Score computer = new Score();

    public static AtomicIntegerFieldUpdater<Score> scoreUpdater = AtomicIntegerFieldUpdater
            .newUpdater(Score.class, "score");

    public static void main(String[] args) throws InterruptedException {
        for (int j = 0; j < 1000; j++) {
            new Thread(() -> {
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                math.score++;
                scoreUpdater.getAndIncrement(computer);
            }).start();
        }

        Thread.sleep(3000);

        System.out.println("循环 1000 后，math 的值 = " + math.score);
        System.out.println("循环 1000 后，computer 的值 = " + computer.score);
    }

    static class Score {
        volatile int score = 0;
    }

}

执行结果：

循环 1000 后，math 的值 = 993
循环 1000 后，computer 的值 = 1000

可以看到普通的 ++ 操作是线程不安全的，导致最终的结果小于 1000，而使用 AtomicIntegerFieldUpdater 将一个普通类型的 score 变量进行原子的递增操作则是线程安全的，结果为 1000 符合预期。

7.Adder 累加器

它里面有两种加法器，分别叫作 LongAdder 和 DoubleAdder。（后续文章详细介绍）

8.Accumulator 积累器

最后一种叫 Accumulator 积累器，分别是 LongAccumulator 和 DoubleAccumulator。（后续文章详细介绍）

9.原子类如何利用 CAS 实现原子操作？

以 AtomicInteger 为例来分析 CAS 操作，AtomicInteger 部分代码如下：

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

可以看到，在数据定义的部分，首先获取了 Unsafe 实例，并且定义了 valueOffset。我们往下看到 static 代码块，这个代码块会在类加载的时候执行，执行时我们会调用 Unsafe 的 objectFieldOffset 方法，从而得到当前这个原子类的 value 的偏移量，并且赋给 valueOffset 变量，这样一来我们就获取到了 value 的偏移量，它的含义是在内存中的偏移地址，因为 Unsafe 就是根据内存偏移地址获取数据的原值的，这样我们就能通过 Unsafe 来实现 CAS 了。

value 是用 volatile 修饰的，它就是我们原子类存储的值的变量，由于它被 volatile 修饰，我们就可以保证在多线程之间看到的 value 是同一份，保证了可见性。

Unsafe 类

Unsafe 其实是 CAS 的核心类。由于 Java 无法直接访问底层操作系统，而是需要通过 native 方法来实现。不过尽管如此，JVM 还是留了一个后门，在 JDK 中有一个 Unsafe 类，它提供了硬件级别的原子操作，我们可以利用它直接操作内存数据。

getAndAdd 方法：

    public final int getAndAdd(int delta) {
        return unsafe.getAndAddInt(this, valueOffset, delta);
    }

unsafe#getAndAddInt

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

当满足 !this.compareAndSwapInt(var1, var2, var5, var5 + var4) 条件时退出循环，这个就是一个标准的 CAS 的操作，具体参数的含义如下：

• 第一个参数 var1-> object 就是将要操作的对象，传入的是 this，也就是 atomicInteger 这个对象本身；
• 第二个参数是 var2 -> offset，也就是偏移量，借助它就可以获取到 value 的数值；
• 第三个参数 var3 -> expectedValue，代表“期望值”，传入的是刚才获取到的 var5；
• 而最后一个参数 var5+var4-> newValue 是希望修改的数值 ，等于之前取到的数值 var5 再加上 var4，而 var4 就是我们之前所传入的 delta，delta 就是我们希望原子类所改变的数值，比如可以传入 +1，也可以传入 -1。

所以 compareAndSwapInt 方法的作用就是，判断如果现在原子类里 value 的值和之前获取到的 var5 相等的话，那么就把计算出来的 var5 + var4 给更新上去，所以说这行代码就实现了 CAS 的过程。

一旦 CAS 操作成功，就会退出这个 while 循环，但是也有可能操作失败。如果操作失败就意味着在获取到 var5 之后，并且在 CAS 操作之前，value 的数值已经发生变化了，证明有其他线程修改过这个变量。

这样一来，就会再次执行循环体里面的代码，重新获取 var5 的值，也就是获取最新的原子变量的数值，并且再次利用 CAS 去尝试更新，直到更新成功为止，所以这是一个死循环。

Unsafe 的 getAndAddInt 方法是通过循环 + CAS 的方式来实现的，在此过程中，它会通过 compareAndSwapInt 方法来尝试更新 value 的值，如果更新失败就重新获取，然后再次尝试更新，直到更新成功。

10.参考

• 《Java 并发编程 78 讲》- 徐隆曦