并發(fā)編程LongAdder的原理是什么

本篇內(nèi)容介紹了“并發(fā)編程LongAdder的原理是什么”的有關(guān)知識(shí)，在實(shí)際案例的操作過(guò)程中，不少人都會(huì)遇到這樣的困境，接下來(lái)就讓小編帶領(lǐng)大家學(xué)習(xí)一下如何處理這些情況吧！希望大家仔細(xì)閱讀，能夠?qū)W有所成！

目錄

• 一、前言

• 二、LongAdder類的使用

• 三、LongAdder原理的直觀理解

• 四、源碼分析

• 五、與AtomicInteger的比較

• 六、思想的抽象

一、前言

ConcurrentHashMap的源碼采用了一種比較獨(dú)特的方式對(duì)map中的元素?cái)?shù)量進(jìn)行統(tǒng)計(jì)，自然是要好好研究一下其原理思想，同時(shí)也能更好地理解ConcurrentHashMap本身。

本文主要思路分為以下5個(gè)部分：

1.計(jì)數(shù)的使用效果

2.原理的直觀圖解

3.源碼的細(xì)節(jié)分析

4.與AtomicInteger的比較

5.思想的抽象

學(xué)習(xí)的入口自然是map的put方法

public V put(K key, V value) {
    return putVal(key, value, false);
}

查看putVal方法

這里并不對(duì)ConcurrentHashMap本身的原理作過(guò)多討論，因此我們直接跳到計(jì)數(shù)部分

final V putVal(K key, V value, boolean onlyIfAbsent) {
    ...
    addCount(1L, binCount);
    return null;
}

每當(dāng)成功添加一個(gè)元素之后，都會(huì)調(diào)用addCount方法進(jìn)行數(shù)量的累加1的操作，這就是我們研究的目標(biāo)

因?yàn)镃oncurrentHashMap的設(shè)計(jì)初衷就是為了解決多線程并發(fā)場(chǎng)景下的map操作，因此在作數(shù)值累加的時(shí)候自然也要考慮線程安全

當(dāng)然，多線程數(shù)值累加一般是學(xué)習(xí)并發(fā)編程的第一課，本身并非很復(fù)雜，可以采用AtomicInteger或者鎖等等方式來(lái)解決該問(wèn)題

然而如果我們查看該方法，就會(huì)發(fā)現(xiàn)，一個(gè)想來(lái)應(yīng)該比較簡(jiǎn)單的累加方法，其邏輯看上去卻相當(dāng)復(fù)雜

這里我只貼出了累加算法的核心部分

private final void addCount(long x, int check) {
    CounterCell[] as; long b, s;
    if ((as = counterCells) != null ||
            !U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)) {
        CounterCell a; long v; int m;
        boolean uncontended = true;
        if (as == null || (m = as.length - 1) < 0 ||
                (a = as[ThreadLocalRandom.getProbe() & m]) == null ||
                !(uncontended =
                        U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))) {
            fullAddCount(x, uncontended);
            return;
        }
        if (check <= 1)
            return;
        s = sumCount();
    }
    ...
}

我們就來(lái)研究一下該邏輯的實(shí)現(xiàn)思路。而這個(gè)思路其實(shí)是照搬了LongAdder類的邏輯，因此我們直接查看該算法的原始類

二、LongAdder類的使用

我們先看下LongAdder的使用效果

LongAdder adder = new LongAdder();
int num = 0;

@Test
public void test5() throws InterruptedException {
    Thread[] threads = new Thread[10];
    for (int i = 0; i < 10; i++) {
        threads[i] = new Thread(() -> {
            for (int j = 0; j < 10000; j++) {
                adder.add(1);
                num += 1;
            }
        });
        threads[i].start();
    }
    for (int i = 0; i < 10; i++) {
        threads[i].join();
    }
    System.out.println("adder:" + adder);
    System.out.println("num:" + num);
}

輸出結(jié)果

adder:100000

num:40982

可以看到adder在使用效果上是可以保證累加的線程安全的

三、LongAdder原理的直觀理解

為了更好地對(duì)源碼進(jìn)行分析，我們需要先從直覺(jué)上理解它的原理，否則直接看代碼的話會(huì)一臉懵逼

LongAdder的計(jì)數(shù)主要分為2個(gè)對(duì)象

一個(gè)long類型的字段：base

