AtomicLong和LongAdder的区别

本文探讨了AtomicLong和LongAdder的工作原理,并详细分析了LongAdder如何通过分散更新压力来提升高并发场景下的性能。

AtomicLong和LongAdder的区别

前言

最近在看到不少框架里面使用到了LongAdder这个类,而并非AtomicLong,很是困惑,于是专门看了LongAdder的源码,总结一下这两个的区别。

AtomicLong原理

就像我们所知道的那样,AtomicLong的原理是依靠底层的cas来保障原子性的更新数据,在要添加或者减少的时候,会使用死循环不断地cas到特定的值,从而达到更新数据的目的。那么LongAdder又是使用到了什么原理?难道有比cas更加快速的方式?

LongAdder原理

首先我们来看一下LongAdder有哪些方法?

img_5e8906c37bc3693e1dad9c31ddd272f7.png

可以看到和AtomicLong基本类似,同样有增加、减少等操作,那么如何实现原子的增加呢?


img_296b8976422d81d0f19f2c51073310cc.png
这里写图片描述

我们可以看到一个Cell的类,那这个类是用来干什么的呢?

img_6f5bd155a3dbfebb23925494f5c626e9.png

我们可以看到Cell类的内部是一个volatile的变量,然后更改这个变量唯一的方式通过cas。我们可以猜测到LongAdder的高明之处可能在于将之前单个节点的并发分散到各个节点的,这样从而提高在高并发时候的效率。

