AtomicLong 和 LongAdder 的区别
AtomicLong
1、AtomicLong是利用了底层的CAS操作来提供并发性。
2、在并发量较低的环境下,线程冲突的概率比较小,自旋的次数不会很多。但是,高并发环境下,N个线程同时进行自旋操作,会出现大量失败并不断自旋的情况,此时AtomicLong的自旋会成为瓶颈。
3、AtomicLong中有个内部volatile变量value保存着实际的long值,所有的操作都是针对该变量进行。也就是说,高并发环境下,value变量其实是一个热点,也就是N个线程竞争一个热点。
LongAdder
1、LongAdder的基本思路就是分散热点,将value值分散到一个数组中,不同线程会命中到数组的不同槽中,各个线程只对自己槽中的那个值进行CAS操作,这样热点就被分散了,冲突的概率就小很多。如果要获取真正的long值,只要将各个槽中的变量值累加返回。
2、低并发、一般的业务场景下AtomicLong是足够了。如果并发量很多,存在大量写多读少的情况,那LongAdder可能更合适。
利用JMH测试AtomicLong和LongAdder的性能
1、创建一个Maven工程,Pom.xml代码如下
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.jane</groupId>
<artifactId>jmh1</artifactId>
<version>1.0-SNAPSHOT</version>
<dependencies>
<!-- JMH -->
<dependency>
<groupId>org.openjdk.jmh</groupId>
<artifactId>jmh-core</artifactId>
<version>1.20</version>
</dependency>
<dependency>
<groupId>org.openjdk.jmh</groupId>
<artifactId>jmh-generator-annprocess</artifactId>
<version>1.20</version>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>exec-maven-plugin</artifactId>
<executions>
<execution>
<id>run-benchmarks</id>
<phase>integration-test</phase>
<goals>
<goal>exec</goal>
</goals>
<configuration>
<classpathScope>test</classpathScope>
<executable>java</executable>
<arguments>
<argument>-classpath</argument>
<classpath />
<argument>org.openjdk.jmh.Main</argument>
<argument>.*</argument>
</arguments>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>
</project>
2、启动文件
package com.jane;
import org.openjdk.jmh.annotations.*;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.RunnerException;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.atomic.LongAdder;
@BenchmarkMode(Mode.AverageTime) // 测试方法平均执行时间,如果测试吞入量则换成Mode.Throughput
@OutputTimeUnit(TimeUnit.MICROSECONDS) // 输出结果的时间粒度为微秒
public class Main {
private static AtomicLong count = new AtomicLong();
private static LongAdder longAdder = new LongAdder();
@Benchmark
@Threads(1) //单位时间内也,默认一秒启动多少个线程进行测试
public void atolong(){
count.getAndIncrement(); //测试AtomicLong递增方法
}
@Benchmark
@Threads(1) //单位时间内也,默认一秒启动多少个线程进行测试
public void loadder(){
longAdder.increment();//测试LongAdder的递增方法
}
public static void main(String[] args) throws RunnerException {
Options options = new OptionsBuilder()
.include(Main.class.getSimpleName())
.forks(1)
.build();
new Runner(options).run();
}
}
3、单线程下的性能对比
吞吐量:AtomicLong性能更好
平均消耗时间:AtomicLong耗时更小
4、20个线程下的性能对比
吞吐量:LongAdder优势明显
平均消耗时间:LongAdder优势明显