LongAdder和AtomicLong哪个性能更好，为什么？

/**
 * Atomically increments by one the current value.
 *
 * @return the updated value
 */
public final long incrementAndGet() {
    return unsafe.getAndAddLong(this, valueOffset, 1L) + 1L;
}

import java.text.NumberFormat;
import java.util.ArrayList;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.atomic.AtomicLong;

/**
 * <pre>
 * 程序目的：演示 AtomicInteger、AtomicLong 在高并发下性能不好
 * 在16个线程下使用AtomicLong。
 * 每次值发生变化时，都会刷新回主内存，竞争激烈时，这样的 flush 和 refresh 操作耗费了很多资源，而且 CAS 也会经常失败
 * </pre>
 * created at 2020/8/11 06:11
 * @author lerry
 */
public class AtomicLongDemo {
 /**
  * 线程池内线程数
  */
 final static int POOL_SIZE = 1000;

 public static void main(String[] args) throws InterruptedException {
  long start = System.currentTimeMillis();

  AtomicLong counter = new AtomicLong(0);
  ExecutorService service = Executors.newFixedThreadPool(POOL_SIZE);

  ArrayList<Future> futures = new ArrayList<>(POOL_SIZE);
  for (int i = 0; i < POOL_SIZE * 100; i++) {
   futures.add(service.submit(new Task(counter)));
  }

  // 等待所有线程执行完
  for (Future future : futures) {
   try {
    future.get();
   }
   catch (ExecutionException e) {
    e.printStackTrace();
   }
  }

  NumberFormat numberFormat = NumberFormat.getInstance();
  System.out.printf("统计结果为：[%s]n", numberFormat.format(counter.get()));
  System.out.printf("耗时：[%d]毫秒", (System.currentTimeMillis() - start));
  // 关闭线程池
  service.shutdown();
 }

 /**
  * 有一个 AtomicLong 成员变量，每次执行N次+1操作
  */
 static class Task implements Runnable {

  private final AtomicLong counter;

  public Task(AtomicLong counter) {
   this.counter = counter;
  }

  /**
   * 每个线程执行N次+1操作
   */
  @Override
  public void run() {
   for (int i = 0; i < 100; i++) {
    counter.incrementAndGet();
   }
  }// end run
 }// end class
}

import java.text.NumberFormat;
import java.util.ArrayList;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.atomic.LongAdder;

/**
 * <pre>
 * 程序目的：和 AtomicLong 进行性能对比
 * </pre>
 * created at 2020/8/11 06:25
 * @author lerry
 */
public class LongAdderDemo {
 /**
  * 线程池内线程数
  */
 final static int POOL_SIZE = 1000;

 public static void main(String[] args) throws InterruptedException {
  long start = System.currentTimeMillis();

  LongAdder counter = new LongAdder();
  ExecutorService service = Executors.newFixedThreadPool(POOL_SIZE);

  ArrayList<Future> futures = new ArrayList<>(POOL_SIZE);
  for (int i = 0; i < POOL_SIZE * 100; i++) {
   futures.add(service.submit(new LongAdderDemo.Task(counter)));
  }

  // 等待所有线程执行完
  for (Future future : futures) {
   try {
    future.get();
   }
   catch (ExecutionException e) {
    e.printStackTrace();
   }
  }

  NumberFormat numberFormat = NumberFormat.getInstance();
  System.out.printf("统计结果为：[%s]n", numberFormat.format(counter.sum()));
  System.out.printf("耗时：[%d]毫秒", (System.currentTimeMillis() - start));
  // 关闭线程池
  service.shutdown();
 }

 /**
  * 有一个 LongAdder 成员变量，每次执行N次+1操作
  */
 static class Task implements Runnable {

  private final LongAdder counter;

  public Task(LongAdder counter) {
   this.counter = counter;
  }

  /**
   * 每个线程执行N次+1操作
   */
  @Override
  public void run() {
   for (int i = 0; i < 100; i++) {
    counter.increment();
   }
  }// end run
 }// end class
}

java version "1.8.0_251"
Java(TM) SE Runtime Environment (build 1.8.0_251-b08)
Java HotSpot(TM) 64-Bit Server VM (build 25.251-b08, mixed mode)