我编写了一些简单的 Java 代码来人为地使用大量 RAM，我发现当我使用这些标志时获得相关时间:

1029.59 seconds .... -Xmx8g -Xms256m
696.44 seconds ..... -XX:ParallelGCThreads=1  -Xmx8g -Xms256m
247.27 seconds ..... -XX:ParallelGCThreads=1 -XX:+UseConcMarkSweepGC  -Xmx8g -Xms256m

现在，我明白了为什么 -XX:+UseConcMarkSweepGC 会提高性能，但是为什么当我限制为单线程 GC 时我会得到加速？这是我写得不好的 Java 代码的产物，还是这也适用于适当优化的 Java？

这是我的代码:

import java.io.*;

class xdriver {
  static int N = 100;
  static double pi = 3.141592653589793;
  static double one = 1.0;
  static double two = 2.0;

  public static void main(String[] args) {
    //System.out.println("Program has started successfully\n");

    if( args.length == 1) {
      // assume that args[0] is an integer
      N = Integer.parseInt(args[0]);
    }   

    // maybe we can get user input later on this ...
    int nr = N;
    int nt = N;
    int np = 2*N;

    double dr = 1.0/(double)(nr-1);
    double dt = pi/(double)(nt-1);
    double dp = (two*pi)/(double)(np-1);

    System.out.format("nn --> %d\n", nr*nt*np);

    if(nr*nt*np < 0) {
      System.out.format("ERROR: nr*nt*np = %d(long) which is %d(int)\n", (long)( (long)nr*(long)nt*(long)np), nr*nt*np);
      System.exit(1);
    }   

    // inserted to artificially blow up RAM
    double[][] dels = new double [nr*nt*np][3];

    double[] rs = new double[nr];
    double[] ts = new double[nt];
    double[] ps = new double[np];

    for(int ir = 0; ir < nr; ir++) {
      rs[ir] = dr*(double)(ir);
    }   
    for(int it = 0; it < nt; it++) {
      ts[it] = dt*(double)(it);
    }   
    for(int ip = 0; ip < np; ip++) {
      ps[ip] = dp*(double)(ip);
    }   

    double C = (4.0/3.0)*pi;
    C = one/C;

    double fint = 0.0;
    int ii = 0;
    for(int ir = 0; ir < nr; ir++) {
      double r = rs[ir];
      double r2dr = r*r*dr;
      for(int it = 0; it < nt; it++) {
        double t = ts[it];
        double sint = Math.sin(t);
        for(int ip = 0; ip < np; ip++) {
          fint += C*r2dr*sint*dt*dp;

          dels[ii][0] = dr; 
          dels[ii][1] = dt; 
          dels[ii][2] = dp; 
        }   
      }   
    }   

    System.out.format("N ........ %d\n", N);
    System.out.format("fint ..... %15.10f\n", fint);
    System.out.format("err ...... %15.10f\n", Math.abs(1.0-fint));
  }
}

最佳答案

我不是垃圾收集器方面的专家，所以这可能不是您想要得到的答案，但也许我在您的问题上的发现仍然很有趣。

首先，我已将您的代码更改为 JUnit测试用例。然后我添加了 JUnitBenchmarks从 Carrot Search Labs 扩展.它多次运行 JUnit 测试用例，测量运行时间，并输出一些性能统计数据。最重要的是 JUnitBenchMarks 会进行“预热”，即它会在实际进行测量之前多次运行代码。

我运行的最终代码:

import com.carrotsearch.junitbenchmarks.AbstractBenchmark;
import com.carrotsearch.junitbenchmarks.BenchmarkOptions;
import com.carrotsearch.junitbenchmarks.annotation.BenchmarkHistoryChart;
import com.carrotsearch.junitbenchmarks.annotation.LabelType;

@BenchmarkOptions(benchmarkRounds = 10, warmupRounds = 5)
@BenchmarkHistoryChart(labelWith = LabelType.CUSTOM_KEY, maxRuns = 20)
public class XDriverTest extends AbstractBenchmark {
    static int N = 200;
    static double pi = 3.141592653589793;
    static double one = 1.0;
    static double two = 2.0;

