Java8对于多线程并发的一些新支持-LongAdder

我们知道AtomicLong、AtomicInteger是基于硬件级别cas实现的保证线程安全的自增类，能保证原子化的自增操作。在多线程下，性能远好于加锁synchronized。

AtomicLong的实现是当多线程并发自增、自减时，通过cas指令从机器指令级别操作保证并发的原子性。制约性能的是高并发时cas失败几率会变高。失败后会重试，越多线程失败、越多次重试，失败几率就会更高，性能就会下降。

Java8诞生了一个新类——LongAdder，从名字就能看到是Long的Add。AtomicLong是因为硬件对一个value进行加锁，由于value只有一个，必然在多线程中有访问冲突。

而LongAdder是将value拆分成多个cell，最终的value值就是这多个cell相加的和。所以对LongAdder进行加减操作时，只需要对不同的cell来操作，不同的线程对不同的cell进行cas操作，这样成功率就会大大提高。

在并发数不高的情况，拆分成若干的cell，然后去维护cell求和，性能是不如AtomicLong的。所以LongAdder用了巧妙的方法来解决。初始情况下，LongAdder与AtomicLong是相同的，只有在cas失败时，才会将value拆分成cell，每失败一次，都会增加cel的数量。这样就能兼顾低并发和高并发都能高效。

 

通过代码测试也能证明：

public class TestAtomicLong {
    private static AtomicLong ai = new AtomicLong(0);

    public static void main(String[] args) throws InterruptedException {
        MyThread mt = new MyThread();

        Long time = System.currentTimeMillis();
        System.out.println("当前时间：" + time);
        for (int i = 0; i < 4; i++) {
            Thread t = new Thread(mt);
            t.start();
        }

        Thread.sleep(5000);
    }

    static class MyThread implements Runnable {
        @Override
        public void run() {
            while (true) {
                if (ai.get() >= 100000000L) {
                    System.out.println("已达到1亿");
                    System.out.println(System.currentTimeMillis());
                    return;
                }
                ai.getAndIncrement();
            }
        }
    }

}

public class TestLongAdder {
    private static LongAdder ai = new LongAdder();

    public static void main(String[] args) throws InterruptedException {
        MyThread mt = new MyThread();

        Long time = System.currentTimeMillis();
        System.out.println("当前时间：" + time);
        for (int i = 0; i < 4; i++) {
            Thread t = new Thread(mt);
            t.start();
        }

        Thread.sleep(5000);
    }

    static class MyThread implements Runnable {
        @Override
        public void run() {
            while (true) {
                if (ai.longValue() >= 100000000L) {
                    System.out.println("已达到1亿");
                    System.out.println(System.currentTimeMillis());
                    return;
                }
                ai.increment();
            }
        }
    }

}

这是只有4个线程的情况下，多个线程对一个变量加到1亿时，看看时间。

• AtomicLong用了2.1秒，LongAdder用了2.2秒，性能还差于AtomicLong。

• 但是修改线程为50时，AtomicLong用了3秒，LongAdder用了2.3秒。

说明在多线程下，LongAdder优于AtomicLong。

 

---

现在，在处理高并发计数时，应该优先使用LongAdder，而不是继续使用AtomicLong。当然， 线程竞争很低的情况下进行计数，使用Atomic还是更简单更直接，并且效率稍微高一些。

其他情况，比如序号生成，这种情况下需要准确的数值，全局唯一的AtomicLong才是正确的选择，此时不应该使用LongAdder。

 

为什么LongAdder返回的值不是准确的数值

LongAdder.sum()方法返回的是： 累加的和，也就是“当前时刻”的计数值。

此返回值可能不是绝对准确的，因为调用这个方法时还有其他线程可能正在进行计数累加，方法的返回时刻和调用时刻不是同一个点，在有并发的情况下，这个值只是近似准确的计数值。

高并发时，除非全局加锁，否则得不到程序运行中某个时刻绝对准确的值，但是全局加锁在高并发情况下是下下策。

在很多的并发场景中，计数操作并不是核心，这种情况下允许计数器的值出现一点偏差，此时可以使用LongAdder。

在必须依赖准确计数值的场景中，应该自己处理而不是使用通用的类。

 

References

• Java8对于多线程并发的一些新支持-LongAdder
• jdk1.8 LongAdder源码学习
• Java8 源码阅读 - LongAdder