一個(gè)Cell對(duì)象數(shù)組，Cell對(duì)象中就維護(hù)了一個(gè)long類型的字段value，用來(lái)計(jì)數(shù)

/**
 * Table of cells. When non-null, size is a power of 2.
 */
transient volatile Cell[] cells;

/**
 * Base value, used mainly when there is no contention, but also as
 * a fallback during table initialization races. Updated via CAS.
 */
transient volatile long base;

當(dāng)沒(méi)有發(fā)生線程競(jìng)爭(zhēng)的時(shí)候，累加都會(huì)發(fā)生在base字段上，這就相當(dāng)于是一個(gè)單線程累加2次，只不過(guò)base的累加是一個(gè)cas操作

當(dāng)發(fā)生線程競(jìng)爭(zhēng)的時(shí)候，必然有一個(gè)線程對(duì)base的cas累加操作失敗，于是它先去判斷Cell是否已經(jīng)被初始化了，如果沒(méi)有則初始化一個(gè)長(zhǎng)度為2的數(shù)組，并根據(jù)線程的hash值找到對(duì)應(yīng)的數(shù)組索引，并對(duì)該索引的Cell對(duì)象中的value值進(jìn)行累加（這個(gè)累加也是cas的操作）

如果一共有3個(gè)線程發(fā)生了競(jìng)爭(zhēng)，那么其中第一個(gè)線程對(duì)base的cas累加成功，剩下2個(gè)線程都需要去對(duì)Cell數(shù)組中的元素進(jìn)行累加。因?yàn)閷?duì)Cell中value值的累加也是一個(gè)cas操作，如果第二個(gè)線程和第三個(gè)線程的hash值對(duì)應(yīng)的數(shù)組下標(biāo)是同一個(gè)，那么同樣會(huì)發(fā)生競(jìng)爭(zhēng)，如果第二個(gè)線程成功了，第三個(gè)線程就會(huì)去rehash自己的hash值，如果得到的新的hash值對(duì)應(yīng)的是另一個(gè)元素為null的數(shù)組下標(biāo)，那么就new一個(gè)Cell對(duì)象并對(duì)value值進(jìn)行累加

如果此時(shí)有線程4同時(shí)參與競(jìng)爭(zhēng)，那么對(duì)于線程4來(lái)說(shuō)，即使rehash后還是可能在和線程3的競(jìng)爭(zhēng)過(guò)程中cas失敗，此時(shí)如果當(dāng)前數(shù)組的容量小于系統(tǒng)可用的cpu的數(shù)量，那么它就會(huì)對(duì)數(shù)組進(jìn)行擴(kuò)容，之后再次rehash，重復(fù)嘗試對(duì)Cell數(shù)組中某個(gè)下標(biāo)對(duì)象的累加

以上就是整體直覺(jué)上的理解，然而代碼中還有很多細(xì)節(jié)的設(shè)計(jì)非常值得學(xué)習(xí)，所以我們就開(kāi)始進(jìn)入源碼分析的環(huán)節(jié)

四、源碼分析

入口方法是add

public void add(long x) {
    Cell[] as; long b, v; int m; Cell a;
    /**
     * 這里優(yōu)先判斷了cell數(shù)組是否為空，之后才判斷base字段的cas累加
     * 意味著如果線程不發(fā)生競(jìng)爭(zhēng)，cell數(shù)組一直為空，那么所有的累加操作都會(huì)累加到base上
     * 而一旦發(fā)生過(guò)一次競(jìng)爭(zhēng)導(dǎo)致cell數(shù)組不為空，那么所有的累加操作都會(huì)優(yōu)先作用于數(shù)組中的對(duì)象上
     */
    if ((as = cells) != null || !casBase(b = base, b + x)) {
        /**
         * 這個(gè)字段是用來(lái)標(biāo)識(shí)在對(duì)cell數(shù)組中的對(duì)象進(jìn)行累加操作時(shí)是否發(fā)生了競(jìng)爭(zhēng)
         * 如果發(fā)生了競(jìng)爭(zhēng)，那么在longAccumulate方法中會(huì)多進(jìn)行一次rehash的自旋
         * 這個(gè)在后面的方法中詳細(xì)說(shuō)明，這里先有個(gè)印象
         * true表示未發(fā)生競(jìng)爭(zhēng)
         */
        boolean uncontended = true;
        /**
         * 如果cell數(shù)組為空或者長(zhǎng)度為0則直接進(jìn)入主邏輯方法
         */
        if (as == null || (m = as.length - 1) < 0 ||
                /**
                 * 這里的getProbe()方法可以認(rèn)為就是獲取線程的hash值
                 * hash值與(數(shù)組長(zhǎng)度-1)進(jìn)行位與操作后得到對(duì)應(yīng)的數(shù)組下標(biāo)
                 * 判斷該元素是否為空，如果不為空那么就會(huì)嘗試?yán)奂?
                 * 否則進(jìn)入主邏輯方法
                 */
                (a = as[getProbe() & m]) == null ||
                /**
                 * 對(duì)數(shù)組下標(biāo)的元素進(jìn)行cas累加，如果成功了，那么就可以直接返回
                 * 否則進(jìn)入主邏輯方法
                 */
                !(uncontended = a.cas(v = a.value, v + x)))
            longAccumulate(x, null, uncontended);
    }
}

