【小家java】AtomicLong可以抛弃了,请使用LongAdder代替(或使用LongAccumulator)

相关阅读

【小家java】java5新特性(简述十大新特性) 重要一跃
【小家java】java6新特性(简述十大新特性) 鸡肋升级
【小家java】java7新特性(简述八大新特性) 不温不火
【小家java】java8新特性(简述十大新特性) 饱受赞誉
【小家java】java9新特性(简述十大新特性) 褒贬不一
【小家java】java10新特性(简述十大新特性) 小步迭代
【小家java】java11新特性(简述八大新特性) 首个重磅LTS版本


每篇一句

传播正能量——做一个快乐的程序员

前言

如题,如果你对AtomicLong的使用、运行机制还不了解的话,请移步我上一篇博文:【小家java】原子操作你还在用Synchronized?Atomic、LongAdder你真有必要了解一下了

如果你现在是用的JDK还是停留在JDK7及以下,对JDK8没有太多的了解,那么本文的讲述获取能让你又多一个赶紧升级的理由。

LongAdder这个类也许很多人闻所未闻,虽然已经使用JDK8很久了。那本文就是要扫盲啦

LongAdder

DoubleAccumulator、LongAccumulator、DoubleAdder、LongAdder是JDK1.8新增的部分,是对AtomicLong等类的改进。

LongAccumulator与LongAdder在高并发环境下比AtomicLong更高效。

看看LongAdder类的java doc怎么说?

 * <p>This class is usually preferable to {@link AtomicLong} when
 * multiple threads update a common sum that is used for purposes such
 * as collecting statistics, not for fine-grained synchronization
 * control.  Under low update contention, the two classes have similar
 * characteristics. But under high contention, expected throughput of
 * this class is significantly higher, at the expense of higher space
 * consumption.
 *
 * <p>LongAdders can be used with a {@link
 * java.util.concurrent.ConcurrentHashMap} to maintain a scalable
 * frequency map (a form of histogram or multiset). For example, to
 * add a count to a {@code ConcurrentHashMap<String,LongAdder> freqs},
 * initializing if not already present, you can use {@code
 * freqs.computeIfAbsent(k -> new LongAdder()).increment();}

大概我们能抽取一些关键信息总结如下:

LongAdder中会维护一组(一个或多个)变量,这些变量加起来就是要以原子方式更新的long型变量。当更新方法add(long)在线程间竞争时,该组变量可以动态增长减缓竞争。方法sum()返回当前在维持总和的变量上的总和。 (这种机制特别像分段锁机制)

与AtomicLong相比,LongAdder更多地用于收集统计数据,而不是细粒度的同步控制。在低并发环境下,两者性能很相似。但在高并发环境下,LongAdder有着明显更高的吞吐量,但是有着更高的空间复杂度(缺点就是内存占用偏高点)。

LongAdder是JDK1.8开始出现的,所提供的API基本上可以替换掉原先的AtomicLong。该类的outline如下:
在这里插入图片描述

LongAdder的优化思想

LongAdder所使用的思想就是热点分离,这一点可以类比一下ConcurrentHashMap的设计思想。就是将value值分离成一个数组,当多线程访问时,通过hash算法映射到其中的一个数字进行计数。而最终的结果,就是这些数组的求和累加。这样一来,就减小了锁的粒度。如下图所示:
在这里插入图片描述

在实现的代码中,LongAdder一开始并不会直接使用Cell[]存储。而是先使用一个long类型的base存储,当casBase()出现失败时,则会创建Cell[]。此时,如果在单个Cell上面出现了cell更新冲突,那么会尝试创建新的Cell,或者将Cell[]扩容为2倍。代码如下:

    public void increment() {
        add(1L);
    }
 
    public void add(long x) {
        Cell[] as; long b, v; int m; Cell a;
        if ((as = cells) != null || !casBase(b = base, b + x)) {// 如cells不为空,直接对cells操作;否则casBase
            boolean uncontended = true;
            if (as == null || (m = as.length - 1) < 0 ||
                (a = as[getProbe() & m]) == null ||
                !(uncontended = a.cas(v = a.value, v + x)))    // CAS cell
                longAccumulate(x, null, uncontended);    // 创建新的Cell或者扩容
        }
    }

与其他原子类一样,LongAdder也是基于CAS实现的。

LongAdder和AtomicLong性能对比测试

