阿里为什么推荐使用LongAdder，而不是volatile？

分手后的思念是犯贱 2023-10-05 09:04 72阅读 0赞

![format_png][]

这是我的第 87 篇原创文章

作者 | 王磊

来源 | Java中文社群（ID：javacn666）

转载请联系授权（微信ID：GG\_Stone）

阿里《Java开发手册》最新嵩山版[在 8.3 日发布][8.3]，其中有一段内容引起了老王的注意，内容如下：

> 【参考】volatile 解决多线程内存不可见问题。对于一写多读，是可以解决变量同步问题，但是如果多写，同样无法解决线程安全问题。
> 
> 说明：如果是 count++ 操作，使用如下类实现：AtomicInteger count = new AtomicInteger(); count.addAndGet(1); 如果是 JDK8，推荐使用 LongAdder 对象，比 AtomicLong 性能更好（减少乐观 锁的重试次数）。

以上内容共有两个重点：

1.  类似于 count++ 这种非一写多读的场景不能使用 `volatile`；
2.  如果是 JDK8 推荐使用 `LongAdder` 而非 `AtomicLong` 来替代 `volatile`，因为 `LongAdder` 的性能更好。

但口说无凭，即使是孤尽大佬说的，咱们也得证实一下，因为马老爷子说过：**实践是检验真理的唯一标准**。

这样做也有它的好处，第一，加深了我们对知识的认知；第二，文档上只写了`LongAdder` 比 `AtomicLong` 的性能高，但是高多少呢？文中并没有说，那只能我们自己动手去测试喽。

话不多，接下来我们直接进入本文正式内容...

#### volatile 线程安全测试 ####

首先我们来测试 `volatile` 在多写环境下的线程安全情况，测试代码如下：

public class VolatileExample {
        public static volatile int count = 0; // 计数器
        public static final int size = 100000; // 循环测试次数
    
        public static void main(String[] args) {
            // ++ 方式 10w 次
            Thread thread = new Thread(() -> {
                for (int i = 1; i <= size; i++) {
                    count++;
                }
            });
            thread.start();
            // -- 10w 次
            for (int i = 1; i <= size; i++) {
                count--;
            }
            // 等所有线程执行完成
            while (thread.isAlive()) {}
            System.out.println(count); // 打印结果
        }
    }

我们把 `volatile` 修饰的 `count` 变量 ++ 10w 次，在启动另一个线程 -- 10w 次，正常来说结果应该是 0，但是我们执行的结果却为：

> 1063

**结论：由以上结果可以看出 `volatile` 在多写环境下是非线程安全的，测试结果和《Java开发手册》相吻合。**

#### LongAdder VS AtomicLong ####

接下来，我们使用 Oracle 官方的 [JMH（Java Microbenchmark Harness， JAVA 微基准测试套件）][JMH_Java Microbenchmark Harness_ JAVA]来测试一下两者的性能，测试代码如下：

import org.openjdk.jmh.annotations.*;
    import org.openjdk.jmh.infra.Blackhole;
    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.AtomicInteger;
    import java.util.concurrent.atomic.LongAdder;
    
    @BenchmarkMode(Mode.AverageTime) // 测试完成时间
    @OutputTimeUnit(TimeUnit.NANOSECONDS)
    @Warmup(iterations = 1, time = 1, timeUnit = TimeUnit.SECONDS) // 预热 1 轮，每次 1s
    @Measurement(iterations = 5, time = 5, timeUnit = TimeUnit.SECONDS) // 测试 5 轮，每次 3s
    @Fork(1) // fork 1 个线程
    @State(Scope.Benchmark)
    @Threads(1000) // 开启 1000 个并发线程
    public class AlibabaAtomicTest {
    
        public static void main(String[] args) throws RunnerException {
            // 启动基准测试
            Options opt = new OptionsBuilder()
                    .include(AlibabaAtomicTest.class.getSimpleName()) // 要导入的测试类
                    .build();
            new Runner(opt).run(); // 执行测试
        }
    
        @Benchmark
        public int atomicTest(Blackhole blackhole) throws InterruptedException {
            AtomicInteger atomicInteger = new AtomicInteger();
            for (int i = 0; i < 1024; i++) {
                atomicInteger.addAndGet(1);
            }
            // 为了避免 JIT 忽略未被使用的结果
            return atomicInteger.intValue();
        }
    
        @Benchmark
        public int longAdderTest(Blackhole blackhole) throws InterruptedException {
            LongAdder longAdder = new LongAdder();
            for (int i = 0; i < 1024; i++) {
                longAdder.add(1);
            }
            return longAdder.intValue();
        }
    }

