死磕Java并發(fā) | 常用并發(fā)原子類(lèi)詳解

作者：了不起 2023-12-14 07:36:16

本文主要圍繞AtomicInteger?的用法和原理進(jìn)行一次知識(shí)總結(jié)，JUC包下的原子操作類(lèi)非常的多，但是大體用法基本相似，只是針對(duì)不同的數(shù)據(jù)類(lèi)型做了細(xì)分處理。

一、簡(jiǎn)介

在 Java 的java.util.concurrent包中，除了提供底層鎖、并發(fā)同步等工具類(lèi)以外，還提供了一組原子操作類(lèi)，大多以Atomic開(kāi)頭，他們位于java.util.concurrent.atomic包下。

所謂原子類(lèi)操作，顧名思義，就是這個(gè)操作要么全部執(zhí)行成功，要么全部執(zhí)行失敗，是保證并發(fā)編程安全的重要一環(huán)。

相比通過(guò)synchronized和lock等方式實(shí)現(xiàn)的線(xiàn)程安全同步操作，原子類(lèi)的實(shí)現(xiàn)機(jī)制則完全不同。它采用的是通過(guò)無(wú)鎖（lock-free）的方式來(lái)實(shí)現(xiàn)線(xiàn)程安全（thread-safe）訪問(wèn)，底層原理主要基于CAS操作來(lái)實(shí)現(xiàn)。

某些業(yè)務(wù)場(chǎng)景下，通過(guò)原子類(lèi)來(lái)操作，既可以實(shí)現(xiàn)線(xiàn)程安全的要求，又可以實(shí)現(xiàn)高效的并發(fā)性能，同時(shí)編程方面更加簡(jiǎn)單。

下面我們一起來(lái)看看它的具體玩法！

二、常用原子操作類(lèi)

在java.util.concurrent.atomic包中，因?yàn)樵宇?lèi)眾多，如果按照類(lèi)型進(jìn)行劃分，可以分為五大類(lèi)，每個(gè)類(lèi)型下的原子類(lèi)可以用如下圖來(lái)概括（不同 JDK 版本，可能略有不同，本文主要基于 JDK 1.8 進(jìn)行采樣）。

圖片

雖然原子操作類(lèi)很多，但是大體的用法基本類(lèi)似，只是針對(duì)不同的數(shù)據(jù)類(lèi)型進(jìn)行了單獨(dú)適配，這些原子類(lèi)都可以保證多線(xiàn)程下數(shù)據(jù)的安全性，使用起來(lái)也比較簡(jiǎn)單。

2.1、基本類(lèi)型

基本類(lèi)型的原子類(lèi)，也是最常用的原子操作類(lèi)，JDK為開(kāi)發(fā)者提供了三個(gè)基礎(chǔ)類(lèi)型的原子類(lèi)，內(nèi)容如下：

AtomicBoolean：布爾類(lèi)型的原子操作類(lèi)
AtomicInteger：整數(shù)類(lèi)型的原子操作類(lèi)
AtomicLong：長(zhǎng)整數(shù)類(lèi)型的原子操作類(lèi)

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

方法	描述
`int get()`	獲取當(dāng)前值
`void set(int newValue)`	設(shè)置 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的使用方式非常簡(jiǎn)單，使用示例如下：

AtomicInteger atomicInteger = new AtomicInteger();
// 先獲取值，再自增，默認(rèn)初始值為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);

輸出結(jié)果：

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

下面我們以對(duì)某個(gè)變量累加 10000 次為例，采用 10 個(gè)線(xiàn)程，每個(gè)線(xiàn)程累加 1000 次來(lái)實(shí)現(xiàn)，對(duì)比不同的實(shí)現(xiàn)方式執(zhí)行結(jié)果的區(qū)別（預(yù)期結(jié)果值為 10000）。

方式一：線(xiàn)程不安全操作實(shí)現(xiàn)

