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

来源:https://www.cnblogs.com/dxflqm/p/18065371
-Advertisement-
Play Games

在 Java 的java.util.concurrent包中，除了提供底層鎖、併發同步等工具類以外，還提供了一組原子操作類，大多以Atomic開頭，他們位於java.util.concurrent.atomic包下。 ...


一、簡介

在 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


作者：程式員志哥
出處：pzblog.cn
資源：微信搜【程式員志哥】關註我，回覆 【技術資料】有我準備的一線程式必備電腦書籍、大廠面試資料和免費電子書。 希望可以幫助大家提升技術和能力。


您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • Redis 故障轉移、高可用方案，都在這了！
    Redis大家都不陌生，就算是沒用過，也都聽說過了。 作為最廣泛使用的KV記憶體資料庫之一，在當今的大流量時代，單機模式略顯單薄，免不了要有一些拓展的方案。 筆者下文會對各種方案進行介紹，並且給出場景，實現 等等概述，還會提到一些新手常見的誤區。 正文 先從基礎的拓展方式開始，這樣更便於理解較高級的模 ...
  • 我為什麼使用Linux做開發
    系統選擇 目前市面上主流的桌面操作系統在大多數人眼裡只有Windows和MacOS，那為什麼我沒選擇它們兩呢？ 首先，不選MacOS的原因，就是太貴。當然這是我的原因不是蘋果的原因，我最早使用Linux寫代碼的時候是2018年，那時候剛畢業上班不久，根本買不起Mac（雖然現在也覺得有點貴）。 在沒有 ...
  • 雲計算 - 內容分髮網絡CDN技術與應用全解
    在這篇全面解析CDN的技術文章中，我們深入探討了CDN的基礎概念、核心架構、多樣化產品和在不同行業中的應用案例。文章揭示了CDN技術如何優化內容分發，提升用戶體驗，並展望了CDN面臨的挑戰和未來發展趨勢。 關註【TechLeadCloud】，分享互聯網架構、雲服務技術的全維度知識。作者擁有10+年互 ...
  • 依賴註入 與 Wire 的使用
    寫在前面 在Java日常開發過程中，實現Excel文件的導入導出功能是一項常見的需求。 通過使用相關的Java庫，如Apache POI、EasyPoi或EasyExcel，可以輕鬆地實現Excel文件的讀寫操作。 而這篇文章將介紹如何在Java中使用Apache POI、EasyPoi 和Easy ...
  • 分塊學習筆記
    學了分塊，感覺這玩意好難啊，怎麼聽起來這麼簡單？【】【】分塊！ 先推薦一個東西：loj 分塊全家桶！ 首先，把一整個數組劈成 \(\sqrt n\) 塊是最優的！（當然如果你想寫一個 \(114514\) 塊的分塊也沒問題但他不優啊！） 長這樣： 這樣它的複雜度是： 預處理：\(O(n\sqrt n ...
  • 狂神說Java——Mybatis學習筆記
    前言：配合狂神老師的教學視頻使用效果更佳： https://www.bilibili.com/video/BV1NE411Q7Nx/?spm_id_from=333.1007.top_right_bar_window_custom_collection.content.click&vd_source ...
  • 深入淺出Java多線程(十)：CAS
    大家好，我是你們的老伙計秀才！今天帶來的是[深入淺出Java多線程]系列的第十篇內容：CAS。大家覺得有用請點贊，喜歡請關註！秀才在此謝過大家了！！！ ...
  • Python 在Word中創建表格並填入數據、圖片
    在Word中，表格是一個強大的工具，它可以幫助你更好地組織、呈現和分析信息。本文將介紹如何使用Python在Word中創建表格並填入數據、圖片，以及設置表格樣式等。 Python Word庫： 要使用Python在Word中創建或操作表格，需要先將Spire.Doc for Python這個第三方庫 ...
一周排行
    -Advertisement-
    Play Games
  • WPF 已知問題 監聽 WMI 事件導致觸摸失效
    示例項目結構 在 Visual Studio 中創建一個 WinForms 應用程式後，項目結構如下所示： MyWinFormsApp/ │ ├───Properties/ │ └───Settings.settings │ ├───bin/ │ ├───Debug/ │ └───Release/ ...
  • [STAThread]特性
    [STAThread] 特性用於需要與 COM 組件交互的應用程式，尤其是依賴單線程模型（如 Windows Forms 應用程式）的組件。在 STA 模式下，線程擁有自己的消息迴圈，這對於處理用戶界面和某些 COM 組件是必要的。 [STAThread] static void Main(stri ...
  • UWP WinUI3 傳入 AddHandler 的 RoutedEventHandler 類型與事件所需不匹配將拋出參數異常
    在WinForm中使用全局異常捕獲處理 在WinForm應用程式中，全局異常捕獲是確保程式穩定性的關鍵。通過在Program類的Main方法中設置全局異常處理，可以有效地捕獲並處理未預見的異常，從而避免程式崩潰。 註冊全局異常事件 [STAThread] static void Main() { / ...
  • .NET 多版本 WinForm 開源控制項庫 SunnyUI
    前言 給大家推薦一款開源的 Winform 控制項庫，可以幫助我們開發更加美觀、漂亮的 WinForm 界面。 項目介紹 SunnyUI.NET 是一個基於 .NET Framework 4.0+、.NET 6、.NET 7 和 .NET 8 的 WinForm 開源控制項庫，同時也提供了工具類庫、擴展 ...
  • .net core8 使用Swagger（附當前源碼）
    說明 該文章是屬於OverallAuth2.0系列文章，每周更新一篇該系列文章（從0到1完成系統開發）。 該系統文章，我會儘量說的非常詳細，做到不管新手、老手都能看懂。 說明：OverallAuth2.0 是一個簡單、易懂、功能強大的許可權+可視化流程管理系統。 有興趣的朋友，請關註我吧(*^▽^*) ...
  • WPF 什麼時候 VisualTreeHelper.GetDescendantBounds 將返回無窮大
    一、下載安裝 1.下載git 必須先下載並安裝git，再TortoiseGit下載安裝 git安裝參考教程：https://blog.csdn.net/mukes/article/details/115693833 2.TortoiseGit下載與安裝 TortoiseGit，Git客戶端，32/6 ...
  • C# 開源教程帶你輕鬆掌握數據結構與演算法
    前言 在項目開發過程中，理解數據結構和演算法如同掌握蓋房子的秘訣。演算法不僅能幫助我們編寫高效、優質的代碼，還能解決項目中遇到的各種難題。 給大家推薦一個支持C#的開源免費、新手友好的數據結構與演算法入門教程：Hello演算法。 項目介紹 《Hello Algo》是一本開源免費、新手友好的數據結構與演算法入門 ...
  • 第22篇 生成proto文件bat腳本
    1.生成單個Proto.bat內容 @rem Copyright 2016, Google Inc. @rem All rights reserved. @rem @rem Redistribution and use in source and binary forms, with or with ...
  • 記一次 .NET某上位機視覺程式 卡死分析
    一：背景 1. 講故事 前段時間有位朋友找到我，說他的窗體程式在客戶這邊出現了卡死，讓我幫忙看下怎麼回事？dump也生成了，既然有dump了那就上 windbg 分析吧。 二：WinDbg 分析 1. 為什麼會卡死 窗體程式的卡死，入口門檻很低，後續往下分析就不一定了，不管怎麼說先用 !clrsta ...
  • 醫學DICOM文件與PACS系統進行數據傳輸
    前言 人工智慧時代，人臉識別技術已成為安全驗證、身份識別和用戶交互的關鍵工具。 給大家推薦一款.NET 開源提供了強大的人臉識別 API，工具不僅易於集成，還具備高效處理能力。 本文將介紹一款如何利用這些API，為我們的項目添加智能識別的亮點。 項目介紹 GitHub 上擁有 1.2k 星標的 C# ...
所有分類