Executors并行执行

在实际的业务当中有可能会有一些情况出现多个方法调用的情况但是他们又互不相干，因此可以通过一些稍微的改造让他们并行的执行，也就是说让方法同时执行，这样就有可能会提高执行的效率，减少等待时间：特别是当同步和异步的接口出现在同一个方法当中时最为明显。

一下是示例代码：

ExecutorService executorService = Executors.newFixedThreadPool(2);
        try {
            // 使用Callable任务
            Callable<Map<String, Object>> taskDaHua = () -> {
                Map<String, Object> taskDaHuaresult = new HashMap<>();
                taskDaHuaresult.put("status", 1);
                if (type.equals("1")) {
//换成自己的实现方法
                    Map<String, Object> map = DaHuaAddElc(account, password,userCode);
                    if (!"1".equals(map.get("status"))) {
                        taskDaHuaresult.put("status", 2);
                    }
                    return taskDaHuaresult;
                }
                Map<String, Object> map = addMeterDaHua(account, password,userCode);
                if (!"1".equals(map.get("status"))) {
                    taskDaHuaresult.put("status", 2); // 失败
                }
                return taskDaHuaresult;
            };
            Callable<Map<String, Object>> taskRenMin = () -> {
                Map<String, Object> taskRenMinresult = new HashMap<>();
//换成自己的实现方法
                sendEcl(pid, acesskey);
                taskRenMinresult.put("status", 1);
                return taskRenMinresult;
            };
            // 提交Callable任务，并获取Future对象
            Future<Map<String, Object>> futureResultTaskDaHua = executorService.submit(taskDaHua);
            Future<Map<String, Object>> futureResultTaskRenMin = executorService.submit(taskRenMin);

            // 等待任务完成，并获取结果
            Map<String, Object> maps = futureResultTaskDaHua.get();
            Map<String, Object> map = futureResultTaskRenMin.get();
            if (maps.get("status").equals("2")&&map.get("status").equals("2")){
                return map;
            }
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        } finally {
            executorService.shutdown();
        }

我这个地方是提取的业务当中的一部分代码。

可以看出，我这个地方利用的是Callable去实现的，它是具有返回值的，因此可以将我们调用方法的结果返回出来。其中标注的地方可以换为自己的实现方法以及逻辑等。在任务执行完后就会将结果返回到future当中，然后通过.get()去获取到返回的结果。

注：先执行完的任务不会结束方法，而是等待其他任务结束后再执行后面逻辑。

       在执行.get()去获取到返回的结果的时候，该任务就会停止执行，但是不会影响其他任务的执行。

       最后一定需要关闭线程池，关闭线程池可以释放线程池所占用的资源，防止内存泄漏，并确保应用程序能够优雅地结束。

1. 关闭线程池：调用 shutdown() 方法，这将阻止线程池接受新任务，但允许当前正在执行的任务完成。

   
   executor.shutdown();
   
   

2. 等待线程池关闭：调用 awaitTermination() 方法，这将等待直到所有的任务都完成，或者等待了指定的时间。如果等待超时，线程池将尝试停止正在执行的任务。

   try { executor.awaitTermination(Long.MAX_VALUE, TimeUnit.NANOSECONDS); } catch (InterruptedException e) { // 处理中断异常 }

当然除了利用Callable 去实现的方式还可以利用Future的方式去执行，但是这种方法是没有返回值的。

Future<?> future = executor.submit(() -> {
    // 任务代码
});