说了这么多,出现LongAdder就是为了来提高并发性能的,那么是骡子是马,拉出来遛遛吧:

    //访问的线程总数
    public static final int THREAD_COUNT = 100;
    //循环的总次数
    public static final int LOOP_COUNT = 10000;
    
    static ExecutorService pool = Executors.newFixedThreadPool(THREAD_COUNT);
    static CompletionService<Long> completionService = new ExecutorCompletionService<>(pool);

    //static的共享变量
    static final AtomicLong atomicLong = new AtomicLong(0L);
    static final LongAdder longAdder = new LongAdder();

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        long start = System.currentTimeMillis();
        for (int i = 0; i < THREAD_COUNT; i++) {
            completionService.submit(() -> {
                for (int j = 0; j < 100000; j++) {
                    //对比只需要求欢此方法即可
                    atomicLong.incrementAndGet();
                    //longAdder.increment();
                }
                return 1L;
            });
        }
        for (int i = 0; i < THREAD_COUNT; i++) {
            Future<Long> future = completionService.take();
            future.get();
        }
        System.out.println("耗时:" + (System.currentTimeMillis() - start));
        pool.shutdown();
    }

第一把:线程100个,循环总次数10000次:

LongAdder耗时:300ms
AtomicLong耗时:265ms

第二把:线程100个,循环总次数100000次:

LongAdder耗时:306ms
AtomicLong耗时:439ms

第三把:线程1000个,循环总次数10000次:

LongAdder耗时:613ms
AtomicLong耗时:735ms

第四把:线程1000个,循环总次数1000000次:

LongAdder耗时:5463ms
AtomicLong耗时:37964ms

从上面的性能测试,可以得出结论:

  1. 在并发比较低的时候,LongAdder和AtomicLong的效果非常接近
  2. 但是当并发较高时,两者的差距会越来越大。如上最后一个,当并发大循环次数多的时候,LongAdder的优势非常明显(6倍以上)
LongAccumulator

关于LongAccumulator,可以说是加强版的LongAdder。LongAdder的API相对比较简陋,只有对数值的加减,而LongAccumulator提供了自定义的函数操作,我们可以自己去决定计算方式。

    // accumulatorFunction:需要执行的二元函数(接收2个long作为形参,并返回1个long);identity:初始值
    public LongAccumulator(LongBinaryOperator accumulatorFunction, long identity) {
        this.function = accumulatorFunction;
        base = this.identity = identity;
    }

accumulatorFunction:需要执行的二元函数(接收2个long作为形参,并返回1个long);
identity:初始值。下面看一个Demo:

代码示例:

    public static void main(String[] args) throws InterruptedException {
        //这样就可以很安全的求和操作了
        LongAccumulator accumulator = new LongAccumulator(Long::max, Long.MIN_VALUE);

        Thread[] ts = new Thread[1000];

        for (int i = 0; i < 1000; i++) {
            ts[i] = new Thread(() -> {
                Random random = new Random();
                long value = random.nextLong();

                accumulator.accumulate(value); // 比较value和上一次的比较值,然后存储较大者
            });
            ts[i].start();
        }
        for (int i = 0; i < 1000; i++) {
            ts[i].join();
        }
        System.out.println(accumulator.longValue()); //9207653574451187103
    }

accumulate(value)传入的值会与上一次的比较值对比,然后保留较大者,最后打印出最大值。

LongAdder可以代替AtomicLong吗?

话有说回来啊,JDK8并没有把AtomicLong标记为过期,所以肯定还是很多用武之地的。
从LongAdder的Api可以看出,提供的方法还是挺少的。它更多地用于收集统计数据,而不是细粒度的同步控制。
LongAdder只提供了add(long)和decrement()方法,想要使用CAS更全面的方法还是要选择AtomicLong。
因此如果你只需要做形如count++的操作,推荐使用LongAdder代替AtomicLong吧(阿里开发手册就是这么推荐的)

DoubleAdder和DoubleAccumulator使用方法类似,这里不在介绍

注意,没有提供IntegerAdder哦~


关注A哥

AuthorA哥(YourBatman)
个人站点www.yourbatman.cn
E-mailyourbatman@qq.com
微 信fsx641385712
活跃平台
公众号BAT的乌托邦(ID:BAT-utopia)
知识星球BAT的乌托邦
每日文章推荐每日文章推荐

BAT的乌托邦

评论 11
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值