public class Demo1 {

    /**
     * 初始化一個(gè)變量
     */
    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個(gè)線(xiàn)程執(zhí)行完畢
        countDownLatch.await();
        // 輸出結(jié)果值
        System.out.println("結(jié)果值：" + a);
    }
}

輸出結(jié)果：

結(jié)果值：9527

從日志上可以很清晰的看到，實(shí)際結(jié)果值與預(yù)期不符，即使變量a加了volatile關(guān)鍵字，也無(wú)法保證累加結(jié)果的正確性。

針對(duì)volatile關(guān)鍵字，在之前的文章中我們有所介紹，它只能保證變量的可見(jiàn)性和程序的有序性，無(wú)法保證程序操作的原子性，導(dǎo)致運(yùn)行結(jié)果與預(yù)期不符。

方式二：線(xiàn)程同步安全操作實(shí)現(xiàn)

public class Demo2 {

    /**
     * 初始化一個(gè)變量
     */
    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個(gè)線(xiàn)程執(zhí)行完畢
        countDownLatch.await();
        // 輸出結(jié)果值
        System.out.println("結(jié)果值：" + a);
    }
}

輸出結(jié)果：

結(jié)果值：10000

當(dāng)多個(gè)線(xiàn)程操作同一個(gè)變量或者方法的時(shí)候，可以在方法上加synchronized關(guān)鍵字，可以同時(shí)實(shí)現(xiàn)變量的可見(jiàn)性、程序的有序性、操作的原子性，達(dá)到運(yùn)行結(jié)果與預(yù)期一致的效果。

同時(shí)也可以采用Lock鎖來(lái)實(shí)現(xiàn)多線(xiàn)程操作安全的效果，執(zhí)行結(jié)果也會(huì)與預(yù)期一致。

方式三：原子類(lèi)操作實(shí)現(xiàn)

public class Demo3 {

    /**
     * 初始化一個(gè)原子操作類(lèi)
     */
    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個(gè)線(xiàn)程執(zhí)行完畢
        countDownLatch.await();
        // 輸出結(jié)果值
        System.out.println("結(jié)果值：" + a.get());
    }
}

輸出結(jié)果：

結(jié)果值：10000

從日志結(jié)果上可見(jiàn)，原子操作類(lèi)也可以實(shí)現(xiàn)在多線(xiàn)程環(huán)境下執(zhí)行結(jié)果與預(yù)期一致的效果，關(guān)于底層實(shí)現(xiàn)原理，我們等會(huì)在后文中進(jìn)行介紹。

與synchronized和Lock等實(shí)現(xiàn)方式相比，原子操作類(lèi)因?yàn)椴捎脽o(wú)鎖的方式實(shí)現(xiàn)，因此某些場(chǎng)景下可以帶來(lái)更高的執(zhí)行效率。

2.2、對(duì)象引用類(lèi)型

上文提到的基本類(lèi)型的原子類(lèi)，只能更新一個(gè)變量，如果需要原子性更新多個(gè)變量，這個(gè)時(shí)候可以采用對(duì)象引用類(lèi)型的原子操作類(lèi)，將多個(gè)變量封裝到一個(gè)對(duì)象中，JDK為開(kāi)發(fā)者提供了三個(gè)對(duì)象引用類(lèi)型的原子類(lèi)，內(nèi)容如下：

AtomicReference：對(duì)象引用類(lèi)型的原子操作類(lèi)
AtomicStampedReference：帶有版本號(hào)的對(duì)象引用類(lèi)型的原子操作類(lèi)，可以解決 ABA 問(wèn)題
AtomicMarkableReference：帶有標(biāo)記的對(duì)象引用類(lèi)型的原子操作類(lèi)

以AtomicReference為例，構(gòu)造一個(gè)對(duì)象引用，具體用法如下：

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<>();
// 設(shè)置原始值
User user1 = new User("張三", 20);
atomicReference.set(user1);

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

