多线程，计算List<Integer>

/**
     * 多线程处理list
     *
     * @param data      数据list
     * @param threadNum 线程数
     */
    public static int handleList(List<Integer> data, int threadNum) {
        int length = data.size();
        int tl = length % threadNum == 0 ? length / threadNum : (length
                / threadNum + 1);
        List<Future<Integer>> futureList = new ArrayList<>();

        for (int i = 0; i < threadNum; i++) {
            int end = (i + 1) * tl;
            ExecutorService executorService = Executors.newFixedThreadPool(threadNum);
            Future<Integer> f = executorService.submit(new HandleThread("线程[" + (i + 1) + "] ", data, i * tl, end > length ? length : end));
            futureList.add(f);
        }

        int sum = 0;

        for (int i = 0; i < futureList.size(); i++) {
            try {
                sum = sum + futureList.get(i).get();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        }

        System.out.println(sum);
        return sum;
    }

    static class HandleThread implements Callable<Integer> {
        private String threadName;
        private List<Integer> data;
        private int start;
        private int end;

        public HandleThread(String threadName, List<Integer> data, int start, int end) {
            this.threadName = threadName;
            this.data = data;
            this.start = start;
            this.end = end;
        }

        public Integer call() {
            int sum = 0;
            List<Integer> subList = data.subList(start, end)/*.add("^&*")*/;
            for (int i = 0; i < subList.size(); i++) {
                sum = sum + subList.get(i);
            }
            System.out.println(threadName + "处理了" + subList.size() + "条！");
            return sum;
        }

    }

 

 

 public static void main(String[] args) {
        int ret = new ZtController().exec(Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10), 3);
        System.out.println(ret);
    }

    public int exec(List<Integer> list, int threadNum) {
        int size = list.size();
        int otherNum = size % threadNum;
        int segmentSize = size / threadNum;

        ExecutorService executorService = Executors.newFixedThreadPool(threadNum);
        List<Future> fList = new ArrayList<>();
        int startIndex = 0;
        for (int i = 1; i <= segmentSize; i++) {
            int end;
            if (i == segmentSize) {
                end = startIndex + segmentSize + otherNum;
            } else {
                end = startIndex + segmentSize;
            }
            List<Integer> integers = list.subList(startIndex, end);
            Future submit = executorService.submit(new Exec(integers));
            fList.add(submit);
            startIndex = startIndex + segmentSize;
        }

        int sum = 0;
        try {
            for (int i = 0; i < fList.size(); i++) {
                int i1 = (int) fList.get(i).get();
                sum = sum + i1;
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        executorService.shutdownNow();
        return sum;
    }

    public class Exec implements Callable<Integer> {
        public List<Integer> integers;

        public Exec(List<Integer> integers) {
            this.integers = integers;
        }

        @Override
        public Integer call() {
            int sum = 0;
            for (int i = 0; i < integers.size(); i++) {
                Integer item = integers.get(i);
                sum = sum + item;
            }
            return sum;
        }
    }