JDK7和JDK8之间的性能差异使用AtomicLong.IncrementAndGet

Question

使用AtomicLong.IncrementAndGet方法测试JDK7和JDK8的性能差异，测试数据表明JDK7的性能优于JDK8。为什么JDK7的性能比JDK8好？是什么导致JDK8中的性能差？

<table border="1">
      <thead>
        <tr>
          <th>The number of threads</th>
          <th>JDK7(Unit:Milliseconds)</th>
          <th>JDK8(Unit:Milliseconds)</th>
        </tr>
      </thead>
      <tbody>
        <tr>
          <td>1</td>
          <td>441351</td>
          <td>444246</td>
        </tr>
        <tr>
          <td>4</td>
          <td>245872</td>
          <td>248655</td>
        </tr>
        <tr>
          <td>8</td>
          <td>240513</td>
          <td>245395</td>
        </tr>
        <tr>
          <td>16</td>
          <td>275445</td>
          <td>279481</td>
        </tr>
      </tbody>
    </table>

系统环境：

CPU：Intel(R)至强(R)CPU E5620@2.40 GHz 2.40 GHz（双处理器）

内存：8.00 GB

set jvm_opt=-xms1024m-xmx1024m-xmn256m-xx:survivorratio=8-xx:permsize=128m-xx:maxpermsize=256m-xx:+useconcmarksweepgc-xx:+useparnewgc set jvm_opt=%jvm_opt%-xx:+disableexplicitgc set jvm_opt=%jvm_opt%-xx:+usecmscompactatfullcollection-xx:cmsfullgcsbeforecompaction=0 set

JDK 8：

set jvm_opt=-xms1024m-xmx1024m-xmn256m-xx:SurvivorRatio=8-xx:MetaspaceSize=128m-xx:MaxMetaspaceSize=256m-xx:+UseConcMarkSweepGC-xx:+UseParnewGC set jvm_opt=%Jvm_opt%-xx:+DisableExplicitGC set jvm_opt=%Jvm_opt%-xx:+UseFastAccessorMethods-xx:+CmsClassUnloadingEnabled

测试代码：

public class Main {
  private static final int K_SIZE = 1024;
  private static final long MAX = 300_000_000L;

  public static void main(String[] args) {

    int threadCount = Integer.getInteger("thread_count", 4);
    final int size = Integer.getInteger("size", 5);
    final long max = Long.getLong("max", MAX);

    final AtomicLong count = new AtomicLong();

    final CountDownLatch beginLatch = new CountDownLatch(1);
    final CountDownLatch endLatch = new CountDownLatch(threadCount);

    ExecutorService executor = Executors.newFixedThreadPool(threadCount);

    for (int i = 0; i < threadCount; i++) {
      executor.execute(new Runnable() {
        ConcurrentMap<Long, Long> map = new ConcurrentHashMap<Long, Long>();

        @Override
        public void run() {
          try {
            beginLatch.await();

                     byte[] data = null;
                     while (!Thread.currentThread().isInterrupted()) {
                       data = new byte[size * K_SIZE];
                       long current = count.incrementAndGet();
                       map.put(current, current);
                       data[0] = (byte) current;
                       if (current >= max) {
                         endLatch.countDown();
                            break;
                       } else if ((current % 1000) == 0) {
                         map.clear();
                       }
                     }
          } catch (InterruptedException e) {
             Thread.currentThread().interrupt();
          }
        }
     });
   }

   long startTime = System.currentTimeMillis();
  beginLatch.countDown();
  try {
    endLatch.await();
    long endTime = System.currentTimeMillis();
    System.out.println(endTime - startTime);
  } catch (InterruptedException e) {
  }

  executor.shutdown();
  }
}

Answer 1

您正在演示的性能差异不到1%。这是如此之小，以致于除了一个非常小的应用程序子集之外的所有应用程序都不相关。即使使用高分辨率的分析工具，也很难确定导致这种无关紧要的性能变化的确切原因。在1.7到1.8之间有这么多的新特性，这可能是由许多因素造成的。

纯粹是一时的猜测，在1.7和1.8之间有数百个bug修复。为了应对边缘条件而进行的额外错误检查很容易导致性能的轻微下降。