JAVA并发编程Fork/Join（分而治之思想）之(Future/Callable）

Java提供Fork/Join框架用于并行执行任务，它的思想就是讲一个大任务分割成若干小任务，最终汇总每个小任务的结果从而得到这个大任务的结果。

这里我们也借助这种思想来处理一个超大任务的运算，但是不用ForkJoinPool/ForkJoinTask这种方式，而采用ExecutorService/Future/Callable方式。

我们来看一段ExecutorService/Future/Callable方式实现的代码。

package com.forkjoin;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

/**
 * JAVA超大数据量计算
 * 求1到100000000的和
 * 解决方案采用多线程拆分任务实现(Future/Callable)
 *
 * @author 小辉GE/小辉哥
 * <p>
 * 2019年8月10日 下午19:30:00
 */
public class ParallelFutureComputing {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        // 直接执行方式测试
        long start = System.currentTimeMillis();
        getSum(1, 100000000);
        long end = System.currentTimeMillis();
        System.out.println("直接执行耗时时长：" + (end - start));

	// 线程池方式
	ExecutorService service = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());

        MyThreadTask t1 = new MyThreadTask(1, 25000000);
        MyThreadTask t2 = new MyThreadTask(25000001, 50000000);
        MyThreadTask t3 = new MyThreadTask(50000001, 75000000);
        MyThreadTask t4 = new MyThreadTask(75000001, 100000000);

        // 调用service.submit启动线程
        Future<Integer> f1 = service.submit(t1);
        Future<Integer> f2 = service.submit(t2);
        Future<Integer> f3 = service.submit(t3);
        Future<Integer> f4 = service.submit(t4);

        start = System.currentTimeMillis();
        // 调用FUTURE.GET的阻塞方法,记录最终完成的时间
        f1.get();
        f2.get();
        f3.get();
        f4.get();
        end = System.currentTimeMillis();
        System.out.println("Future/Callable执行耗时时长：" + (end - start));
        // 处理完成调用shutdown方法结束线程池
        service.shutdown();
    }

    static class MyThreadTask implements Callable<Integer> {
        Integer begin;
        Integer end;

        MyThreadTask(Integer begin, Integer end) {
            this.begin = begin;
            this.end = end;
        }

        @Override
        public Integer call() throws Exception {
            return getSum(begin, end);
        }
    }

    /**
     * 实现begin到end求和
     *
     * @param begin
     * @param end
     * @return
     */
    static Integer getSum(Integer begin, Integer end) {
        Integer sum = 0;
        for (int i = begin; i <= end; i++) {
            sum = sum + i;
        }
        return sum;
    }
}

测试输出结果如下：

结果分析：

其实我们很清晰可以看到，单独执行任务比采用多线程执行任务运行结果所花费的时间多一些。当然，如果任务拆分的合适、运算量足够大的时候，就更能看出多线程执行和单独执行的效率差别。

以上代码仅供参考，如有不当之处，欢迎指出！！！

更多干货，欢迎大家关注和联系我。期待和大家一起更好的交流、探讨技术！！！