Java atomic包中的原子操作类（AtomicInteger）总结

沉默王二约 2537 字大约 8 分钟

我们前面讲过 CAS，相信大家都还有印象，Java 中的原子操作类，如 AtomicInteger 和 AtomicLong，底层就是利用 CAS 来确保变量更新的原子性的。

像递增运算 count++ 就不是一个原子操作，在多线程环境下并不能得到正确的结果，因为 count++ 操作实际上分为三个步骤：

读取 count 变量的值；
将 count 变量的值加 1；
将 count 变量的值写入到内存中；

假定线程 A 正在修改 count 变量，为了保证线程 B 在使用 count 的时候是线程 A 修改过后的状态，可以用 synchronized 关键字同步一手。

private long count = 0;
public synchronized void write() {
    System.out.println("我寻了半生的春天，你一笑便是了。");
    count++;
}

但多个线程之间访问 write() 方法是互斥的，线程 B 访问的时候必须要等待线程 A 访问结束，有没有更好的办法呢？

AtomicInteger 是 JDK 提供的一个原子操作的 Integer 类，它提供的加减操作是线程安全的。于是我们可以这样：

private AtomicInteger count = new AtomicInteger(0);
public void write() {
    System.out.println("我寻了半生的春天，你一笑便是了。");
    count.incrementAndGet();
}

你看，这下是不是就舒服多了，不用加锁，也能保证线程安全。OK，接下来，我们来看看原子操作类都有哪些？

原子操作的基本数据类型

基本类型的原子操作主要有这些：

AtomicBoolean：以原子更新的方式更新 boolean；
AtomicInteger：以原子更新的方式更新 Integer;
AtomicLong：以原子更新的方式更新 Long；

这几个类的用法基本一致，这里以 AtomicInteger 为例。

addAndGet(int delta) ：增加给定的 delta，并获取新值。
incrementAndGet()：增加 1，并获取新值。
getAndSet(int newValue)：获取当前值，并将新值设置为 newValue。
getAndIncrement()：获取当前值，并增加 1。

还有一些方法，可以直接查看 API，都很好理解。

为了能够弄懂 AtomicInteger 的实现原理，以 getAndIncrement 方法为例，来看下源码：

public final int getAndIncrement() {
    // 使用Unsafe类中的getAndAddInt方法原子地增加AtomicInteger的当前值
    // 第一个参数this是AtomicInteger的当前实例
    // 第二个参数valueOffset是一个偏移量，它指示在AtomicInteger对象中的哪个位置可以找到实际的int值
    // 第三个参数1表示要加到当前值上的值（即增加的值）
    // 此方法返回的是增加前的原始值
    return unsafe.getAndAddInt(this, valueOffset, 1);
}

可以看出，该方法实际上是调用了 unsafe 对象的 getAndAddInt 方法，unsafe 对象是通过通过 UnSafe 类的静态方法 getUnsafe 获取的：

private static final Unsafe unsafe = Unsafe.getUnsafe();

Unsafe 类我们在讲 CAS 的时候也讲过，包括 AtomicInteger 类，相信大家还有印象。

Unsafe 类是 Java 中的一个特殊类，用于执行低级、不安全的操作。getAndIncrement 方法就是利用了 Unsafe 类提供的 CAS（Compare-And-Swap）操作来实现原子的 increment 操作。CAS 是一种常用的无锁技术，允许在多线程环境中原子地更新值。

好，下面用一个简单的例子来说明 AtomicInteger 的用法：

public class AtomicDemo {
    private static AtomicInteger atomicInteger = new AtomicInteger(1);

    public static void main(String[] args) {
        System.out.println(atomicInteger.getAndIncrement());
        System.out.println(atomicInteger.get());
    }
}

输出结果：

1
2

AtomicLong 和 AtomicInteger 的实现原理基本一致，只不过一个针对的是 long 型，一个针对的是 int 型。

AtomicBoolean 类是怎样实现更新的呢？核心方法是compareAndSet 方法，其源码如下：

public final boolean compareAndSet(boolean expect, boolean update) {
    // 将expect布尔值转化为整数，true为1，false为0
    int e = expect ? 1 : 0;
    
    // 将update布尔值转化为整数，true为1，false为0
    int u = update ? 1 : 0;
    
    // 使用Unsafe类中的compareAndSwapInt方法尝试原子地更新AtomicBoolean的当前值
    // 第一个参数this是AtomicBoolean的当前实例
    // 第二个参数valueOffset是一个偏移量，它指示在AtomicBoolean对象中的哪个位置可以找到实际的int值
    // 第三个参数e是我们期望的当前值（转换为整数后的值）
    // 第四个参数u是我们想要更新的值（转换为整数后的值）
    // 如果当前值与期望值e相等，它会被原子地设置为u，并返回true；否则返回false。
    return unsafe.compareAndSwapInt(this, valueOffset, e, u);
}

该方法尝试将当前值从expect设置为update，但这种设置只会在当前值确实为expect时成功。方法返回true表示更新成功，否则返回false。

原子操作的数组类型

如果需要原子更新数组里的某个元素，atomic 也提供了相应的类：

AtomicIntegerArray：这个类提供了一些原子更新 int 整数数组的方法。
AtomicLongArray：这个类提供了一些原子更新 long 型证书数组的方法。
AtomicReferenceArray：这个类提供了一些原子更新引用类型数组的方法。

这几个类的用法一致，就以 AtomicIntegerArray 来总结下常用的方法：