下面我们来验证我们的观点,我们接着看上图的add方法,如果cell数组不为空,那么就尝试更新base元素,如果更新成功,那么就直接返回。base元素在这里起到了一个什么作用呢?可以保障的是在低并发的时候和AtomicLong一样的直接对基础元素进行更新。
  而如果cell为空或者更新base失败,我们看接下来的那个if判断,即如果as不为空并且成功更新对应节点的数据,则返回,否则就会进入longAccumulate()方法。
  图有点大,无法截图,直接贴源码

        for (;;) {
            Cell[] as; Cell a; int n; long v;
            if ((as = cells) != null && (n = as.length) > 0) {
                if ((a = as[(n - 1) & h]) == null) { //如果对应位置没有数据,那么直接插入元素
                    if (cellsBusy == 0) {       // Try to attach new Cell
                        Cell r = new Cell(x);   // Optimistically create
                        if (cellsBusy == 0 && casCellsBusy()) {
                            boolean created = false;
                            try {               // Recheck under lock
                                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;
                            }
                            if (created)
                                break;
                            continue;           // Slot is now non-empty
                        }
                    }
                    collide = false;
                }
                else if (!wasUncontended)     //标示冲突标志位 ,进行重试 CAS already known to fail
                    wasUncontended = true;      // Continue after rehash
                else if (a.cas(v = a.value, ((fn == null) ? v + x :
                                             fn.applyAsLong(v, x))))
                    break;
                else if (n >= NCPU || cells != as)
                    collide = false;            // At max size or stale,如果已经cell数组的大小已经超过了CPU核数,那么再扩容没意义了,直接重试,或者有别的线程扩容导致变更了数组,设置标示位,进行重试,,避免一失败就扩容
                else if (!collide)
                    collide = true;
                else if (cellsBusy == 0 && casCellsBusy()) {//开始扩容
                    try {
                        if (cells == as) {      // Expand table unless stale
                            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;                   // Retry with expanded table
                }
                h = advanceProbe(h); //扩容完成以后,重新初始化要更新的索引值,尽量保障可以更新成功
            }
            else if (cellsBusy == 0 && cells == as && //初始化casCellsBusy()) {
                boolean init = false;
                try {                           // Initialize table
                    if (cells == as) {
                        Cell[] rs = new Cell[2];
                        rs[h & 1] = new Cell(x);
                        cells = rs;
                        init = true;
                    }
                } finally {
                    cellsBusy = 0;
                }
                if (init)
                    break;
            }
            else if (casBase(v = base, ((fn == null) ? v + x :
                                        fn.applyAsLong(v, x))))
                break;                          // Fall back on using base
        }

上面的代码主要有三个分支:
    1. 如果数组不为空
    2. 数据为空,则初始化
    3. 前面都更新失败了,尝试更新base数据
   cellBusy是一个标示元素,只有当修改cell数组大小或者插入元素的时候才会修改。分支二、分支三都很简单,我们来重点分析一下分支一。
   当要更新的位置没有元素的时候,首先cas标志位,防止扩容以及插入元素,然后插入数据。如果成功直接返回,否则标示发生了冲突,然后重试。如果对应的位置有元素则更新,如果更新失败,进行判断是否数组的大小已经超过了cpu的核数,如果大于的话,则意味着扩容没有意义。直接重试。否则进行扩容,扩容完成后,重新设置要更新的位置,尽可能保证下一次更新成功。
  我们来看一下如何统计计数。


img_7bf79e9ae1182adbf28598831d592fba.png

当计数的时候,将base和各个cell元素里面的值进行叠加,从而得到计算总数的目的。这里的问题是在计数的同时如果修改cell元素,有可能导致计数的结果不准确。

总结:

LongAdder在AtomicLong的基础上将单点的更新压力分散到各个节点,在低并发的时候通过对base的直接更新可以很好的保障和AtomicLong的性能基本保持一致,而在高并发的时候通过分散提高了性能。
缺点是LongAdder在统计的时候如果有并发更新,可能导致统计的数据有误差。

### LongAdder 的用法与实现细节 `LongAdder` 是 Java 并发包 `java.util.concurrent.atomic` 中的一个类,旨在解决高并发场景下频繁更新共享变量时的竞争问题。它通过减少竞争来提高性能,特别适用于计数器场景。 #### 高效的设计理念 `LongAdder` 使用了一种称为 **分条累加(Striped Accumulation)** 的技术[^1]。其核心思想是将多个线程的增量操作分布到不同的内部单元上执行,从而降低锁争用的可能性。最终的结果可以通过汇总这些单元的值获得。 #### 主要方法概述 以下是 `LongAdder` 提供的一些常用方法及其功能: - **`increment()`**: 将当前值增加 1。 - **`decrement()`**: 将当前值减去 1。 - **`add(long x)`**: 增加指定数值。 - **`sum()` 或者 `longValue()`**: 返回累积计算后的总。 需要注意的是,在多线程环境中调用 `sum()` 方法会触发一次同步的操作以确保数据一致性[^2]。 #### 实现机制剖析 为了提升效率并减少冲突,`LongAdder` 维护了一个数组结构用于存储各个独立的部分求结果。每当某个线程尝试修改该对象时,如果发现对应槽位未被占用,则直接写入;否则采用 CAS(Compare And Swap)算法寻找新的位置记录变化量。这种策略有效缓解了传统原子类型如 AtomicLong 所面临的瓶颈问题——即当大量线程同时访问同一内存地址时产生的激烈争夺现象[^3]。 下面展示如何创建以及使用一个简单的例子: ```java import java.util.concurrent.atomic.LongAdder; public class Main { public static void main(String[] args) throws InterruptedException { final int THREAD_COUNT = 10; Thread[] threads = new Thread[THREAD_COUNT]; LongAdder counter = new LongAdder(); for(int i=0;i<THREAD_COUNT;i++) { threads[i]=new Thread(()->{ for(int j=0;j<1000;j++) { counter.increment(); } }); threads[i].start(); } for(Thread t : threads){ t.join(); // wait until all thread finish their job. } System.out.println("Total count:"+counter.sum()); } } ``` 上述程序展示了利用 `LongAdder` 来统计来自不同线程贡献次数的方式,并验证最后得到总数是否正确无误。 #### 性能对比分析 相较于传统的 `AtomicLong`, 在极高频率读写的条件下,由于引入了额外的空间开销换取时间上的优化,因此可以观察到显著优于前者的表现特性。然而对于低负载或者单一线程应用场合来说,可能并不会体现出明显优势甚至稍逊一筹因为存在初始化成本等因素影响。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值