輸出結(jié)果：

更新后的對(duì)象：User{name='李四', age=21}

2.3、對(duì)象屬性類(lèi)型

在某項(xiàng)場(chǎng)景下，可能你只想原子性更新對(duì)象中的某個(gè)屬性值，此時(shí)可以采用對(duì)象屬性類(lèi)型的原子操作類(lèi)，JDK為開(kāi)發(fā)者提供了三個(gè)對(duì)象屬性類(lèi)型的原子類(lèi)，內(nèi)容如下：

AtomicIntegerFieldUpdater：屬性為整數(shù)類(lèi)型的原子操作類(lèi)
AtomicLongFieldUpdater：屬性為長(zhǎng)整數(shù)類(lèi)型的原子操作類(lèi)
AtomicReferenceFieldUpdater：屬性為對(duì)象類(lèi)型的原子操作類(lèi)

需要注意的是，這些原子操作類(lèi)需要滿(mǎn)足以下條件才可以使用。

1.被操作的字段不能是 static 類(lèi)型
2.被操縱的字段不能是 final 類(lèi)型
3.被操作的字段必須是 volatile 修飾的
4.屬性必須對(duì)于當(dāng)前的 Updater 所在區(qū)域是可見(jiàn)的，簡(jiǎn)單的說(shuō)就是盡量使用public修飾字段

以AtomicIntegerFieldUpdater為例，構(gòu)造一個(gè)整數(shù)類(lèi)型的屬性引用，具體用法如下：

public class User {

    private String name;

    /**
     * age 字段加上 volatile 關(guān)鍵字，并且改成 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));

輸出結(jié)果：

更新后的屬性值：21

2.4、數(shù)組類(lèi)型

數(shù)組類(lèi)型的原子操作類(lèi)，并不是指對(duì)數(shù)組本身的原子操作，而是對(duì)數(shù)組中的元素進(jìn)行原子性操作，這一點(diǎn)需要特別注意，如果要針對(duì)整個(gè)數(shù)組進(jìn)行更新，可以采用對(duì)象引入類(lèi)型的原子操作類(lèi)進(jìn)行處理。

JDK為開(kāi)發(fā)者提供了三個(gè)數(shù)組類(lèi)型的原子類(lèi)，內(nèi)容如下：

AtomicIntegerArray：數(shù)組為整數(shù)類(lèi)型的原子操作類(lèi)
AtomicLongArray：數(shù)組為長(zhǎng)整數(shù)類(lèi)型的原子操作類(lèi)
AtomicReferenceArray：數(shù)組為對(duì)象類(lèi)型的原子操作類(lèi)

以AtomicIntegerArray為例，具體用法如下：

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

輸出結(jié)果：

下標(biāo)為[0]的元素，更新后的值：1

2.5、累加器類(lèi)型

累加器類(lèi)型的原子操作類(lèi)，是從 jdk 1.8 開(kāi)始加入的，專(zhuān)門(mén)用來(lái)執(zhí)行數(shù)值類(lèi)型的數(shù)據(jù)累加操作，性能更好。

它的實(shí)現(xiàn)原理與基本數(shù)據(jù)類(lèi)型的原子類(lèi)略有不同，當(dāng)多線(xiàn)程競(jìng)爭(zhēng)時(shí)采用分段累加的思路來(lái)實(shí)現(xiàn)目標(biāo)值，在多線(xiàn)程環(huán)境中，它比AtomicLong性能要高出不少，特別是寫(xiě)多的場(chǎng)景。

JDK為開(kāi)發(fā)者提供了四個(gè)累加器類(lèi)型的原子類(lèi)，內(nèi)容如下：

LongAdder：長(zhǎng)整數(shù)類(lèi)型的原子累加操作類(lèi)
LongAccumulator：LongAdder的功能增強(qiáng)版，它支持自定義的函數(shù)操作
DoubleAdder：浮點(diǎn)數(shù)類(lèi)型的原子累加操作類(lèi)
DoubleAccumulator：同樣的，也是DoubleAdder的功能增強(qiáng)版，支持自定義的函數(shù)操作

以LongAdder為例，具體用法如下：

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

輸出結(jié)果：

最新值：3

三、原理解析

在上文中，我們提到了原子類(lèi)的底層主要基于CAS來(lái)實(shí)現(xiàn)，CAS的全稱(chēng)是：Compare and Swap，翻譯過(guò)來(lái)就是：比較并替換。

CAS是實(shí)現(xiàn)并發(fā)算法時(shí)常用的一種技術(shù)，它包含三個(gè)操作數(shù)：內(nèi)存位置、預(yù)期原值及新值。在執(zhí)行CAS操作的時(shí)候，會(huì)將內(nèi)存位置的值與預(yù)期原值比較，如果一致，會(huì)將該位置的值更新為新值；否則，不做任何操作。

我們還是以上文介紹的AtomicInteger為例，部分源碼內(nèi)容如下：

public class AtomicInteger extends Number implements java.io.Serializable {
    private static final long serialVersionUID = 6214790243416807050L;

    // 使用 Unsafe.compareAndSwapInt 方法進(jìn)行 CAS 操作
    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); }
    }

    // 變量使用 volatile 保證可見(jiàn)性
    private volatile int value;

    /**
     * get 方法
     */
    public final int get() {
        return value;
    }