addAndGet(int i, int delta)：以原子更新的方式将数组中索引为 i 的元素与输入值相加；
getAndIncrement(int i)：以原子更新的方式将数组中索引为 i 的元素自增加 1；
compareAndSet(int i, int expect, int update)：将数组中索引为 i 的位置的元素进行更新

可以看出，AtomicIntegerArray 与 AtomicInteger 的方法基本一致，只不过在 AtomicIntegerArray 的方法中会多一个数组索引 i。下面举一个简单的例子：

public class AtomicDemo {
    //    private static AtomicInteger atomicInteger = new AtomicInteger(1);
    private static int[] value = new int[]{1, 2, 3};
    private static AtomicIntegerArray integerArray = new AtomicIntegerArray(value);

    public static void main(String[] args) {
        //对数组中索引为1的位置的元素加5
        int result = integerArray.getAndAdd(1, 5);
        System.out.println(integerArray.get(1));
        System.out.println(result);
    }
}

输出结果：

7
2

通过 getAndAdd 方法将位置为 1 的元素加 5，从结果可以看出索引为 1 的元素变成了 7，该方法返回的也是相加之前的数为 2。

原子操作的引用类型

如果需要原子更新引用类型的话，atomic 也提供了相关的类：

AtomicReference：原子更新引用类型；
AtomicReferenceFieldUpdater：原子更新引用类型里的字段；
AtomicMarkableReference：原子更新带有标记位的引用类型；

这几个类的使用方法也是基本一样，以 AtomicReference 为例，来说明这些类的基本用法。下面是一个 demo：

public class AtomicDemo {

    private static AtomicReference<User> reference = new AtomicReference<>();

    public static void main(String[] args) {
        User user1 = new User("a", 1);
        reference.set(user1);
        User user2 = new User("b",2);
        User user = reference.getAndSet(user2);
        System.out.println(user);
        System.out.println(reference.get());
    }

    static class User {
        private String userName;
        private int age;

        public User(String userName, int age) {
            this.userName = userName;
            this.age = age;
        }

        @Override
        public String toString() {
            return "User{" +
                    "userName='" + userName + '\'' +
                    ", age=" + age +
                    '}';
        }
    }
}

输出结果：

User{userName='a', age=1}
User{userName='b', age=2}

首先将对象 User1 用 AtomicReference 进行封装，然后调用 getAndSet 方法进行赋值，从结果可以看出，该方法会原子更新 user 对象，变为 User{userName='b', age=2}。

原子更新字段类型

如果需要更新对象的某个字段，atomic 同样也提供了相应的原子操作类：

AtomicIntegeFieldUpdater：原子更新整型字段类；
AtomicLongFieldUpdater：原子更新长整型字段类；
AtomicStampedReference：原子更新引用类型，这种更新方式会带有版本号，是为了解决 CAS 的 ABA 问题，ABA 问题我们前面也讲过。

使用原子更新字段需要两步：

通过静态方法newUpdater创建一个更新器，并且设置想要更新的类和字段；
字段必须使用public volatile进行修饰；

以 AtomicIntegerFieldUpdater 为例来看看具体的使用：

public class AtomicDemo {

    private static AtomicIntegerFieldUpdater updater = AtomicIntegerFieldUpdater.newUpdater(User.class,"age");
    public static void main(String[] args) {
        User user = new User("a", 1);
        int oldValue = updater.getAndAdd(user, 5);
        System.out.println(oldValue);
        System.out.println(updater.get(user));
    }

    static class User {
        private String userName;
        public volatile int age;

        public User(String userName, int age) {
            this.userName = userName;
            this.age = age;
        }

        @Override
        public String toString() {
            return "User{" +
                    "userName='" + userName + '\'' +
                    ", age=" + age +
                    '}';
        }
    }
}

输出结果：

1
6

从示例中可以看出，创建AtomicIntegerFieldUpdater是通过它提供的静态方法进行创建的，getAndAdd方法会将指定的字段加上输入的值，并返回相加之前的值。user 对象中 age 字段原值为 1，加 5 之后变成了 6。

小结

Java 中的 java.util.concurrent.atomic 包提供了一系列类，这些类支持原子操作（即线程安全而无需同步）在单个变量上，这大大减少了并发编程的复杂性。

原子操作类主要有这些：

原子操作的基本数据类型：AtomicBoolean、AtomicInteger、AtomicLong；
原子操作的数组类型：AtomicIntegerArray、AtomicLongArray、AtomicReferenceArray；
原子操作的引用类型：AtomicReference、AtomicReferenceFieldUpdater、AtomicMarkableReference；

编辑：沉默王二，编辑前的内容主要来自于CL0610的 GitHub 仓库https://github.com/CL0610/Java-concurrency。推荐阅读：码农参上的Unsafe类详解

GitHub 上标星 10000+ 的开源知识库《二哥的 Java 进阶之路》第二份 PDF 《并发编程小册》终于来了！包括线程的基本概念和使用方法、Java的内存模型、sychronized、volatile、CAS、AQS、ReentrantLock、线程池、并发容器、ThreadLocal、生产者消费者模型等面试和开发必须掌握的内容，共计 15 万余字，200+张手绘图，可以说是通俗易懂、风趣幽默……详情戳：太赞了，二哥的并发编程进阶之路.pdf

加入二哥的编程星球，在星球的第二个置顶帖「知识图谱」里就可以获取 PDF 版本。