當(dāng)不發(fā)生線程競(jìng)爭(zhēng)的時(shí)候，那累加操作就會(huì)由第一個(gè)if中的casBase負(fù)責(zé)，對(duì)應(yīng)之前圖解的情況一

當(dāng)發(fā)生線程競(jìng)爭(zhēng)之后，累加操作就會(huì)由cell數(shù)組負(fù)責(zé)，對(duì)應(yīng)之前圖解的情況二（數(shù)組的初始化在longAccumulate方法中）

接著我們查看主邏輯方法，因?yàn)榉椒ū容^長(zhǎng)，所以我會(huì)一段一段拿出來(lái)解析

longAccumulate方法

簽名中的參數(shù)

x表示需要累加的值

fn表示需要如何累加，一般傳null就行，不重要

wasUncontended表示是否在外層方法遇到了競(jìng)爭(zhēng)失敗的情況，因?yàn)橥鈱拥呐袛噙壿嬍嵌鄠€(gè)“或”(as == null || (m = as.length - 1) < 0 || (a = as[getProbe() & m]) == null)，所以如果數(shù)組為空或者相應(yīng)的下標(biāo)元素還未初始化，這個(gè)字段就會(huì)保持false

final void longAccumulate(long x, LongBinaryOperator fn,
                          boolean wasUncontended) {
  ...
}

首先判斷線程的hash值是否為0，如果為0則需要做一個(gè)初始化，即rehash

之后會(huì)將wasUncontended置為true，因?yàn)榧词怪笆菦_突過(guò)的，經(jīng)過(guò)rehash后就會(huì)先假設(shè)它能找到一個(gè)元素不沖突的數(shù)組下標(biāo)

int h;//線程的hash值，在后面的邏輯中會(huì)用到
if ((h = getProbe()) == 0) {
    ThreadLocalRandom.current(); // force initialization
    h = getProbe();
    wasUncontended = true;
}

之后是一個(gè)死循環(huán)，死循環(huán)中有3個(gè)大的if分支，這3個(gè)分支的邏輯作用于數(shù)組未初始化的時(shí)候，一旦數(shù)組初始化完成，那么就都會(huì)進(jìn)入主邏輯了，因此我這里把主邏輯抽取出來(lái)放到后面單獨(dú)說(shuō)，也可以避免外層分支對(duì)思路的影響

/**
 * 用來(lái)標(biāo)記某個(gè)線程在上一次循環(huán)中找到的數(shù)組下標(biāo)是否已經(jīng)有Cell對(duì)象了
 * 如果為true，則表示數(shù)組下標(biāo)為空
 * 在主邏輯的循環(huán)中會(huì)用到
 */
boolean collide = false;
/**
 * 死循環(huán)，提供自旋操作
 */
