一文吃透 Java 中的并发原子类！-51CTO.COM

一、简介

在 Java 的java.util.concurrent包中，除了提供底层锁、并发同步等工具类以外，还提供了一组原子操作类，大多以Atomic开头，他们位于java.util.concurrent.atomic包下。

所谓原子类操作，顾名思义，就是这个操作要么全部执行成功，要么全部执行失败，是保证并发编程安全的重要一环。

相比通过synchronized和lock等方式实现的线程安全同步操作，原子类的实现机制则完全不同。它采用的是通过无锁（lock-free）的方式来实现线程安全（thread-safe）访问，底层原理主要基于CAS操作来实现。

某些业务场景下，通过原子类来操作，既可以实现线程安全的要求，又可以实现高效的并发性能，同时编程方面更加简单。

下面我们一起来看看它的具体玩法！

二、常用原子操作类

在java.util.concurrent.atomic包中，因为原子类众多，如果按照类型进行划分，可以分为五大类，每个类型下的原子类可以用如下图来概括（不同 JDK 版本，可能略有不同，本文主要基于 JDK 1.8 进行采样）。

图片

虽然原子操作类很多，但是大体的用法基本类似，只是针对不同的数据类型进行了单独适配，这些原子类都可以保证多线程下数据的安全性，使用起来也比较简单。

2.1、基本类型

基本类型的原子类，也是最常用的原子操作类，JDK为开发者提供了三个基础类型的原子类，内容如下：

AtomicBoolean：布尔类型的原子操作类
AtomicInteger：整数类型的原子操作类
AtomicLong：长整数类型的原子操作类

以AtomicInteger为例，常用的操作方法如下：

方法	描述
`int get()`	获取当前值
`void set(int newValue)`	设置 value 值
`int getAndIncrement()`	先取得旧值，然后加1，最后返回旧值
`int getAndDecrement()`	先取得旧值，然后减1，最后返回旧值
`int incrementAndGet()`	加1，然后返回新值
`int decrementAndGet()`	减1，然后返回新值
`int getAndAdd(int delta)`	先取得旧值，然后增加指定值，最后返回旧值
`int addAndGet(int delta)`	增加指定值，然后返回新值
`boolean compareAndSet(int expect, int update)`	直接使用CAS方式，将【旧值】更新成【新值】，核心方法

AtomicInteger的使用方式非常简单，使用示例如下：

AtomicInteger atomicInteger = new AtomicInteger();
// 先获取值，再自增，默认初始值为0
int v1 = atomicInteger.getAndIncrement();
System.out.println("v1：" + v1);

// 获取自增后的ID值
int v2 = atomicInteger.incrementAndGet();
System.out.println("v2：" + v2);

// 获取自减后的ID值
int v3 = atomicInteger.decrementAndGet();
System.out.println("v3：" + v3);

// 使用CAS方式，将就旧值更新成 10
boolean v4 = atomicInteger.compareAndSet(v3,10);
System.out.println("v4：" + v4);

// 获取最新值
int v5 = atomicInteger.get();
System.out.println("v5：" + v5);

输出结果：

v1：0
v2：2
v3：1
v4：true
v5：10

下面我们以对某个变量累加 10000 次为例，采用 10 个线程，每个线程累加 1000 次来实现，对比不同的实现方式执行结果的区别（预期结果值为 10000）。

方式一：线程不安全操作实现

public class Demo1 {

    /**
     * 初始化一个变量
     */
    private static volatile int a = 0;

    public static void main(String[] args) throws InterruptedException {
        final int threads = 10;
        CountDownLatch countDownLatch = new CountDownLatch(threads);
        for (int i = 0; i < threads; i++) {
            new Thread(new Runnable() {

                @Override
                public void run() {
                    for (int j = 0; j < 1000; j++) {
                        a++;
                    }
                    countDownLatch.countDown();
                }
            }).start();
        }

        // 阻塞等待10个线程执行完毕
        countDownLatch.await();
        // 输出结果值
        System.out.println("结果值：" + a);
    }
}

输出结果：

结果值：9527

从日志上可以很清晰的看到，实际结果值与预期不符，即使变量a加了volatile关键字，也无法保证累加结果的正确性。

针对volatile关键字，在之前的文章中我们有所介绍，它只能保证变量的可见性和程序的有序性，无法保证程序操作的原子性，导致运行结果与预期不符。

方式二：线程同步安全操作实现

public class Demo2 {

    /**
     * 初始化一个变量
     */
    private static int a = 0;

    public static void main(String[] args) throws InterruptedException {
        final int threads = 10;
        CountDownLatch countDownLatch = new CountDownLatch(threads);
        for (int i = 0; i < threads; i++) {
            new Thread(new Runnable() {

                @Override
                public void run() {
                    synchronized (Demo2.class){
                        for (int j = 0; j < 1000; j++) {
                            a++;
                        }
                    }
                    countDownLatch.countDown();
                }
            }).start();
        }

        // 阻塞等待10个线程执行完毕
        countDownLatch.await();
        // 输出结果值
        System.out.println("结果值：" + a);
    }
}

输出结果：

结果值：10000

当多个线程操作同一个变量或者方法的时候，可以在方法上加synchronized关键字，可以同时实现变量的可见性、程序的有序性、操作的原子性，达到运行结果与预期一致的效果。

同时也可以采用Lock锁来实现多线程操作安全的效果，执行结果也会与预期一致。

方式三：原子类操作实现

public class Demo3 {

    /**
     * 初始化一个原子操作类
     */
    private static AtomicInteger a = new AtomicInteger();

