ExecutorService线程池

通过线程池开启多线程，并发执行任务。

新建任务类，实现 Callable 接口，参数通过构造方法传入。通过 executor 的 submit() 方法进行执行。

如果需要获取执行的返回结果，可以创建 FutureTask 对象，将任务类传入，调用 get() 方法获取执行结果，这个方法会阻塞程序，待获得返回值后才继续执行。

通常需要等待所有线程执行完毕才进行后续操作，调用 executor 的 shutdown() 方法，该线程池不会再继续接受任务，之前接受的任务会继续执行，

可以通过自身的 isTerminated() 方法判断是否全部执行完毕，或者 awaitTermination() 方法进行判断，或者 FutureTask 的 get() 方法。

public class MyExecutor {

    private static ExecutorService executorService = Executors.newFixedThreadPool(3);
    private static ExecutorService executorService2 = Executors.newFixedThreadPool(3);

    static class MyTask implements Callable<Boolean> {

        private String taskID;

        public MyTask(String taskID) {
            this.taskID = taskID;
        }

        @Override
        public Boolean call() throws Exception {
            if (taskID.equals("10")) {
                System.out.println("第十次执行出错！");
                throw new RuntimeException("抛出运行时异常！");
            }
            System.out.println(Thread.currentThread().getName());
            System.out.println("taskID :" + taskID);
            Thread.sleep(1000);
            return true;
        }
    }

    static class MyTaskUUID implements Callable<String> {

        private int str;

        public MyTaskUUID(int str) {
            this.str = str;
        }

        @Override
        public String call() throws Exception {
            String result = UUID.randomUUID().toString().replace("-", "");
            Thread.sleep(1000);
            System.out.println("MyTaskUUID第" + str + "次执行~");
            return result + str * 100;
        }
    }

    private static void testExecutors() {
        for (int i = 0; i < 15; i++) {
            if (i % 2 == 0) {
                executorService.submit(new MyTask(String.valueOf(i)));
                System.out.println("偶数线程池执行~");
            } else {
                executorService2.submit(new MyTask(String.valueOf(i)));
                System.out.println("奇数线程池执行~");
            }
            System.out.println(i);
        }
        executorService.shutdown();
        executorService2.shutdown();
        try {
            executorService.awaitTermination(1, TimeUnit.HOURS);
            System.out.println("偶数线程执行完毕~");
        } catch (InterruptedException e) {
            System.out.println(e.getMessage());
        }
        while (true) {
            if (executorService2.isTerminated()) {
                System.out.println("奇数线程池执行完毕~");
                break;
            }
        }
    }

    private static void testFutureTask() {
        Map<String, FutureTask<String>> map = new HashMap<>();
        for (int i = 0; i < 15; i++) {
            FutureTask<String> task = new FutureTask<>(new MyTaskUUID(i));
            map.put(String.valueOf(i), task);
            executorService.submit(task);
            System.out.println(i);
        }
        executorService.shutdown();
        while (true) {
            if (executorService.isTerminated()) {
                break;
            }
        }
        HashMap<String, String> resMap = new HashMap<>();
        for (String key : map.keySet()) {
            try {
                resMap.put(key, map.get(key).get());
            } catch (Exception e) {
                System.out.println(e.getMessage());
            }
        }
        System.out.println(resMap);
    }

    public static void main(String[] args) {
        testExecutors();
        testFutureTask();
        System.out.println("over~~");
    }
}