for (; ; ) {
    Cell[] as;
    Cell a;
    int n;//cell數(shù)組長(zhǎng)度
    long v;//需要被累積的值
    /**
     * 如果cells數(shù)組不為空，且已經(jīng)被某個(gè)線程初始化成功，那么就會(huì)進(jìn)入主邏輯，這個(gè)后面詳細(xì)解釋
     */
    if ((as = cells) != null && (n = as.length) > 0) {
        ...
        /**
         * 如果數(shù)組為空，那么就需要初始化一個(gè)Cell數(shù)組
         * cellsBusy用來(lái)標(biāo)記cells數(shù)組是否能被操作，作用相當(dāng)于一個(gè)鎖
         * cells == as 判斷是否有其他線程在當(dāng)前線程進(jìn)入這個(gè)判斷之前已經(jīng)初始化了一個(gè)數(shù)組
         * casCellsBusy 用一個(gè)cas操作給cellsBusy字段賦值為1，如果成功可以認(rèn)為拿到了操作cells數(shù)組的鎖
         */
    } else if (cellsBusy == 0 && cells == as && casCellsBusy()) {
        /**
         * 這里就是初始化一個(gè)數(shù)組，不解釋了
         */
        boolean init = false;
        try {                           
            if (cells == as) {
                Cell[] rs = new Cell[2];
                rs[h & 1] = new Cell(x);
                cells = rs;
                init = true;
            }
        } finally {
            cellsBusy = 0;
        }
        if (init)
            break;
        /**
         * 如果當(dāng)前數(shù)組是空的，又沒(méi)有競(jìng)爭(zhēng)過(guò)其他線程
         * 那么就再次嘗試去給base賦值
         * 如果又沒(méi)競(jìng)爭(zhēng)過(guò)（感覺(jué)有點(diǎn)可憐），那么就自旋
         * 另外提一下方法簽名中的LongBinaryOperator對(duì)象就是用在這里的，不影響邏輯
         */
    } else if (casBase(v = base, ((fn == null) ? v + x :
            fn.applyAsLong(v, x))))
        break;                          // Fall back on using base
}

接著就看對(duì)cell數(shù)組元素進(jìn)行累加的主邏輯

/**
 * 如果cells數(shù)組不為空，且已經(jīng)被某個(gè)線程初始化成功，進(jìn)入主邏輯
 */
