我們知道AtomicLong、AtomicInteger是基於硬體級別cas實現的保證執行緒安全的自增類，能保證原子化的自增操作。在多執行緒下，效能遠好於加鎖synchronized。

AtomicLong的實現是當多執行緒併發自增、自減時，通過cas指令從機器指令級別操作保證併發的原子性。制約效能的是高併發時cas失敗機率會變高。失敗後會重試，越多執行緒失敗、越多次重試，失敗機率就會更高，效能就會下降。

Java8誕生了一個新類——LongAdder，從名字就能看到是Long的Add。AtomicLong是因為硬體對一個value進行加鎖，由於value只有一個，必然在多執行緒中有訪問衝突。

而LongAdder是將value拆分成多個cell，最終的value值就是這多個cell相加的和。所以對LongAdder進行加減操作時，只需要對不同的cell來操作，不同的執行緒對不同的cell進行cas操作，這樣成功率就會大大提高。

在併發數不高的情況，拆分成若干的cell，然後去維護cell求和，效能是不如AtomicLong的。所以LongAdder用了巧妙的方法來解決。初始情況下，LongAdder與AtomicLong是相同的，只有在cas失敗時，才會將value拆分成cell，每失敗一次，都會增加cel的數量。這樣就能兼顧低併發和高併發都能高效。

通過程式碼測試也能證明：

public class TestAtomicLong {
    private static AtomicLong ai = new AtomicLong(0);

    public static void main(String[] args) throws InterruptedException {
        MyThread mt = new MyThread();

        Long time = System.currentTimeMillis();
        System.out.println("當前時間：" + time);
        for (int i = 0; i < 4; i++) {
            Thread t = new Thread(mt);
            t.start();
        }

        Thread.sleep(5000);
    }

    static class MyThread implements Runnable {

        @Override
        public void run() {
            while (true) {
                if (ai.get() >= 100000000L) {
                    System.out.println("已達到1億");
                    System.out.println(System.currentTimeMillis());
                    return;
                }
                ai.getAndIncrement();
            }
        }
    }

}
 

public class TestLongAdder {
    private static LongAdder ai = new LongAdder();

    public static void main(String[] args) throws InterruptedException {
        MyThread mt = new MyThread();

        Long time = System.currentTimeMillis();
        System.out.println("當前時間：" + time);
        for (int i = 0; i < 4; i++) {
            Thread t = new Thread(mt);
            t.start();
        }

        Thread.sleep(5000);
    }

    static class MyThread implements Runnable {

        @Override
        public void run() {
            while (true) {
                if (ai.longValue() >= 100000000L) {
                    System.out.println("已達到1億");
                    System.out.println(System.currentTimeMillis());
                    return;
                }
                ai.increment();
            }
        }
    }

}
 

這是隻有4個執行緒的情況下，多個執行緒對一個變數加到1億時，看看時間。

AtomicLong用了2.1秒，LongAdder用了2.2秒，效能還差於AtomicLong。

但是修改執行緒為50時，AtomicLong用了3秒，LongAdder用了2.3秒。

說明在多執行緒下，LongAdder優於AtomicLong。