LongAdder与AtomicLong的区别

AutomaticLong的底层是通过CAS(compareAndSwap)来实现线程的同步，是在一个死循环内不断的尝试修改目标的值，直到修改成功。如果在竞争不激烈的情况下，它修改成功的概率很高，否则的话修改失败的概率就会很高，在大量修改失败的时候这些原子操作就会多次循环尝试，因此性能就会受到影响。对于普通类型的long和dubble变量JVM允许将64位的读或者写操作拆分成2个32位的读或者写操作，
LongAdder的内部实现思想是： 将热点数据分离，将AutomaticLong的内部核心数据value分割成一个数组，每个线程访问时，通过Hash等算法映射到其中一个数字进行计数，最终的计数结果为这个数组的求和累加，其中热点数据value他会被分割成多个单元的cell，每个cell独立维护内部的值，当前对象的实际值由所有的cell累计合成，这样热点就进行了有效的分离，提高了并行度。即LongAdder是在AtomicLong的基础上将单点的更新压力分散到各个节点上。在地并发的时候通过对base的值直接更新，可以很好地保证和AutomaticLong性能基本一致，而在高并发的时候则通过分散提高了性能。
LongAdder缺点：在统计的时候如果有并发更新，可能会导致统计的数据有些误差。在实际处理高并发中，我们根据实际业务场景优先考虑使用LongAdder而不是继续使用AtomicLong，当然在线程竞争很低的情况下AutomaticLong才是最佳选择(序列号生成等要求准确且全局唯一)。

总结:

AtomicLong的原理是依靠底层的cas来保障原子性的更新数据，在要添加或者减少的时候，会使用死循环不断地cas到特定的值，从而达到更新数据的目的。
LongAdder在AtomicLong的基础上将单点的更新压力分散到各个节点，在低并发的时候通过对base的直接更新可以很好的保障和AtomicLong的性能基本保持一致，而在高并发的时候通过分散提高了性能。
缺点是LongAdder在统计的时候如果有并发更新，可能导致统计的数据有误差。

示例:

AutomaticLong示例代码

package com.mall.concurrcy.autoincrease;
import com.mall.concurrcy.annotations.ThreadSafe;
import lombok.extern.slf4j.Slf4j;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
import java.util.concurrent.atomic.AtomicLong;
 
@Slf4j
@ThreadSafe
public class AtomicLongTest {
    private static final Logger log = LoggerFactory.getLogger(AtomicLongTest.class);
 
    private static int clientTotal=5000;
 
    private static int threadTotal=200;
 
    public static AtomicLong count=new AtomicLong(0);
 
    public static void main(String[] args) throws InterruptedException {
        ExecutorService executorService = Executors.newCachedThreadPool();
        final Semaphore semaphore = new Semaphore(threadTotal);
        final CountDownLatch countDownLatch = new CountDownLatch(clientTotal);
        for(int i=0;i<clientTotal;i++){
            executorService.execute(()->{
                try {
                    semaphore.acquire();
                    add();
                    semaphore.release();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    log.error("InterruptedException",e);
                }
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        log.info("count:{}",count);
        executorService.shutdown();
    }
 
    private static void add(){
        count.getAndIncrement();
    }
}

LongAdder示例代码

package com.mall.concurrcy.autoincrease;
 
import com.mall.concurrcy.annotations.ThreadSafe;
import lombok.extern.slf4j.Slf4j;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
 
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
import java.util.concurrent.atomic.LongAdder;
 
@Slf4j
@ThreadSafe
public class LongAdderTest {
    private static final Logger log = LoggerFactory.getLogger(LongAdderTest.class);
 
    private static int clientTotal=5000;
 
    private static int threadTotal=200;
 
    public static LongAdder count=new LongAdder();
 
    public static void main(String[] args) throws InterruptedException {
        ExecutorService executorService = Executors.newCachedThreadPool();
        final Semaphore semaphore = new Semaphore(threadTotal);
        final CountDownLatch countDownLatch = new CountDownLatch(clientTotal);
        for(int i=0;i<clientTotal;i++){
            executorService.execute(()->{
                try {
                    semaphore.acquire();
                    add();
                    semaphore.release();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    log.error("InterruptedException",e);
                }
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        log.info("count:{}",count);
        executorService.shutdown();
    }
 
    private static void add(){
        count.increment();
    }
}