if ((as = cells) != null && (n = as.length) > 0) {
    /**
     * 如果當(dāng)前線程的hash值對(duì)應(yīng)的數(shù)組元素為空
     */
    if ((a = as[(n - 1) & h]) == null) {
        /**
         * Cell數(shù)組并未被其他線程操作
         */
        if (cellsBusy == 0) {
            /**
             * 這里沒(méi)有理解作者為什么會(huì)在這里初始化單個(gè)Cell
             * 作者這里的注釋是Optimistically create，如果有理解的同學(xué)可以說(shuō)一下
             */
            Cell r = new Cell(x);
            /**
             * 在此判斷cell鎖的狀態(tài)，并嘗試加鎖
             */
            if (cellsBusy == 0 && casCellsBusy()) {
                boolean created = false;
                try {
                    /**
                     * 這里對(duì)數(shù)組是否為空等狀態(tài)再次進(jìn)行校驗(yàn)
                     * 如果校驗(yàn)通過(guò)，那么就將之前new的Cell對(duì)象放到Cell數(shù)組的該下標(biāo)處
                     */
                    Cell[] rs;
                    int m, j;
                    if ((rs = cells) != null &&
                            (m = rs.length) > 0 &&
                            rs[j = (m - 1) & h] == null) {
                        rs[j] = r;
                        created = true;
                    }
                } finally {
                    cellsBusy = 0;
                }
                /**
                 * 如果創(chuàng)建成功，就說(shuō)明累加成功，直接退出循環(huán)
                 */
                if (created)
                    break;
                /**
                 * 走到這里說(shuō)明在判空和拿到鎖之間正好有其他線程在該下標(biāo)處創(chuàng)建了一個(gè)Cell
                 * 因此直接continue，不rehash，下次就不會(huì)進(jìn)入到該分支了
                 */
                continue;
            }
        }
        /**
         * 當(dāng)執(zhí)行到這里的時(shí)候，因?yàn)槭窃?nbsp;if ((a = as[(n - 1) & h]) == null) 這個(gè)判斷邏輯中
         * 就說(shuō)明在第一個(gè)if判斷的時(shí)候該下標(biāo)處沒(méi)有元素，所以賦值為false
         * collide的意義是：上一次循環(huán)中找到的數(shù)組下標(biāo)是否已經(jīng)有Cell對(duì)象了
         * True if last slot nonempty
         */
        collide = false;
    /**
     * 這個(gè)字段如果為false，說(shuō)明之前已經(jīng)和其他線程發(fā)過(guò)了競(jìng)爭(zhēng)
     * 即使此時(shí)可以直接取嘗試cas操作，但是在高并發(fā)場(chǎng)景下
     * 這2個(gè)線程之后依然可能發(fā)生競(jìng)爭(zhēng)，而每次競(jìng)爭(zhēng)都需要自旋的話會(huì)很浪費(fèi)cpu資源
     * 因此在這里先直接增加自旋一次，在for的最后會(huì)做一次rehash
     * 使得線程盡快地找到自己獨(dú)占的數(shù)組下標(biāo)
     */
    } else if (!wasUncontended) 
        wasUncontended = true;
    /**
     * 嘗試給hash對(duì)應(yīng)的Cell累加，如果這一步成功了，那么就返回
     * 如果這一步依然失敗了，說(shuō)明此時(shí)整體的并發(fā)競(jìng)爭(zhēng)非常激烈
     * 那就可能需要考慮擴(kuò)容數(shù)組了
     * （因?yàn)閿?shù)組初始化容量為2，如果此時(shí)有10個(gè)線程在并發(fā)運(yùn)行，那就很難避免競(jìng)爭(zhēng)的發(fā)生了）
     */
    else if (a.cas(v = a.value, ((fn == null) ? v + x :
            fn.applyAsLong(v, x))))
        break;
    /**
     * 這里判斷下cpu的核數(shù)，因?yàn)榧词褂?00個(gè)線程
     * 能同時(shí)并行運(yùn)行的線程數(shù)等于cpu數(shù)
     * 因此如果數(shù)組的長(zhǎng)度已經(jīng)大于cpu數(shù)目了，那就不應(yīng)當(dāng)再擴(kuò)容了
     */
    else if (n >= NCPU || cells != as)
        collide = false;
    /**
     * 走到這里，說(shuō)明當(dāng)前循環(huán)中根據(jù)線程hash值找到的數(shù)組下標(biāo)已經(jīng)有元素了
     * 如果此時(shí)collide為false，說(shuō)明上一次循環(huán)中找到的下邊是沒(méi)有元素的
     * 那么就自旋一次并rehash
     * 如果再次運(yùn)行到這里，并且collide為true，就說(shuō)明明競(jìng)爭(zhēng)非常激烈，應(yīng)當(dāng)擴(kuò)容了
     */
    else if (!collide)
        collide = true;
    /**
     * 能運(yùn)行到這里，說(shuō)明需要擴(kuò)容數(shù)組了
     * 判斷鎖狀態(tài)并嘗試獲取鎖
     */
    else if (cellsBusy == 0 && casCellsBusy()) {
        /**
         * 擴(kuò)容數(shù)組的邏輯，這個(gè)擴(kuò)容比較簡(jiǎn)單，就不解釋了
         * 擴(kuò)容大小為2倍
         */
        try {
            if (cells == as) { 
                Cell[] rs = new Cell[n << 1];
                for (int i = 0; i < n; ++i)
                    rs[i] = as[i];
                cells = rs;
            }
        } finally {
            cellsBusy = 0;
        }
        collide = false;
        /**
        * 這里直接continue，因?yàn)閿U(kuò)容過(guò)了，就先不rehash了
        */
        continue;               
    }
    /**
     * 做一個(gè)rehash，使得線程在下一個(gè)循環(huán)中可能找到獨(dú)占的數(shù)組下標(biāo)
     */
    h = advanceProbe(h);
}

到這里L(fēng)ongAdder的源碼其實(shí)就分析結(jié)束了，其實(shí)代碼并不多，但是他的思想非常值得我們?nèi)W(xué)習(xí)。

五、與AtomicInteger的比較

光分析源碼其實(shí)還差一些感覺(jué)，我們還沒(méi)有搞懂為何作者要在已經(jīng)有AtomicInteger的情況下，再設(shè)計(jì)這么一個(gè)看上去非常復(fù)雜的類。

那么首先我們先分析下AtomicInteger保證線程安全的原理

查看最基本的getAndIncrement方法

public final int getAndIncrement() {
    return unsafe.getAndAddInt(this, valueOffset, 1);
}

調(diào)用了Unsafe類的getAndAddInt方法，繼續(xù)往下看

public final int getAndAddInt(Object var1, long var2, int var4) {
    int var5;
    do {
        var5 = this.getIntVolatile(var1, var2);
    } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));

    return var5;
}

這里我們不再深究getIntVolatile和compareAndSwapInt方法具體實(shí)現(xiàn)，因?yàn)槠湟呀?jīng)是native的方法了

可以看到，AtomicInteger底層是使用了cas+自旋的方式解決原子性問(wèn)題的，即如果一次賦值不成功，那么就自旋，直到賦值成功為止