    /**
     * 原子性自增操作
     */
    public final int incrementAndGet() {
        return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
    }
}

從源碼上可以清晰的看出，變量value使用了volatile關(guān)鍵字，保證數(shù)據(jù)可見(jiàn)性和程序的有序性；原子性自增操作incrementAndGet()方法，路由到Unsafe.getAndAddInt()方法上。

我們繼續(xù)往下看Unsafe.getAndAddInt()這個(gè)方法，部分源碼內(nèi)容如下：

public final class Unsafe {

    public final int getAndAddInt(Object var1, long var2, int var4) {
        int var5;
        // 1.循環(huán)比較并替換，只有成功才返回
        do {
            // 2.調(diào)用底層方法得到 value 值
            var5 = this.getIntVolatile(var1, var2);
            // 3.通過(guò)var1和var2得到底層值，var5為當(dāng)前值，如果底層值與當(dāng)前值相同，則將值設(shè)為var5+var4
        } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
        // 4.如果替換成功，返回當(dāng)前值
        return var5;
    }

    /**
     * CAS 核心方法，由其他語(yǔ)言實(shí)現(xiàn)，不再分析
     */
    public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);
}

從以上的源碼可以清晰的看到，incrementAndGet()方法主要基于Unsafe.compareAndSwapInt方法來(lái)實(shí)現(xiàn)，同時(shí)進(jìn)行了循環(huán)比較與替換的操作，只有替換成功才會(huì)返回，這個(gè)過(guò)程也被稱(chēng)為自旋操作，確保程序執(zhí)行成功，進(jìn)一步保證了操作的原子性。

其它的方法實(shí)現(xiàn)思路也類(lèi)似。

如果我們自己通過(guò)CAS編寫(xiě)incrementAndGet()，大概長(zhǎng)這樣：

public int incrementAndGet(AtomicInteger var) {
    int prev, next;
    do {
        prev = var.get();
        next = prev + 1;
    } while ( !var.compareAndSet(prev, next));
    return next;
}

當(dāng)并發(fā)數(shù)量比較低的時(shí)候，采用CAS這種方式可以實(shí)現(xiàn)更快的執(zhí)行效率；當(dāng)并發(fā)數(shù)量比較高的時(shí)候，因?yàn)榇嬖谘h(huán)比較與替換的邏輯，如果長(zhǎng)時(shí)間循環(huán)，可能會(huì)更加消耗 CPU 資源，此時(shí)采用synchronized或Lock來(lái)實(shí)現(xiàn)線(xiàn)程同步，可能會(huì)更有優(yōu)勢(shì)。

