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

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

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();
    }
    ...
}

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);
}

/**
 * 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;

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

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

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

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

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

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

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;
}