那么由此可以推斷，當(dāng)出現(xiàn)大量線程并發(fā)，競(jìng)爭(zhēng)非常激烈的時(shí)候，AtomicInteger就有可能導(dǎo)致有些線程不斷地競(jìng)爭(zhēng)失敗，不斷自旋從而影響任務(wù)的吞吐量

為了解決高并發(fā)下的自旋問(wèn)題，LongAdder的作者在設(shè)計(jì)的時(shí)候就通過(guò)增加一個(gè)數(shù)組的方式，使得競(jìng)爭(zhēng)的對(duì)象從一個(gè)值變成多個(gè)值，從而使得發(fā)生競(jìng)爭(zhēng)的頻率降低，從而緩解了自旋的問(wèn)題，當(dāng)然付出的代價(jià)就是額外的存儲(chǔ)空間。

最后我簡(jiǎn)單做了個(gè)測(cè)試，比較2種計(jì)數(shù)方法的耗時(shí)

通過(guò)原理可知，只有當(dāng)線程競(jìng)爭(zhēng)非常激烈的時(shí)候，LongAdder的優(yōu)勢(shì)才會(huì)比較明顯，因此這里我用了100個(gè)線程，每一個(gè)線程對(duì)同一個(gè)數(shù)累加1000000次，得到結(jié)果如下，差距非常巨大，達(dá)到15倍！

LongAdder耗時(shí)：104292242nanos

AtomicInteger耗時(shí)：1583294474nanos

當(dāng)然這只是一個(gè)簡(jiǎn)單測(cè)試，包含了很多隨機(jī)性，有興趣的同學(xué)可以嘗試不同的競(jìng)爭(zhēng)程度多次測(cè)試

六、思想的抽象

最后我們需要將作者的具體代碼和實(shí)現(xiàn)邏輯抽象一下，理清思考的過(guò)程

1）AtomicInteger遇到的問(wèn)題：?jiǎn)蝹€(gè)資源的競(jìng)爭(zhēng)導(dǎo)致自旋的發(fā)生

2）解決的思路：將單個(gè)對(duì)象的競(jìng)爭(zhēng)擴(kuò)展為多個(gè)對(duì)象的競(jìng)爭(zhēng)（有那么一些分治的思想）

3）擴(kuò)展的可控性：多個(gè)競(jìng)爭(zhēng)對(duì)象需要付出額外的存儲(chǔ)空間，因此不能無(wú)腦地?cái)U(kuò)展（極端情況是一個(gè)線程一個(gè)計(jì)數(shù)的對(duì)象，這明顯不合理）

4）問(wèn)題的分層：因?yàn)槭褂妙惖臅r(shí)候的場(chǎng)景是不可控的，因此需要根據(jù)并發(fā)的激烈程度動(dòng)態(tài)地?cái)U(kuò)展額外的存儲(chǔ)空間（類似于synchronized的膨脹）

5）3個(gè)分層策略：當(dāng)不發(fā)生競(jìng)爭(zhēng)時(shí)，那么用一個(gè)值累加即可；當(dāng)發(fā)生一定程度的競(jìng)爭(zhēng)時(shí)，創(chuàng)建一個(gè)容量為2的數(shù)組，使得競(jìng)爭(zhēng)的資源擴(kuò)展為3個(gè)；當(dāng)競(jìng)爭(zhēng)更加激烈時(shí)，則繼續(xù)擴(kuò)展數(shù)組（對(duì)應(yīng)圖解中的1個(gè)線程到4個(gè)線程的過(guò)程）

6）策略細(xì)節(jié)：在自旋的時(shí)候增加rehash，此時(shí)雖然付出了一定的運(yùn)算時(shí)間計(jì)算hash、比較數(shù)組對(duì)象等，但是這會(huì)使得并發(fā)的線程盡快地找到專屬于自己的對(duì)象，在之后就不會(huì)再發(fā)生任何競(jìng)爭(zhēng)（磨刀不誤砍柴工，特別注意wasUncontended字段的相關(guān)注解）

“并發(fā)編程LongAdder的原理是什么”的內(nèi)容就介紹到這里了，感謝大家的閱讀。如果想了解更多行業(yè)相關(guān)的知識(shí)可以關(guān)注億速云網(wǎng)站，小編將為大家輸出更多高質(zhì)量的實(shí)用文章！