詳細總結Java中常用的原子類

Posted on by

一、什麼是原子類

Java中提供瞭一些原子類，原子類包裝瞭一個變量，並且提供瞭一系列對變量進行原子性操作的方法。我們在多線程環境下對這些原子類進行操作時，不需要加鎖，大大簡化瞭並發編程的開發。

二、原子類的底層實現

目前Java中提供的原子類大部分底層使用瞭CAS鎖（CompareAndSet自旋鎖），如AtomicInteger、AtomicLong等；也有使用瞭分段鎖+CAS鎖的原子類，如LongAdder等。

三、常用的原子類

3.1 AtomicInteger與AtomicLong

AtomicInteger與AtomicLong的底層實現與用法基本相同，不同點在於AtomicInteger包裝瞭一個Integer型變量，而AtomicLong包裝瞭一個Long型變量。
AtomicInteger與AtomicLong的底層實現都使用瞭CAS鎖。

import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;

/**
 * @author IT00ZYQ
 * @date 2021/5/24 15:33
 **/
public class T13_AtomicInteger {
    private static AtomicInteger atomicInteger = new AtomicInteger();
    private static AtomicLong atomicLong = new AtomicLong();
    private static Integer integer = 0;
    private static Long lon = 0L;
    public static void main(String[] args) {

        // 創建10個線程，分別對atomicInteger、atomicLong、integer、lon進行1000次增加1的操作
        // 如果操作是原子性的，那麼正確結果 = 10 * 1000 = 10000
        Thread[] threads = new Thread[10];
        for (int i = 0; i < 10; i++) {
            threads[i] = new Thread(() -> {
                for (int j = 1; j <= 1000; j++) {
                    atomicInteger.incrementAndGet();
                    atomicLong.incrementAndGet();
                    integer ++;
                    lon ++;
                }
            });
        }

        // 啟動線程
        for (Thread thread : threads) {
            thread.start();
        }

        // 保證10個線程運行完成
        try {
            for (Thread thread : threads) {
                thread.join();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("AtomicInteger的結果：" + atomicInteger);
        System.out.println("AtomicLong的結果：" + atomicLong);
        System.out.println("Integer的結果：" + integer);
        System.out.println("Long的結果：" + lon);
    }
}

運行結果：

AtomicInteger的結果：10000
AtomicLong的結果：10000
Integer的結果：4880
Long的結果：4350
Process finished with exit code 0

多次運行發現原子類AtomicInteger與AtomicLong每次都能得到正確的結果10000，但是非原子類Integer與Long一般情況下都達不到10000，每次的結果也可能不一樣。

3.2 LongAdder

LongAdder的底層實現使用瞭分段鎖，每個段使用的鎖是CAS鎖，所以LongAdder的底層實現是分段鎖+CAS鎖。
在上面的程序添加瞭一個LongAdder變量進行測試

import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.atomic.LongAdder;

/**
 * @author IT00ZYQ
 * @date 2021/5/24 15:33
 **/
public class T13_AtomicInteger {
    private static AtomicInteger atomicInteger = new AtomicInteger();
    private static AtomicLong atomicLong = new AtomicLong();
    private static LongAdder longAdder = new LongAdder();
    private static Integer integer = 0;
    private static Long lon = 0L;
    public static void main(String[] args) {

        // 創建10個線程，分別對atomicInteger、atomicLong、integer、lon進行1000次增加1的操作
        // 如果操作是原子性的，那麼正確結果 = 10 * 1000 = 10000
        Thread[] threads = new Thread[10];
        for (int i = 0; i < 10; i++) {
            threads[i] = new Thread(() -> {
                for (int j = 1; j <= 1000; j++) {
                    atomicInteger.incrementAndGet();
                    atomicLong.incrementAndGet();
                    integer ++;
                    lon ++;
                    longAdder.increment();
                }
            });
        }

        // 啟動線程
        for (Thread thread : threads) {
            thread.start();
        }

        // 保證10個線程運行完成
        try {
            for (Thread thread : threads) {
                thread.join();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("AtomicInteger的結果：" + atomicInteger);
        System.out.println("AtomicLong的結果：" + atomicLong);
        System.out.println("Integer的結果：" + integer);
        System.out.println("Long的結果：" + lon);
        System.out.println("LongAdder的結果：" + longAdder);
    }
}

運行結果：

AtomicInteger的結果：10000
AtomicLong的結果：10000
Integer的結果：6871
Long的結果：6518
LongAdder的結果：10000
Process finished with exit code 0

LongAdder類也是能夠正確輸出結果的。

四、原子類的性能測試

4.1 測試程序

package juc;

import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.atomic.LongAdder;

/**
 * @author IT00ZYQ
 * @date 2021/5/24 15:51
 **/
public class T14_AtomicClassPerformance {
    private static AtomicLong atomicLong = new AtomicLong();
    private static LongAdder longAdder = new LongAdder();
    /**
     * 線程數
     */
    private static final int THREAD_COUNT = 100;
    /**
     * 每次線程循環操作次數
     */
    private static final int OPERATION_COUNT = 10000;

    public static void main(String[] args) {
        Thread[] threads = new Thread[THREAD_COUNT];

        
        // 創建對AtomicLong進行操作的線程
        for (int i = 0; i < THREAD_COUNT; i++) {
            threads[i] = new Thread(() -> {
                for (int j = 0; j < OPERATION_COUNT; j++) {
                    atomicLong.incrementAndGet();
                }
            });
        }

        long start1 = System.currentTimeMillis();
        // 啟動線程
        for (Thread thread : threads) {
            thread.start();
        }

        // 保證線程運行完成
        try {
            for (Thread thread : threads) {
                thread.join();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        long end1 = System.currentTimeMillis();


        // 創建對LongAdder進行操作的線程
        for (int i = 0; i < THREAD_COUNT; i++) {
            threads[i] = new Thread(() -> {
                for (int j = 0; j < OPERATION_COUNT; j++) {
                    longAdder.increment();
                }
            });
        }

        long start2 = System.currentTimeMillis();
        // 啟動線程
        for (Thread thread : threads) {
            thread.start();
        }

        // 保證線程運行完成
        try {
            for (Thread thread : threads) {
                thread.join();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        long end2 = System.currentTimeMillis();

        System.out.println("AtomicLong運行時間: " + (end1 - start1) + "ms, 運行結果：" + atomicLong);
        System.out.println("LongAdder運行時間: " + (end2 - start2) + "ms, 運行結果：" + longAdder);
    }

}

4.2 測試結果

THREAD_COUNT = 100, OPERATION_COUNT = 1000時的運行結果

AtomicLong運行時間: 40ms, 運行結果：100000
LongAdder運行時間: 57ms, 運行結果：100000
Process finished with exit code 0

THREAD_COUNT = 100, OPERATION_COUNT = 10000時的運行結果

AtomicLong運行時間: 108ms, 運行結果：1000000
LongAdder運行時間: 85ms, 運行結果：1000000
Process finished with exit code 0

THREAD_COUNT = 100, OPERATION_COUNT = 1000000時的運行結果

AtomicLong運行時間: 6909ms, 運行結果：100000000
LongAdder運行時間: 468ms, 運行結果：100000000
Process finished with exit code 0

THREAD_COUNT = 10, OPERATION_COUNT = 1000000時的運行結果

AtomicLong運行時間: 788ms, 運行結果：10000000
LongAdder運行時間: 162ms, 運行結果10000000
Process finished with exit code 0

4.3 結果分析

當THREAD_COUNT * OPERATION_COUN足夠小時，AtomicInteger的性能會略高於LongAdder，而隨著THREAD_COUNT * OPERATION_COUN的增加，LongAdder的性能更高，THREAD_COUNT * OPERATION_COUN足夠大時，LongAdder的性能遠高於AtomicInteger。

4.4 底層實現分析

  • AtomicLong的原子性自增操作，是通過CAS實現的。在競爭線程數較少且每個線程的運行所需時間較短的情況下，這樣做是合適的。但是如果線程競爭激烈，會造成大量線程在原地打轉、不停嘗試去修改值，但是老是發現值被修改瞭，於是繼續自旋。 這樣浪費瞭大量的CPU資源。
  • LongAdder在競爭激烈時，多個線程並不會一直自旋來修改值，而是采用瞭分段的思想，各個線程會分散累加到自己所對應的Cell[]數組的某一個數組對象元素中，而不會大傢共用一個，把不同線程對應到不同的Cell中進行修改，降低瞭對臨界資源的競爭。本質上，是用空間換時間。

到此這篇關於詳細總結Java中常用的原子類的文章就介紹到這瞭,更多相關Java常用原子類內容請搜索WalkonNet以前的文章或繼續瀏覽下面的相關文章希望大傢以後多多支持WalkonNet！

推薦閱讀：