Forkjoinpool VS顺序执行

Question

我正在比较算法（前n个数之和）的顺序和并行性能（使用ForkJoinPool）：

public class ForkJoinSumCalculator extends RecursiveTask<Long> {
    private static final ForkJoinPool FORKJOINPOOL = new ForkJoinPool();
    private final long[] numbers;
    private final int start;
    private final int end;
    public static final long THRESHOLD = 10_000;       

    public static void main(String[] args) {
        long startTime = System.currentTimeMillis();
        int numLoops = 40;
        for(int i = 1; i <= numLoops; i++) {
            ForkJoinSumCalculator forkJoinSumCalculator = new ForkJoinSumCalculator(LongStream.rangeClosed(1, 100000000).toArray());
            FORKJOINPOOL.invoke(forkJoinSumCalculator);
        }
        System.out.println("Total time parallel:"+ (System.currentTimeMillis() - startTime));

        startTime = System.currentTimeMillis();
        for(int i = 1; i <= numLoops ; i++) {
            long seqSum = 0L;
            for(int j = 1; j <= 100000000 ; j++) {
                seqSum = seqSum + j;
            }
        }
        System.out.println("Total time sequential:"+ (System.currentTimeMillis() - startTime));
    }

    public ForkJoinSumCalculator(long[] numbers) {
        this(numbers, 0, numbers.length);
    }
    private ForkJoinSumCalculator(long[] numbers, int start, int end) {
        this.numbers = numbers;
        this.start = start;
        this.end = end;
    }
    @Override
    protected Long compute() {
        ....splitting the task
        ....or calculating the sum if size is less than THRESHOLD 
    }
}

我试着用不同的NumLoop来获得不同的值，但顺序法总是表现得更好，而且也是按3-4的顺序。

考虑到阵列大小并不是那么小，并行版本在这里的性能不应该更好吗。

Answer 1

获得实际输出的一些建议：

1.我不知道你的机器上有多少个处理器。但是你在代码中使用了默认的。所以在这种情况下，基本上你没有得到并行处理的性能。当你创建ForkJoinpool的对象时，你需要发送你想要计算的处理器号。所以从

private static final ForkJoinPool FORKJOINPOOL = new ForkJoinPool();

为此：

private static final ForkJoinPool FORKJOINPOOL = new ForkJoinPool(8);

注意：对于我的机器，可用处理器的数量是8。所以我发这个。您可以从以下输出中获得您的：

System.out.println(Runtime.getRuntime().availableProcessors());

2.对于并行处理，在每个循环迭代中创建10^8个元素的长流。在Java中，创建一个新对象需要做很多事情。因此，它影响着并行处理的性能。在一个循环中，您根本没有创建任何对象。因此，要比较的领域并不相同。

您可以创建一个实例，并在每次引用该对象时使用它。所以改变这一部分：

for(int i = 1; i <= numLoops; i++) {
    ForkJoinSumCalculator forkJoinSumCalculator = new ForkJoinSumCalculator(LongStream.rangeClosed(1, 100000000).toArray());
    FORKJOINPOOL.invoke(forkJoinSumCalculator);
}

为此：

long[] longs = LongStream.rangeClosed(1, 100000000).toArray();
for(int i = 1; i <= numLoops; i++) {
    ForkJoinSumCalculator forkJoinSumCalculator = new ForkJoinSumCalculator(longs);
    FORKJOINPOOL.invoke(forkJoinSumCalculator);
}

3.当您在顺序1中进行求和时，您使用原语变量来声明seqSum，而您的并行任务使用装箱的变量来返回。盒装计算比原始计算需要更多的时间。

另外，当你在并行任务中发送一个数组时，我猜（你在帖子中没有给出代码），你是在使用这个数组来获得和。但在顺序索引中，不需要访问任何引用的索引。而是从迭代变量中获取值。对于像10^8这样的数字来说，创造差异实际上是很大的。

所以把那部分从：

for(int i = 1; i <= numLoops ; i++) {
    long seqSum = 0L;
    for(int j = 1; j <= 100000000 ; j++) {
        seqSum = seqSum + j;
    }
}

至：

for(int i = 1; i <= numLoops ; i++) {
    Long seqSum = 0L;
    for(int j = 1; j < 100000000 ; j++) {
        seqSum = seqSum + longs[j];
    }
}

在所有这些变化之后，使用一台4处理器的机器，我得到了以下信息：

Total time parallel:4461
Total time sequential:25542

并与8处理器的机器（更新了一个和更好的配置机器）：

Total time parallel:3157
Total time sequential:16863

最后但并非最不重要的是，你的问题给了我一些思考的要点。这就是为什么，谢谢！

快乐编码！