How to add numbers using LongAdder function in Java

In Java, if we need to accumulate numbers, we usually use a simple counter or atomic variable. However, these methods have a disadvantage, that is, under high concurrency conditions, a large amount of contention may occur, resulting in performance degradation. At this time, we can use the LongAdder function introduced in Java 8 to replace these methods, thereby improving the execution efficiency of the program.

LongAdder is a thread-safe accumulator in Java. It adopts a decentralized strategy to reduce competition and thereby improve program execution efficiency. When multiple threads need to accumulate the same counter, LongAdder will disperse the counter value into multiple units. Each unit has an independent counter, and the threads can independently accumulate these units. When it is necessary to obtain the total value of the counter, LongAdder will accumulate the values ​​of all units to obtain the final counter value.

The following is a sample program to introduce how to use the LongAdder function to accumulate numbers:

import java.util.concurrent.atomic.LongAdder;

public class LongAdderDemo {
    
    public static void main(String[] args) throws InterruptedException {
        
        // 创建一个LongAdder对象
        LongAdder longAdder = new LongAdder();
        
        // 创建5个工作线程进行计数器累加
        for (int i = 0; i < 5; i++) {
            new Thread(() -> {
                for (int j = 0; j < 100000; j++) {
                    longAdder.increment();
                }
            }).start();
        }
        
        // 等待所有工作线程执行完毕
        Thread.sleep(2000);
        
        // 输出计数器值
        System.out.println("计数器值：" + longAdder.sum());
    }
    
}

In the above program, we first create a LongAdder object, and then create five working threads to perform calculations on the counter. Accumulation operation, finally output the total value of the counter. After running the program, we can see the following output:

计数器值：500000

As can be seen from the output, LongAdder can still provide excellent performance even under high concurrency conditions. If we use traditional counters or atomic variables to implement this example, serious competition problems may occur, resulting in a sharp decline in program execution efficiency.

In summary, LongAdder is a very practical accumulator function in Java, which can effectively improve the execution efficiency of the program. If your program requires a lot of numerical accumulation operations, you might consider using LongAdder instead of traditional counters or atomic variables.

The above is the detailed content of How to add numbers using LongAdder function in Java. For more information, please follow other related articles on the PHP Chinese website!