java多线程list批量操作并且带有返回值

业务场景：需要操作多个list并且返回数据（而且需要一一对应）

	private static ExecutorService executor = Executors.newCachedThreadPool();
	@RequestMapping("/getUseLast")
	@ResponseBody
	public List<Map<String,Object>> getUseLast(String users,final Integer shop_id){
		if(StringUtils.isEmpty(users)){
			return null;
		}
		final String[] us = users.split(",");
		List<Map<String,Object>> rem = new ArrayList<Map<String,Object>>();
		
		List<Callable<Map<String, Object>>> tasks = new ArrayList<Callable<Map<String, Object>>>();
		Callable<Map<String, Object>> task = null;
		
		for (int i = 0; i < us.length; i++) {
			final int ii = i;
			 task = new Callable<Map<String, Object>>() {
			 		@Override
			 		public Map<String, Object> call() throws Exception{
			 			Map<String, Object> res = new HashMap<String,Object>();
			 			try {
							res = customerBuyFrequencyService.getUseLast(us[ii],shop_id);
						} catch (Exception e) {
							e.printStackTrace();
							res.put("last", "");
							res.put("last2", "");
							res.put("last3", "");
							res.put("interval", "");
							res.put("slast", "");
							res.put("slast2", "");
							res.put("slast3", "");
							res.put("sinterval", "");
						}
						return res;
			 		}
			 	};
			 	tasks.add(task);	
		}
		try {
			List<Future<Map<String, Object>>> results = executor.invokeAll(tasks);
			for (int i = 0; i < results.size(); i++) {
					rem.add(results.get(i).get());
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		executor.shutdown();
		
		return rem;
	}

以上代码：前端传过来一个用户组，需要计算每个用户的信息，正常操作我们可以直接循环操作然后返回，但是如果每个用户计算时间过长，那么前端总体响应时间也略长。例如：每个用户计算1s，10个用户得10s，前端响应时间10s+。所以这里可以使用
ExecutorService 批量线程任务，每个用户是一个task，用Callable带返回值Future，整个批量任务返回结果就是一个Future类型的List,这里注意的是最终返回的结果顺序就是刚开始新建task的顺序，所以可以一一对应上。

到这里位置已经达到我们最初的要求了。
———————————————————————————————————————————————————————
扩展

public static void main(String[] args) throws Exception {

        // 开始时间
        long start = System.currentTimeMillis();
        List<String> list = new ArrayList<String>();

        for (int i = 1; i <= 3000; i++) {
            list.add(i + "");
        }
        // 每500条数据开启一条线程
        int threadSize = 500;
        // 总数据条数
        int dataSize = list.size();
        // 线程数
        int threadNum = dataSize / threadSize + 1;
        // 定义标记,过滤threadNum为整数
        boolean special = dataSize % threadSize == 0;

        // 创建一个线程池
        ExecutorService exec = Executors.newFixedThreadPool(threadNum);
        // 定义一个任务集合
        List<Callable<Integer>> tasks = new ArrayList<Callable<Integer>>();
        Callable<Integer> task = null;
        List<String> cutList = null;

        // 确定每条线程的数据
        for (int i = 0; i < threadNum; i++) {
            if (i == threadNum - 1) {
                if (special) {
                    break;
                }
                cutList = list.subList(threadSize * i, dataSize);
            } else {
                cutList = list.subList(threadSize * i, threadSize * (i + 1));
            }
            // System.out.println("第" + (i + 1) + "组：" + cutList.toString());
            final List<String> listStr = cutList;
            task = new Callable<Integer>() {

                @Override
                public Integer call() throws Exception {
                    System.out.println(Thread.currentThread().getName() + "线程：" + listStr);
                    return 1;
                }
            };
            // 这里提交的任务容器列表和返回的Future列表存在顺序对应的关系
            tasks.add(task);
        }

        List<Future<Integer>> results = exec.invokeAll(tasks);

        for (Future<Integer> future : results) {
            System.out.println(future.get());
        }

        // 关闭线程池
        exec.shutdown();
        System.out.println("线程任务执行结束");
        System.err.println("执行任务消耗了 ：" + (System.currentTimeMillis() - start) + "毫秒");
    }

这里是网上copy的一个方法切割list对每个小list进行多线程操作，以后可能会用上，这里记录下。

除了invokeAll(tasks),还有个invokeAll(tasks, timeout, unit)，两者都会堵塞，必须等待所有的线程任务执行完成后程序才能继续往下执行，当程序执行到 executorService.invokeAll(tasks)时多线程就开始执行了，所以可能会在这阻塞一段时间，等里面的多个线程任务执行完成才继续向下执行（但是循环的list的任务是异步的，例如：本来list每个执行时间5s，list循环10次得50s多，现在只需要5s），第二种方法（invokeAll(tasks, timeout, unit)）有个超时时间，针对的是这个整个tasks任务的时间，如果超时了没有执行完的任务会被直接中断，并抛出异常。
说到阻塞题再举一个示例：

		ExecutorService executor = Executors.newCachedThreadPool();
        Future<String> future = executor.submit(new Callable<String>(){
			@Override
			public String call() throws Exception {
				System.out.println("running task");
	            Thread.sleep(5000);
	            return "return task";
			}
        });
        System.out.println(222222); //可以写一些其它逻辑
        try {
            System.out.println(future.get());  
        } catch (Exception e) {} finally {
            executor.shutdown();
        }
		System.out.println(11111);

这是单个任务带返回值的异步，之前的方法是批量提交tasks用的是invokeAll，在调用executorService.invokeAll就开始阻塞，而上述是submit调用方式，这时程序可能产生阻塞的地方在future.get()，所以可以在调用future.get()之前写一些其它逻辑代码，如果将future.get()写在上述代码System.out.println(222222);之前那么这段代码异步就没有意义了。为什么说可能产生阻塞：多线程程序实际上是在submit时候开始执行了，你接着执行下面的逻辑代码，如果你其它逻辑代码执行完毕，但是多线程的那个任务还没执行完毕，那么get()时候当然要等待他执行完毕啦。