多线程实现数据汇总

背景：当需要进行大规模数据计算的时候，整体处理的效率较低，因此需要将数据分块计算然后，最终得到结果。

1、首先创建一个计算划分类

package com.smart.generic;

import lombok.Getter;
import lombok.Setter;
import lombok.ToString;

/**
 *
 * @author smart 2019/4/6
 */

@Getter
@Setter
@ToString
public class Calcualtor {

    private int indexBegin;

    private int indexEnd;

    private int []arr;

    private Long sum;
}

2、实现Runnable接口

package com.smart.generic;

import lombok.Getter;

import java.util.concurrent.Callable;

/**
 *
 * @author smart 2019/4/6
 */
public class Calculate implements Callable <Long>{

    @Getter
    private Calcualtor calcualtor;

    public  Calculate (Calcualtor calcualtor){
        this.calcualtor = calcualtor;
    }
    @Override
    public Long call() throws Exception {
        for(int i = calcualtor.getIndexBegin(); i<calcualtor.getIndexEnd(); i++)
        {
           calcualtor.setSum(calcualtor.getSum()+calcualtor.getArr()[i]);
        }
        return calcualtor.getSum();
    }
}

3、编写测试类

package com.smart.generic;

import sun.nio.ch.ThreadPool;

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 *
 * @author smart 2019/4/6
 */
public class CalculateTest {

    private static int[] arr = new int[100000];
    private static List<Calculate> calculates = new ArrayList<>();

    static {
        for(int i = 0; i < arr.length; i++){
            arr[i] = i;
        }
        for(int i = 0; i<arr.length;i=i+100) {
            Calcualtor calcualtor = new Calcualtor();
            calcualtor.setIndexBegin(i);
            calcualtor.setIndexEnd(i+100);
            calcualtor.setArr(arr);
            calcualtor.setSum(0L);
            Calculate calculate = new Calculate(calcualtor);
            calculates.add(calculate);
        }
    }

    public static void main(String[] args) {

        ExecutorService executorService = Executors.newFixedThreadPool(10);
        try {
            executorService.invokeAll(calculates);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
          //executorService.shutdown();
        }
        ListIterator<Calculate> listIterator = calculates.listIterator();
        int sum  = 0 ;
        while(listIterator.hasNext()){
            sum += listIterator.next().getCalcualtor().getSum();
        }
        System.out.println(sum);
    }
}

疑问：当把计算任务委托给线程池去计算，但是我们并不知道线程池什么时候完成任务，那什么时候关闭线程池？欢迎大佬指正。