多線程系列(十六) -常用併發原子類詳解

一、簡介

在 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

三、原理解析

在上文中，我們提到了原子類的底層主要基於CAS來實現，CAS的全稱是：Compare and Swap，翻譯過來就是：比較並替換。

CAS是實現併發算法時常用的一種技術，它包含三個操作數：內存位置、預期原值及新值。在執行CAS操作的時候，會將內存位置的值與預期原值比較，如果一致，會將該位置的值更新爲新值；否則，不做任何操作。

我們還是以上文介紹的AtomicInteger爲例，部分源碼內容如下：

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

    // 使用 Unsafe.compareAndSwapInt 方法進行 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 保證可見性
    private volatile int value;

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

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

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

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

public final class Unsafe {

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

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

從以上的源碼可以清晰的看到，incrementAndGet()方法主要基於Unsafe.compareAndSwapInt方法來實現，同時進行了循環比較與替換的操作，只有替換成功纔會返回，這個過程也被稱爲自旋操作，確保程序執行成功，進一步保證了操作的原子性。

其它的方法實現思路也類似。

如果我們自己通過CAS編寫incrementAndGet()，大概長這樣：

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

當併發數量比較低的時候，採用CAS這種方式可以實現更快的執行效率；當併發數量比較高的時候，因爲存在循環比較與替換的邏輯，如果長時間循環，可能會更加消耗 CPU 資源，此時採用synchronized或Lock來實現線程同步，可能會更有優勢。

四、ABA問題

從上文的分析中，我們知道 CAS 在操作的時候會檢查預期原值是否發生變化，當預期原值沒有發生變化纔會更新值。

在實際業務中，可能會出現這麼一個現象：線程 t1 正嘗試將共享變量的值 A 進行修改，但還沒修改；此時另一個線程 t2 獲取到 CPU 時間片，將共享變量的值 A 修改成 B，然後又修改爲 A，此時線程 t1 檢查發現共享變量的值沒有發生變化，就會主動去更新值，導致出現了錯誤更新，但是實際上原始值在這個過程中發生了好幾次變化。這個現象我們稱它爲 ABA 問題。

ABA 問題的解決思路就是使用版本號，在變量前面追加上版本號，每次變量更新的時候把版本號加 1，原來的A-B-A就會變成1A-2B-3A。

在java.util.concurrent.atomic包下提供了AtomicStampedReference類，它支持指定版本號來更新，可以通過它來解決 ABA 問題。

在AtomicStampedReference類的compareAndSet()方法中，會檢查當前引用是否等於預期引用，並且當前版本號是否等於預期版本號，如果全部相等，則以原子方式將該引用的值設置爲給定的更新值，同時更新版本號。

具體示例如下：

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

// 將a更爲b，同時將版本號加1，第一個參數：預期原值；第二個參數：更新後的新值；第三個參數：預期原版本號；第四個參數：更新後的版本號
boolean result1 = reference.compareAndSet("a", "b", reference.getStamp(), reference.getStamp() + 1);
System.out.println("第一次更新：" + result1);

// 將b更爲a，因爲預期原版本號不對，所以更新失敗
boolean result2 = reference.compareAndSet("b", "a", 1, reference.getStamp());
System.out.println("第二次更新：" + result2);

輸出結果：

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

五、小結

本文主要圍繞AtomicInteger的用法和原理進行一次知識總結，JUC包下的原子操作類非常的多，但是大體用法基本相似，只是針對不同的數據類型做了細分處理。

在實際業務開發中，原子操作類通常用於計數器，累加器等場景，比如編寫一個多線程安全的全局唯一 ID 生成器。

public class IdGenerator {

    private static AtomicLong atomic = new AtomicLong(0);

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

希望本篇的知識總結，能幫助到大家！

六、參考

1.https://www.liaoxuefeng.com/wiki/1252599548343744/1306581083881506

2.https://blog.csdn.net/zzti_erlie/article/details/123001758

3.https://juejin.cn/post/7057032581165875231

多線程系列(十六) -常用併發原子類詳解

一、簡介

二、常用原子操作類

2.1、基本類型

方式一：線程不安全操作實現

方式二：線程同步安全操作實現

方式三：原子類操作實現

2.2、對象引用類型

2.3、對象屬性類型

2.4、數組類型

2.5、累加器類型

三、原理解析

四、ABA問題

五、小結

六、參考

多線程系列(二十一) -ForkJoin使用詳解

多線程系列(二十) -CompletableFuture使用詳解

多線程系列(十九) -Future使用詳解

多線程系列(十七) -線程組介紹

多線程系列(十八) -AQS原理淺析

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結