LongAdder详解以及底层原理分析

关注

原创最新推荐文章于 2026-08-11 21:06:02 发布 1k 阅读 AI 写同款· GEO 优化 ›

ConcurrentHashMap源码篇：LongAdder原理分析前言最近在学习ConcurrentHashMap的源码，发现它采用了一种比较独特的方式对map中的元素数量进行统计，自然是要好好研究一下其原理思想，同时也能更好地理解ConcurrentHashMap本身。本文主要思路分为以下4个部分 1.计数的使用效果 2.原理的直观图解 3.源码的细节分析 4.与AtomicInteger的比较 5.思想的抽象学习的入口自然是map的put方法 public V put(K key, V value) { return putVal(k 阅读详情

一、原子累加器

我们都知道，原子整型可以在线程安全的前提下做到累加功能，而今天介绍的LongAdder具有更好的性能

我们先来看原子累加器和原子整型做累加的对比使用：

    private static <T> void demo(Supplier<T> supplier, Consumer<T> action){
        T adder = supplier.get();
        long start = System.nanoTime();
        List<Thread> ts = new ArrayList<>();
        for (int i = 0;i<40;i++){
            ts.add(new Thread(()->{
                for (int j = 0;j<500000;j++){
                    action.accept(adder);
                }
            }));
        }
        ts.forEach(t->t.start());
        ts.forEach(t->{
            try {
                t.join();
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        });
    }

    public static void main(String[] args) {
        for (int i = 0;i<5;i++){
            demo(()->new LongAdder(),longAdder -> longAdder.increment());
        }
        for (int i = 0;i<5;i++){
            demo(()->new AtomicLong(),atomicLong -> atomicLong.getAndIncrement());
        }
    }

通过上面的代码运行我们可以清晰地看到，两种方式都有效的产完成了累加的效果，但是明显使用累加器的效率要更好，甚至要高出原子类型累加好几倍。

现在，我们可以简单地理解为，原子累加器就是JAVA在并发编程下提供的有保障的累加手段。

二、LongAdder执行原理

LongAdder之所以性能提升这么多，就是在有竞争时，设置多个累加单元，不同线程累加不同的累加单元，最后在将其汇总，减少了cas重试失败，从而提高了性能。

简单来说，累加器就是将需要做累加的共享变量，分成许多部分，时多个线程只累加自己的部分（这样做既可以减少使用普通整型容易出现的线程不安全错误，也可以提高原子类型在累加时效率底下的问题），足以后再将结果汇总，得到累加结果。

就比如银行要清点大量钞票，一个人来清点效率低下，所以需要多个人来（多个线程），将大量钞票分给多个员工（分配累加单元），每个员工仅仅需要对自己的那部分钞票清点（每个线程累加自己的累加单元），最后将结果汇总起来，就是所有钞票的总数。

LongAdder中有几个关键域：

transient volatile Cell[] cells;//累加单元数组，懒惰初始化
transient volatile long base;//基础值，如果是单线程没有竞争，则用cas累加这个域
transient volatile int cellsBusy;//zaicell创建或扩容时，置位1，表示加锁

其中cells就是累加单元，用来给各个线程分配累加任务。

base用来做单线程的累加，同时还有汇总的作用，也是就是说base=cells[0]+cells[1]……+base

cellbase则用来表示加锁置位，0表示无锁，1表示加锁。

注意：

此处cellsbusy所说的锁并不是真正的对象锁，而是底层用cas来模拟加锁。

cas模拟加锁：

当占用某资源需要模拟加锁时，cas会将某处标志位的初始态变为加锁态（如将0改为1）。此时当出现竞争时，其他线程同样会尝试cas操作，但均以失败告终，所以会不停尝试cas，起到了加锁的功效。

Cell

@sun.misc.Contended static final class Cell {
        volatile long value;
        Cell(long x) { value = x; }
        final boolean cas(long cmp, long val) {
            return UNSAFE.compareAndSwapLong(this, valueOffset, cmp, val);
        }

        // Unsafe mechanics
        private static final sun.misc.Unsafe UNSAFE;
        private static final long valueOffset;
        static {
            try {
                UNSAFE = sun.misc.Unsafe.getUnsafe();
                Class<?> ak = Cell.class;
                valueOffset = UNSAFE.objectFieldOffset
                    (ak.getDeclaredField("value"));
            } catch (Exception e) {
                throw new Error(e);
            }
        }
    }

在Cell类源码中我们能看出，cell底层也是采用cas来做累加计数。