Fork/Join 简单实用

项目中有远程多次远程调用需求，由于等待时间过长照成相应超时，于是需要多线程调用并获取结果组装，从而引入Fork/Join，由于过多线程会大量消耗CPU，请妥善计算好MAX值，放置系统出错

具体例子：

package TestMessage;

import org.springframework.web.client.RestTemplate;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.concurrent.RecursiveTask;



public class test14 {

    private static final Integer MAX = 5;

    static class MyForkJoinTask extends RecursiveTask<List<Integer > > {
        // 子任务开始计算的值
        private Integer startValue;

        // 子任务结束计算的值
        private Integer endValue;

        // 主线程传入的对象、服务、及其它
        private RestTemplate restTemplate;

        public MyForkJoinTask(Integer startValue , Integer endValue,  RestTemplate restTemplate) {
            this.startValue = startValue;
            this.endValue = endValue;
            this.restTemplate = restTemplate;
        }

        @Override
        protected  List<Integer >  compute() {
            // 如果条件成立，说明这个任务所需要计算的数值分为足够小了
            // 可以正式进行累加计算了
            if(endValue - startValue < MAX) {

                String threadname = Thread.currentThread().getName();

                System.out.println("开始计算的部分：startValue = " + startValue + ";endValue = " + endValue+";线程名称 = "+threadname);
                Integer totalValue = 0;
                List<Integer > returnList = new ArrayList<>();
                for(int index = this.startValue ; index <= this.endValue  ; index++) {
                    totalValue += index;
                    returnList.add(index);
                }
                return returnList;
            }
            // 否则再进行任务拆分，拆分成两个任务
            else {
                MyForkJoinTask leftTask  = new MyForkJoinTask(startValue, (startValue + endValue) / 2,restTemplate);

                MyForkJoinTask rightTask  = new MyForkJoinTask((startValue + endValue) / 2 + 1 , endValue,restTemplate);

                //执行子任务
                invokeAll(leftTask,rightTask);

                // 结果合并
                boolean b = leftTask.join().addAll(rightTask.join());

                return leftTask.join();
            }
        }
    }

    public static void main(String[] args) {

        RestTemplate restTemplate = new RestTemplate();
        // 这是Fork/Join框架的线程池
        ForkJoinPool pool = new ForkJoinPool();

        ForkJoinTask<List<Integer >> taskFuture =  pool.submit(new MyForkJoinTask(1,121,restTemplate));
        try {
            List<Integer > result = taskFuture.get();
            System.out.println("result = " + result);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace(System.out);
        }
    }
}