    @org.junit.Test
    public void test() {
        // System.out.println("Program has started successfully\n");
        // maybe we can get user input later on this ...
        int nr = N;
        int nt = N;
        int np = 2 * N;

        double dr = 1.0 / (double) (nr - 1);
        double dt = pi / (double) (nt - 1);
        double dp = (two * pi) / (double) (np - 1);

        System.out.format("nn --> %d\n", nr * nt * np);

        if (nr * nt * np < 0) {
            System.out.format("ERROR: nr*nt*np = %d(long) which is %d(int)\n",
                    (long) ((long) nr * (long) nt * (long) np), nr * nt * np);
            System.exit(1);
        }

        // inserted to artificially blow up RAM
        double[][] dels = new double[nr * nt * np][4];

        double[] rs = new double[nr];
        double[] ts = new double[nt];
        double[] ps = new double[np];

        for (int ir = 0; ir < nr; ir++) {
            rs[ir] = dr * (double) (ir);
        }
        for (int it = 0; it < nt; it++) {
            ts[it] = dt * (double) (it);
        }
        for (int ip = 0; ip < np; ip++) {
            ps[ip] = dp * (double) (ip);
        }

        double C = (4.0 / 3.0) * pi;
        C = one / C;

        double fint = 0.0;
        int ii = 0;
        for (int ir = 0; ir < nr; ir++) {
            double r = rs[ir];
            double r2dr = r * r * dr;
            for (int it = 0; it < nt; it++) {
                double t = ts[it];
                double sint = Math.sin(t);
                for (int ip = 0; ip < np; ip++) {
                    fint += C * r2dr * sint * dt * dp;

                    dels[ii][0] = dr;
                    dels[ii][5] = dt;
                    dels[ii][6] = dp;
                }
            }
        }

        System.out.format("N ........ %d\n", N);
        System.out.format("fint ..... %15.10f\n", fint);
        System.out.format("err ...... %15.10f\n", Math.abs(1.0 - fint));
    }
}

从基准选项 @BenchmarkOptions(benchmarkRounds = 10, warmupRounds = 5) 可以看出，预热通过运行测试方法 5 次来完成，之后实际基准运行 10 次。

然后我使用几个不同的 GC 选项运行上面的程序(每个选项都有 -Xmx1g -Xms256m 的常规堆设置):

• 默认(无特殊选项)
• -XX:ParallelGCThreads=1 -Xmx1g -Xms256m
• -XX:ParallelGCThreads=2 -Xmx1g -Xms256m
• -XX:ParallelGCThreads=4 -Xmx1g -Xms256m
• -XX:+UseConcMarkSweepGC -Xmx1g -Xms256m
• -XX:ParallelGCThreads=1 -XX:+UseConcMarkSweepGC -Xmx1g -Xms256m
• -XX:ParallelGCThreads=2 -XX:+UseConcMarkSweepGC -Xmx1g -Xms256m
• -XX:ParallelGCThreads=4 -XX:+UseConcMarkSweepGC -Xmx1g -Xms256m

为了获得带有图表的摘要作为 HTML 页面，除了上面提到的 GC 设置之外，还传递了以下 VM 参数:

-Djub.consumers=CONSOLE,H2 -Djub.db.file=.benchmarks
-Djub.customkey=[CUSTOM_KEY]

(其中 [CUSTOM_KEY] 必须是唯一标识每个基准测试运行的字符串，例如 defaultGC 或 ParallelGCThreads=1。它用于作为图表轴上的标签)。

下表总结了结果:

Run Custom key          Timestamp                   test
1   defaultGC           2015-05-01 19:43:53.796     10.721
2   ParallelGCThreads=1 2015-05-01 19:51:07.79       8.770
3   ParallelGCThreads=2 2015-05-01 19:56:44.985      8.737
4   ParallelGCThreads=4 2015-05-01 20:01:30.071     10.415
5   UseConcMarkSweepGC  2015-05-01 20:03:54.474      2.683
6   UseCCMS,Threads=1   2015-05-01 20:10:48.504      3.856
7   UseCCMS,Threads=2   2015-05-01 20:12:58.624      3.861
8   UseCCMS,Threads=4   2015-05-01 20:13:58.94       2.701

系统信息:CPU:Intel Core 2 Quad Q9400，2.66 GHz，内存:4.00 GB，操作系统:Windows 8.1 x64，JVM:1.8.0_05-b13。

(请注意，单独的基准测试运行会输出更详细的信息，例如标准派生 GC 调用和时间；不幸的是，此信息在摘要中不可用)。

解释

如您所见，当启用 -XX:+UseConcMarkSweepGC 时，性能会得到巨大提升。线程数对性能的影响不大，更多线程是否有利取决于一般的GC策略。默认 GC 似乎从两个或三个线程中获益，但如果使用四个线程，性能会变差。

相反，具有四个线程的ConcurrentMarkSweep GC 比具有一个或两个线程的性能更高。

所以一般来说，我们不能说GC线程越多性能越差。

请注意，我不知道，在没有指定线程数的情况下，使用默认GC或ConcurrentMarkSweep GC时，使用了多少个GC线程。

关于java - 为什么将 GC 限制为 1 个线程会提高性能？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/29991282/