多线程系列(十六) -常用并发原子类详解

一、简介

在 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(