Java原子类：AtomicLong、LongAdder、LongAccumulator详解

超、凢脫俗 2023-01-05 12:49 234阅读 0赞

JUC包提供了一系列的原子性操作类，这些类都是使用非阻塞算法CAS实现的，相比使用锁实现原子性操作，这在性能上有很大的提高。

### 1、AtomicLong ###

JUC并发包中包含有AtomicInteger、AtomicLong和AtomicBoolean等原子性操作类，它们的原理类似。AtomicLong是原子性递增或者递减类，其内部使用Unsafe来实现。

**多线程使用AtomicLong统计0的个数：**

// 统计0的个数
    public class Atomic {
        // 创建Long型原子计数器
        private static AtomicLong atomicLong = new AtomicLong();
        // 创建数据源
        private static Integer[] arrayOne = new Integer[] {0,1,2,3,0,5,6,0,56,0};
        private static Integer[] arrayTwo = new Integer[] {10,1,2,3,0,5,6,0,56,0};
    
        public static void main(String[] args) throws InterruptedException {
            // 线程one统计数组arrayOne中0的个数
            Thread threadOne = new Thread(new Runnable() {
                @Override
                public void run() {
                    int size = arrayOne.length;
                    for (int i=0;i<size;i++) {
                        if(arrayOne[i].intValue() == 0) {
                            // 调用unsafe方法，原子性设置value值为原始值加1，返回值为递增后的值
                            atomicLong.incrementAndGet();
                        }
                    }
                }
            });
            // 线程two统计数组arrayTwo中0的个数
            Thread threadTwo = new Thread(new Runnable() {
                @Override
                public void run() {
                    int size = arrayTwo.length;
                    for (int i=0;i<size;i++) {
                        if(arrayTwo[i].intValue() == 0) {
                            atomicLong.incrementAndGet();
                        }
                    }
                }
            });
            // 启动子线程
            threadOne.start();
            threadTwo.start();
            // 等待线程执行完毕
            threadOne.join();
            threadTwo.join();
            System.out.println("count 0:" + atomicLong.get());
        }
    }

### 2、LongAdder类 ###

使用AtomicLong时，在高并发下大量线程会同时去竞争更新同一个原子变量，但是由于同时只有一个线程的CAS操作会成功，这就造成了大量线程竞争失败后，会通过无限循环不断进行自旋尝试CAS的操作，而这会白白浪费CPU资源。

JDK8新增了一个原子性递增或者递减类LongAdder用来克服在高并发下使用AtomicLong的缺点。它通过把一个变量分解为多个变量，让同样多的线程去竞争多个资源。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpX3dfY2g_size_16_color_FFFFFF_t_70][]

使用LongAdder时，在内部维护多个Cell变量，每个Cell里面有一个初始值为0的long型变量，这样，在同等并发量的情况下，争夺单个更新操作的线程量会减少，这变相地减少了争夺共享资源的并发量。

另外，多个线程在争夺同一个Cell原子变量时如果失败了，它并不是在当前Cell变量上一直自旋CAS重试，而是尝试在其他Cell的变量上进行CAS尝试，这个改变增加了当前线程重试CAS成功的可能性。最后，在获取LongAdder当前值时，是把所有Cell变量的value值累加后再加上base返回的。

LongAdder维护了一个延迟初始化的原子性更新数组和一个基值变量base。由于Cells占用的内存是相对比较大的，所以一开始并不创建它，而是在需要的时候创建，也就是懒加载。

### 3、LongAccumulator类 ###

LongAdder类是LongAccumulator的一个特例，LongAccumulator比LongAdder的功能更强大。它们有公共的父类Striped64。因此LongAccumulator内部的优化方式和LongAdder是一样的。它们都将一个long型整数分割，并存储在不同的变量中，以防止多线程竞争。对于LongAdder来说，他只是每次对给定的整数执行一次加法，而LongAccumulator则可以实现任意函数操作。

**通过多线程访问若干个整数，并返回遇到的最大的那个数：**

public class AccumulatorTest {
        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);
                });
                ts[i].start();
            }
            for (int i=0;i<1000;i++) {
                ts[i].join();
            }
            System.out.println(accumulator.longValue());
        }
    }

*  上述代码第二行构造了LongAccumulator实例。由于我们要过滤最大值，因此传入Long::max函数句柄。
 *  当有数据通过accumulate()方法传入LongAccumulator后，LongAccumulator会通过Long::max识别最大值并保存在内部（Cell数组内，或base）
 *  最后通过longValue()函数对所有的cell进行Long::max操作，得到最大值

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpX3dfY2g_size_16_color_FFFFFF_t_70]: /images/20221119/fca9871f34834d81a8e63d477353849e.png