四、ABA問(wèn)題

從上文的分析中，我們知道 CAS 在操作的時(shí)候會(huì)檢查預(yù)期原值是否發(fā)生變化，當(dāng)預(yù)期原值沒(méi)有發(fā)生變化才會(huì)更新值。

在實(shí)際業(yè)務(wù)中，可能會(huì)出現(xiàn)這么一個(gè)現(xiàn)象：線(xiàn)程 t1 正嘗試將共享變量的值 A 進(jìn)行修改，但還沒(méi)修改；此時(shí)另一個(gè)線(xiàn)程 t2 獲取到 CPU 時(shí)間片，將共享變量的值 A 修改成 B，然后又修改為 A，此時(shí)線(xiàn)程 t1 檢查發(fā)現(xiàn)共享變量的值沒(méi)有發(fā)生變化，就會(huì)主動(dòng)去更新值，導(dǎo)致出現(xiàn)了錯(cuò)誤更新，但是實(shí)際上原始值在這個(gè)過(guò)程中發(fā)生了好幾次變化。這個(gè)現(xiàn)象我們稱(chēng)它為 ABA 問(wèn)題。

ABA 問(wèn)題的解決思路就是使用版本號(hào)，在變量前面追加上版本號(hào)，每次變量更新的時(shí)候把版本號(hào)加 1，原來(lái)的A-B-A就會(huì)變成1A-2B-3A。

在java.util.concurrent.atomic包下提供了AtomicStampedReference類(lèi)，它支持指定版本號(hào)來(lái)更新，可以通過(guò)它來(lái)解決 ABA 問(wèn)題。

在AtomicStampedReference類(lèi)的compareAndSet()方法中，會(huì)檢查當(dāng)前引用是否等于預(yù)期引用，并且當(dāng)前版本號(hào)是否等于預(yù)期版本號(hào)，如果全部相等，則以原子方式將該引用的值設(shè)置為給定的更新值，同時(shí)更新版本號(hào)。

具體示例如下：

// 初始化一個(gè)帶版本號(hào)的原子操作類(lèi)，原始值：a，原始版本號(hào)：1
AtomicStampedReference<String> reference = new AtomicStampedReference<>("a", 1);

// 將a更為b，同時(shí)將版本號(hào)加1，第一個(gè)參數(shù)：預(yù)期原值；第二個(gè)參數(shù)：更新后的新值；第三個(gè)參數(shù)：預(yù)期原版本號(hào)；第四個(gè)參數(shù)：更新后的版本號(hào)
boolean result1 = reference.compareAndSet("a", "b", reference.getStamp(), reference.getStamp() + 1);
System.out.println("第一次更新：" + result1);

// 將b更為a，因?yàn)轭A(yù)期原版本號(hào)不對(duì)，所以更新失敗
boolean result2 = reference.compareAndSet("b", "a", 1, reference.getStamp());
System.out.println("第二次更新：" + result2);

輸出結(jié)果：

第一次更新：true
第二次更新：false

五、小結(jié)

本文主要圍繞AtomicInteger的用法和原理進(jìn)行一次知識(shí)總結(jié)，JUC包下的原子操作類(lèi)非常的多，但是大體用法基本相似，只是針對(duì)不同的數(shù)據(jù)類(lèi)型做了細(xì)分處理。

在實(shí)際業(yè)務(wù)開(kāi)發(fā)中，原子操作類(lèi)通常用于計(jì)數(shù)器，累加器等場(chǎng)景，比如編寫(xiě)一個(gè)多線(xiàn)程安全的全局唯一 ID 生成器。

public class IdGenerator {

    private static AtomicLong atomic = new AtomicLong(0);

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

希望本篇的知識(shí)總結(jié)，能幫助到大家！