程序执行的结果为：

![format_png 1][]

从上述的数据可以看出，在开启了 1000 个线程之后，程序的 `LongAdder` 的性能比 `AtomicInteger` 快了约 1.53 倍，你没看出是开了 1000 个线程，为什么要开这么多呢？这其实是为了模拟高并发高竞争的环境下二者的性能查询。

如果在低竞争下，比如我们开启 100 个线程，测试的结果如下：

![format_png 2][]

结论：从上面结果可以看出，**在低竞争的并发环境下 `AtomicInteger` 的性能是要比 `LongAdder` 的性能好，而高竞争环境下 `LongAdder` 的性能比 `AtomicInteger` 好**，当有 1000 个线程运行时，`LongAdder` 的性能比 `AtomicInteger` 快了约 1.53 倍，所以各位要根据自己业务情况选择合适的类型来使用。

##### 性能分析 #####

为什么会出现上面的情况？这是因为 `AtomicInteger` 在高并发环境下会有多个线程去竞争一个原子变量，而始终只有一个线程能竞争成功，而其他线程会一直通过 CAS 自旋尝试获取此原子变量，因此会有一定的性能消耗；而 `LongAdder` 会将这个原子变量分离成一个 Cell 数组，每个线程通过 Hash 获取到自己数组，这样就减少了乐观锁的重试次数，从而在高竞争下获得优势；而在低竞争下表现的又不是很好，可能是因为自己本身机制的执行时间大于了锁竞争的自旋时间，因此在低竞争下表现性能不如 `AtomicInteger`。

#### 总结 ####

本文我们测试了 `volatile` 在多写情况下是非线程安全的，而**在低竞争的并发环境下 `AtomicInteger` 的性能是要比 `LongAdder` 的性能好，而高竞争环境下 `LongAdder` 的性能比 `AtomicInteger` 好**，因此我们在使用时要结合自身的业务情况来选择相应的类型。

![format_png 3][]

[![format_png 4][]][format_png 4 1]

[阿里《Java开发手册》最新嵩山版发布！][format_png 4 1]

[![format_png 5][]][format_png 5 1]

[6种快速统计代码执行时间的方法，真香!(史上最全)][format_png 5 1]

[![format_png 6][]][format_png 6 1]

[Oracle官方推荐的性能测试工具！简单、精准又直观！][format_png 6 1]

--------------------

**文末福利**：我整理了一份 280 多页的《JAVA核心面试知识整理.pdf》，包含了：Java 集合、Java 基础、JVM、并发编程、Spring 原理、Netty、网络、Kafka、Zookeeper、RabbitMQ、设计模式、数据库、数据结构和算法等面试题。

**下载方式**

***1.*** **首先扫描下方二维码**

***2.*** **后台回复「****面试****」即可获取**

![format_png 7][]

注明：仅仅作为知识分享，切勿用于其它商业活动 。感谢所有技术分享者的付出。

