這是java高併發系列第32篇文章。

java環境：jdk1.8。

本文主要內容

1. 4種方式實現計數器功能，對比其效能
2. 介紹LongAdder
3. 介紹LongAccumulator

需求：一個jvm中實現一個計數器功能，需保證多執行緒情況下資料正確性。

我們來模擬50個執行緒，每個執行緒對計數器遞增100萬次，最終結果應該是5000萬。

我們使用4種方式實現，看一下其效能，然後引出為什麼需要使用LongAdder、LongAccumulator。

方式一：synchronized方式實現

package com.itsoku.chat32;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.atomic.LongAccumulator;

/**
 * 跟著阿里p7學併發，微信公眾號：javacode2018
 */
public class Demo1 {
    static int count = 0;

    public static synchronized void incr() {
        count++;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        for (int i = 0; i < 10; i++) {
            count = 0;
            m1();
        }
    }

    private static void m1() throws InterruptedException {
        long t1 = System.currentTimeMillis();
        int threadCount = 50;
        CountDownLatch countDownLatch = new CountDownLatch(threadCount);
        for (int i = 0; i < threadCount; i++) {
            new Thread(() -> {
                try {
                    for (int j = 0; j < 1000000; j++) {
                        incr();
                    }
                } finally {
                    countDownLatch.countDown();
                }
            }).start();
        }
        countDownLatch.await();
        long t2 = System.currentTimeMillis();
        System.out.println(String.format("結果：%s,耗時(ms)：%s", count, (t2 - t1)));
    }
}
 

輸出：

結果：50000000,耗時(ms)：1437
結果：50000000,耗時(ms)：1913
結果：50000000,耗時(ms)：386
結果：50000000,耗時(ms)：383
結果：50000000,耗時(ms)：381
結果：50000000,耗時(ms)：382
結果：50000000,耗時(ms)：379
結果：50000000,耗時(ms)：379
結果：50000000,耗時(ms)：392
結果：50000000,耗時(ms)：384

平均耗時：390毫秒

方式2：AtomicLong實現

package com.itsoku.chat32;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.atomic.AtomicLong;

/**
 * 跟著阿里p7學併發，微信公眾號：javacode2018
 */
public class Demo2 {
    static AtomicLong count = new AtomicLong(0);

    public static void incr() {
        count.incrementAndGet();
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        for (int i = 0; i < 10; i++) {
            count.set(0);
            m1();
        }
    }

    private static void m1() throws InterruptedException {
        long t1 = System.currentTimeMillis();
        int threadCount = 50;
        CountDownLatch countDownLatch = new CountDownLatch(threadCount);
        for (int i = 0; i < threadCount; i++) {
            new Thread(() -> {
                try {
                    for (int j = 0; j < 1000000; j++) {
                        incr();
                    }
                } finally {
                    countDownLatch.countDown();
                }
            }).start();
        }
        countDownLatch.await();
        long t2 = System.currentTimeMillis();
        System.out.println(String.format("結果：%s,耗時(ms)：%s", count, (t2 - t1)));
    }
}
 

輸出：

結果：50000000,耗時(ms)：971
結果：50000000,耗時(ms)：915
結果：50000000,耗時(ms)：920
結果：50000000,耗時(ms)：923
結果：50000000,耗時(ms)：910
結果：50000000,耗時(ms)：916
結果：50000000,耗時(ms)：923
結果：50000000,耗時(ms)：916
結果：50000000,耗時(ms)：912
結果：50000000,耗時(ms)：908

平均耗時：920毫秒

AtomicLong內部採用CAS的方式實現，併發量大的情況下，CAS失敗率比較高，導致效能比synchronized還低一些。併發量不是太大的情況下，CAS效能還是可以的。

AtomicLong屬於JUC中的原子類，還不是很熟悉的可以看一下：JUC中原子類，一篇就夠了

方式3：LongAdder實現

先介紹一下LongAdder，說到LongAdder，不得不提的就是AtomicLong，AtomicLong是JDK1.5開始出現的，裡面主要使用了一個long型別的value作為成員變數，然後使用迴圈的CAS操作去操作value的值，併發量比較大的情況下，CAS操作失敗的概率較高，內部失敗了會重試，導致耗時可能會增加。

LongAdder是JDK1.8開始出現的，所提供的API基本上可以替換掉原先的AtomicLong。LongAdder在併發量比較大的情況下，操作資料的時候，相當於把這個數字分成了很多份數字，然後交給多個人去管控，每個管控者負責保證部分數字在多執行緒情況下操作的正確性。當多執行緒訪問的時，通過hash演算法對映到具體管控者去操作資料，最後再彙總所有的管控者的資料，得到最終結果。相當於降低了併發情況下鎖的粒度，所以效率比較高，看一下下面的圖，方便理解：

程式碼：

package com.itsoku.chat32;

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

/**
 * 跟著阿里p7學併發，微信公眾號：javacode2018
 */
public class Demo3 {
    static LongAdder count = new LongAdder();

    public static void incr() {
        count.increment();
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        for (int i = 0; i < 10; i++) {
            count.reset();
            m1();
        }
    }

    private static void m1() throws ExecutionException, InterruptedException {
        long t1 = System.currentTimeMillis();
        int threadCount = 50;
        CountDownLatch countDownLatch = new CountDownLatch(threadCount);
        for (int i = 0; i < threadCount; i++) {
            new Thread(() -> {
                try {
                    for (int j = 0; j < 1000000; j++) {
                        incr();
                    }
                } finally {
                    countDownLatch.countDown();
                }
            }).start();
        }
        countDownLatch.await();
        long t2 = System.currentTimeMillis();
        System.out.println(String.format("結果：%s,耗時(ms)：%s", count.sum(), (t2 - t1)));
    }
}