    public static void main(String[] args) throws InterruptedException {
        final int threads = 10;
        CountDownLatch countDownLatch = new CountDownLatch(threads);
        for (int i = 0; i < threads; i++) {
            new Thread(new Runnable() {

                @Override
                public void run() {
                    for (int j = 0; j < 1000; j++) {
                        // 采用原子性操作累加
                        a.incrementAndGet();
                    }
                    countDownLatch.countDown();
                }
            }).start();
        }
        // 阻塞等待10个线程执行完毕
        countDownLatch.await();
        // 输出结果值
        System.out.println("结果值：" + a.get());
    }
}

输出结果：

结果值：10000

从日志结果上可见，原子操作类也可以实现在多线程环境下执行结果与预期一致的效果，关于底层实现原理，我们等会在后文中进行介绍。

与synchronized和Lock等实现方式相比，原子操作类因为采用无锁的方式实现，因此某些场景下可以带来更高的执行效率。

2.2、对象引用类型

上文提到的基本类型的原子类，只能更新一个变量，如果需要原子性更新多个变量，这个时候可以采用对象引用类型的原子操作类，将多个变量封装到一个对象中，JDK为开发者提供了三个对象引用类型的原子类，内容如下：

AtomicReference：对象引用类型的原子操作类
AtomicStampedReference：带有版本号的对象引用类型的原子操作类，可以解决 ABA 问题
AtomicMarkableReference：带有标记的对象引用类型的原子操作类

以AtomicReference为例，构造一个对象引用，具体用法如下：

public class User {

    private String name;

    private Integer age;

    public User(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

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

AtomicReference<User> atomicReference = new AtomicReference<>();
// 设置原始值
User user1 = new User("张三", 20);
atomicReference.set(user1);

// 采用CAS方式，将user1更新成user2
User user2 = new User("李四", 21);
atomicReference.compareAndSet(user1, user2);
System.out.println("更新后的对象：" +  atomicReference.get().toString());

输出结果：

更新后的对象：User{name='李四', age=21}

2.3、对象属性类型

在某项场景下，可能你只想原子性更新对象中的某个属性值，此时可以采用对象属性类型的原子操作类，JDK为开发者提供了三个对象属性类型的原子类，内容如下：

AtomicIntegerFieldUpdater：属性为整数类型的原子操作类
AtomicLongFieldUpdater：属性为长整数类型的原子操作类
AtomicReferenceFieldUpdater：属性为对象类型的原子操作类

需要注意的是，这些原子操作类需要满足以下条件才可以使用。

1.被操作的字段不能是 static 类型
2.被操纵的字段不能是 final 类型
3.被操作的字段必须是 volatile 修饰的
4.属性必须对于当前的 Updater 所在区域是可见的，简单的说就是尽量使用public修饰字段

以AtomicIntegerFieldUpdater为例，构造一个整数类型的属性引用，具体用法如下：

public class User {

    private String name;

    /**
     * age 字段加上 volatile 关键字，并且改成 public 修饰
     */
    public volatile int age;

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

User user = new User("张三", 20);
AtomicIntegerFieldUpdater<User> fieldUpdater = AtomicIntegerFieldUpdater.newUpdater(User.class, "age");
// 将 age 的年龄原子性操作加 1
fieldUpdater.getAndIncrement(user);
System.out.println("更新后的属性值：" + fieldUpdater.get(user));

输出结果：

更新后的属性值：21

2.4、数组类型

数组类型的原子操作类，并不是指对数组本身的原子操作，而是对数组中的元素进行原子性操作，这一点需要特别注意，如果要针对整个数组进行更新，可以采用对象引入类型的原子操作类进行处理。

JDK为开发者提供了三个数组类型的原子类，内容如下：

AtomicIntegerArray：数组为整数类型的原子操作类
AtomicLongArray：数组为长整数类型的原子操作类
AtomicReferenceArray：数组为对象类型的原子操作类

以AtomicIntegerArray为例，具体用法如下：

int[] value = new int[]{0, 3, 5};
AtomicIntegerArray array = new AtomicIntegerArray(value);
// 将下标为[0]的元素，原子性操作加 1
array.getAndIncrement(0);
System.out.println("下标为[0]的元素，更新后的值：" + array.get(0));

输出结果：

下标为[0]的元素，更新后的值：1

2.5、累加器类型

累加器类型的原子操作类，是从 jdk 1.8 开始加入的，专门用来执行数值类型的数据累加操作，性能更好。

它的实现原理与基本数据类型的原子类略有不同，当多线程竞争时采用分段累加的思路来实现目标值，在多线程环境中，它比AtomicLong性能要高出不少，特别是写多的场景。

JDK为开发者提供了四个累加器类型的原子类，内容如下：

LongAdder：长整数类型的原子累加操作类
LongAccumulator：LongAdder的功能增强版，它支持自定义的函数操作
DoubleAdder：浮点数类型的原子累加操作类
DoubleAccumulator：同样的，也是DoubleAdder的功能增强版，支持自定义的函数操作

以LongAdder为例，具体用法如下：

LongAdder adder = new LongAdder();
// 自增加 1，默认初始值为0
adder.increment();
adder.increment();
adder.increment();
System.out.println("最新值：" +  adder.longValue());

输出结果：

最新值：3

三、小结

本文主要围绕AtomicInteger的用法进行一次知识总结，JUC包下的原子操作类非常的多，但是大体用法基本相似，只是针对不同的数据类型做了细分处理。

在实际业务开发中，原子操作类通常用于计数器，累加器等场景，比如编写一个多线程安全的全局唯一 ID 生成器。

public class IdGenerator {

    private static AtomicLong atomic = new AtomicLong(0);

    public long getNextId() {
        return atomic.incrementAndGet();
    }
}