ForkJoin计算对比普通方式计算性能分析

package com.cwn.wizbank.common;

import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.Future;
import java.util.concurrent.RecursiveTask;

/**
 * @Description:
 * @Author :小书包
 * @CreateDate :2018-11-19 10:39
 */
public class ForkJoinTest extends RecursiveTask<Long> {

    private int start;
    private int end;
    // 设置小于该值时，不再继续拆分
    private static final int THRESHOLD = 200;

    public ForkJoinTest(int start, int end) {
        this.start = start;
        this.end = end;
    }

    @Override
    protected Long compute() {
        long sum = 0;
        // 是否可以进行计算
        boolean canOperation = (end - start) <= THRESHOLD;

        if (canOperation) {
            for (int i = start; i < end; i++) {
                sum = sum + i;
            }
        } else {
            // 进行拆分
            int middle = (start + end) / 2;
            ForkJoinTest leftTask = new ForkJoinTest(start, middle);
            ForkJoinTest rightTask = new ForkJoinTest(middle, end);

            leftTask.fork();
            rightTask.fork();

            long leftResult = leftTask.join();
            long rightResult = rightTask.join();

            sum = leftResult + rightResult;
        }
        return sum;
    }

    public static void main(String[] args) throws IOException {
        long startTime;
        long endTime;
        for (int i = 10000; i < 100000; i = i + 10000) {
            startTime = System.nanoTime();
            calcuByForkJoin(0, i);
            endTime = System.nanoTime();
            System.out.print("ForkJoin方式计算" + i + "次消耗的时间为：" + (endTime - startTime) / 1000000.0 + "ms\r\n");

            startTime = System.nanoTime();
            calcuByNormal(0, i);
            endTime = System.nanoTime();
            System.out.print("普通方式方式计算" + i + "次消耗的时间为：" + (endTime - startTime) / 1000000.0 + "ms\r\n");
        }
    }

    /**
     * 常规方式计算总和
     * @param start 开始
     * @param end 结束
     */
    private static void calcuByNormal(int start, int end) {
        long sum = 0;
        for (int i = start; i < end; i++) {
            sum = sum + i;
        }
        System.out.print("普通方式计算结果为：" + sum + "\t\t");
    }

    /**
     * forkJoin方式计算总和
     * @param start 开始位置
     * @param end 结束位置
     */
    private static void calcuByForkJoin(int start, int end) {

        ForkJoinPool pool = new ForkJoinPool();

        ForkJoinTest task = new ForkJoinTest(start, end);
        // 提交任务
        Future<Long> result = pool.submit(task);

        try {
            System.out.print("ForkJoin方式计算结果为：" + result.get() + "\t\t");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

分别从10000次开始计算到100000次，分别统计两个所花的时间：

ForkJoin方式计算结果为：49995000		ForkJoin方式计算10000次消耗的时间为：18.746042ms
普通方式计算结果为：49995000		普通方式方式计算10000次消耗的时间为：0.212907ms
ForkJoin方式计算结果为：199990000		ForkJoin方式计算20000次消耗的时间为：24.709994ms
普通方式计算结果为：199990000		普通方式方式计算20000次消耗的时间为：0.640001ms
ForkJoin方式计算结果为：449985000		ForkJoin方式计算30000次消耗的时间为：51.458177ms
普通方式计算结果为：449985000		普通方式方式计算30000次消耗的时间为：0.07552ms
ForkJoin方式计算结果为：799980000		ForkJoin方式计算40000次消耗的时间为：62.690614ms
普通方式计算结果为：799980000		普通方式方式计算40000次消耗的时间为：0.059306ms
ForkJoin方式计算结果为：1249975000		ForkJoin方式计算50000次消耗的时间为：41.256568ms
普通方式计算结果为：1249975000		普通方式方式计算50000次消耗的时间为：0.04736ms
ForkJoin方式计算结果为：1799970000		ForkJoin方式计算60000次消耗的时间为：103.517102ms
普通方式计算结果为：1799970000		普通方式方式计算60000次消耗的时间为：0.066133ms
ForkJoin方式计算结果为：2449965000		ForkJoin方式计算70000次消耗的时间为：138.015691ms
普通方式计算结果为：2449965000		普通方式方式计算70000次消耗的时间为：0.07296ms
ForkJoin方式计算结果为：3199960000		ForkJoin方式计算80000次消耗的时间为：70.298086ms
普通方式计算结果为：3199960000		普通方式方式计算80000次消耗的时间为：0.095147ms
ForkJoin方式计算结果为：4049955000		ForkJoin方式计算90000次消耗的时间为：120.423782ms
普通方式计算结果为：4049955000		普通方式方式计算90000次消耗的时间为：0.097706ms
ForkJoin方式计算结果为：4999950000		ForkJoin方式计算100000次消耗的时间为：204.868015ms
普通方式计算结果为：4999950000		普通方式方式计算100000次消耗的时间为：0.10496ms

可以明显的看到forkJoin花的时间比普通方式计算的时间长，如果把 THRESHOLD 值稍微调大一点，forkjoin花的时间在不断地减小