輸出：

結果：50000000,耗時(ms)：206
結果：50000000,耗時(ms)：105
結果：50000000,耗時(ms)：107
結果：50000000,耗時(ms)：107
結果：50000000,耗時(ms)：105
結果：50000000,耗時(ms)：99
結果：50000000,耗時(ms)：106
結果：50000000,耗時(ms)：102
結果：50000000,耗時(ms)：106
結果：50000000,耗時(ms)：102

平均耗時：100毫秒

程式碼中new LongAdder()建立一個LongAdder物件，內部數字初始值是0，呼叫increment()方法可以對LongAdder內部的值原子遞增1。reset()方法可以重置LongAdder的值，使其歸0。

方式4：LongAccumulator實現

LongAccumulator介紹

LongAccumulator是LongAdder的功能增強版。LongAdder的API只有對數值的加減，而LongAccumulator提供了自定義的函式操作，其建構函式如下：

/**
  * accumulatorFunction：需要執行的二元函式（接收2個long作為形參，並返回1個long）
  * identity：初始值
 **/
public LongAccumulator(LongBinaryOperator accumulatorFunction, long identity) {
    this.function = accumulatorFunction;
    base = this.identity = identity;
}

示例程式碼：

package com.itsoku.chat32;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.atomic.LongAccumulator;
import java.util.concurrent.atomic.LongAdder;

/**
 * 跟著阿里p7學併發，微信公眾號：javacode2018
 */
public class Demo4 {
    static LongAccumulator count = new LongAccumulator((x, y) -> x + y, 0L);

    public static void incr() {
        count.accumulate(1);
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        for (int i = 0; i < 10; i++) {
            count.reset();
            m1();
        }
    }

    private static void m1() throws ExecutionException, InterruptedException {
        long t1 = System.currentTimeMillis();
        int threadCount = 50;
        CountDownLatch countDownLatch = new CountDownLatch(threadCount);
        for (int i = 0; i < threadCount; i++) {
            new Thread(() -> {
                try {
                    for (int j = 0; j < 1000000; j++) {
                        incr();
                    }
                } finally {
                    countDownLatch.countDown();
                }
            }).start();
        }
        countDownLatch.await();
        long t2 = System.currentTimeMillis();
        System.out.println(String.format("結果：%s,耗時(ms)：%s", count.longValue(), (t2 - t1)));
    }
}

輸出：

結果：50000000,耗時(ms)：138
結果：50000000,耗時(ms)：111
結果：50000000,耗時(ms)：111
結果：50000000,耗時(ms)：103
結果：50000000,耗時(ms)：103
結果：50000000,耗時(ms)：105
結果：50000000,耗時(ms)：101
結果：50000000,耗時(ms)：106
結果：50000000,耗時(ms)：102
結果：50000000,耗時(ms)：103

平均耗時：100毫秒

LongAccumulator的效率和LongAdder差不多，不過更靈活一些。

呼叫new LongAdder()等價於new LongAccumulator((x, y) -> x + y, 0L)。

從上面4個示例的結果來看，LongAdder、LongAccumulator全面超越同步鎖及AtomicLong的方式，建議在使用AtomicLong的地方可以直接替換為LongAdder、LongAccumulator，吞吐量更高一些。

java高併發系列目錄

1. 第1天:必須知道的幾個概念
2. 第2天:併發級別
3. 第3天:有關並行的兩個重要定律
4. 第4天:JMM相關的一些概念
5. 第5天:深入理解程序和執行緒
6. 第6天:執行緒的基本操作
7. 第7天:volatile與Java記憶體模型
8. 第8天:執行緒組
9. 第9天：使用者執行緒和守護執行緒
10. 第10天:執行緒安全和synchronized關鍵字
11. 第11天:執行緒中斷的幾種方式
12. 第12天JUC:ReentrantLock重入鎖
13. 第13天:JUC中的Condition物件
14. 第14天:JUC中的LockSupport工具類，必備技能
15. 第15天：JUC中的Semaphore（訊號量）
16. 第16天：JUC中等待多執行緒完成的工具類CountDownLatch，必備技能
17. 第17天：JUC中的迴圈柵欄CyclicBarrier的6種使用場景
18. 第18天：JAVA執行緒池，這一篇就夠了
19. 第19天：JUC中的Executor框架詳解1
20. 第20天：JUC中的Executor框架詳解2
21. 第21天：java中的CAS，你需要知道的東西
22. 第22天：JUC底層工具類Unsafe，高手必須要了解
23. 第23天：JUC中原子類，一篇就夠了
24. 第24天：ThreadLocal、InheritableThreadLocal（通俗易懂）
25. 第25天：掌握JUC中的阻塞佇列
26. 第26篇：學會使用JUC中常見的集合，常看看！
27. 第27天：實戰篇，介面效能提升幾倍原來這麼簡單
28. 第28天：實戰篇，微服務日誌的傷痛，一併幫你解決掉
29. 第29天：高併發中常見的限流方式
30. 第30天：JUC中工具類CompletableFuture，必備技能
31. 第31天：獲取執行緒執行結果，這6種方法你都知道？

阿里p7一起學併發，公眾號：路人甲java，每天獲取最新文章！

相關推薦