[format_png]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy9Icld3Nlp1WENzalhMbU4wOHVQSlBpYTltMGUxenAzWHhiOTFlYXRkZmljTU5sMkpwcU5WaWFnNDJXbmZ0dWZwZjBrV1NpY01GdHA0TEFhdDBOOFVZZ3FpYjNBLzY0MA?x-oss-process=image/format,png
[8.3]: https://mp.weixin.qq.com/s?__biz=MzU1NTkwODE4Mw%3D%3D&idx=1&mid=2247487645&scene=21&sn=3d60fe2de44eac0e66e80725e0c34240#wechat_redirect
[JMH_Java Microbenchmark Harness_ JAVA]: https://mp.weixin.qq.com/s?__biz=MzU1NTkwODE4Mw%3D%3D&idx=1&mid=2247486145&scene=21&sn=06e9e09018787f968fa05577e2663b42#wechat_redirect
[format_png 1]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy9Icld3Nlp1WENzalhMbU4wOHVQSlBpYTltMGUxenAzWHhHMVhuOGtYVjliTmZzNDg1YTdUaWFNRkRnV3BDUzFBWllxV3FNbmREaWNONXo3dlFVbHJUNUV5dy82NDA?x-oss-process=image/format,png
[format_png 2]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy9Icld3Nlp1WENzalhMbU4wOHVQSlBpYTltMGUxenAzWHhkVndjQ3ZUOHZkSmtCRVA4Z1V6TVRQQlZjRkZxNjdOWjA4UWdYd2E1aGtuZVBjZEExN1htbkEvNjQw?x-oss-process=image/format,png
[format_png 3]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X2dpZi9iOTZDaWJDdDcwaWFid2p5b2pMaEEwM1B0eFVua05QUkVudDJGNDh5d2ZYTHBEZERBamljT1RQSThROTR0VkxiSjU4dGJSczEyaWFYREtoVU9XOWdkNE5sRkEvNjQw?x-oss-process=image/format,png
[format_png 4]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X2pwZy9Icld3Nlp1WENzaWFSU0NNV000Q3R6djRCbDFuOE9adUNjQnhkS0pQRjE2VktRTWh4NlhCWEI0OWhyeW5wbkkxR3dxWWJOZGlhN20yalJoMUZDbjJLaWFVZy82NDA?x-oss-process=image/format,png
[format_png 4 1]: http://mp.weixin.qq.com/s?__biz=MzU1NTkwODE4Mw%3D%3D&chksm=fbcc7da5ccbbf4b30dfc048032a272764145fbd71008e132316eaa79f4fe11575f5ae22b8f1a&idx=1&mid=2247487645&scene=21&sn=3d60fe2de44eac0e66e80725e0c34240#wechat_redirect
[format_png 5]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X2pwZy9Icld3Nlp1WENzaFhkUFg2OEg1M0V0TEZSR2ljaWJrcVpzYVBqQWdibXRpYzNUaWM5WGNCUGlhRUJCTlNNalhrY2ljejJ3WmZkcWliU3ZnaWM2RWliMkhiTkZOWFR6Zy82NDA?x-oss-process=image/format,png
[format_png 5 1]: http://mp.weixin.qq.com/s?__biz=MzU1NTkwODE4Mw%3D%3D&chksm=fbcc6270ccbbeb663ff5fe2d433fd4f7411388f64af0e59c7f1e16727cd00185e9aa188de0c0&idx=1&mid=2247487304&scene=21&sn=d978d29170acb1ad37af96e554d3e3a5#wechat_redirect
[format_png 6]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X2pwZy9Icld3Nlp1WENzaWFJWENzejNrelJPV3V0UGljakVOSUNGWDR4eE9LZ3lQR1p4dzlVR2ljaWJpY0VNdXZrSVNUdHR4VDRqaWI5TDJxcjFKUExHY2EzeWJyT21XUS82NDA?x-oss-process=image/format,png
[format_png 6 1]: http://mp.weixin.qq.com/s?__biz=MzU1NTkwODE4Mw%3D%3D&chksm=fbcc67f9ccbbeeefbb4fa9d8228735ea9d65278de37a19064d08b839ebdd2b7a5c7349ff3b4d&idx=1&mid=2247486145&scene=21&sn=06e9e09018787f968fa05577e2663b42#wechat_redirect
[format_png 7]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy9HSnZ1V2lhTURaa0JmMUdTTjI5MENIWWQ1QWZPV0hoUlBWOUx3M2ljYmliaWNFbE02NjVEYnh3Y1hEV01NaWF6Z2lhOUdrV0ZpYzIxaDNIYjZGRXpUWTVZM2pQbWcvNjQw?x-oss-process=image/format,png