背景

在Java开发中，如果涉及多线程，会经常使用到线程池，本期不额外讲述线程池本身相关的东西。考虑一种场景，如果我们提交给线程池的任务都相对比较耗时，而在任务启动运行后，如果后续有需求的变更，要重新部署业务。
这时，需要关闭当前的执行实例或者重启，如果直接kill实例而任务又包含多个复杂的逻辑，可能导致一些非预期的后果。因此，类似情况下，需要等线程池中已有任务尽量执行完毕，来避免带来意料以外的问题。当然本身的
threadPoolExecutor是带有相关处理机制的，下面就介绍对应方法以及使用。

线程池停止

threadPoolExecutor 提供了两个线程池停止方法shutdown(),shutdownNow()。首先shutdown()将状态转换为shutdown，方法不会阻塞，没有返回值;shutdownNow()将状态转换为stop，方法不会阻塞，返回线程池队列中等待执行的任务列表。如果要等待任务执行完毕，就要和另一个方法配合实现，即awaitTermination()。如下代码，后面做解释说明。

代码

    static ThreadPoolExecutor executorService = new ThreadPoolExecutor(5, 5, 1, TimeUnit.SECONDS, new ArrayBlockingQueue<>(10));
 @Test
    public void executorTest() throws InterruptedException {
    //用来监控线程池的执行状态，注意初始化用ThreadPoolExecutor，非executorService
        Thread t = new Thread(() -> {
            while (true) {
                try {
                    System.out.println(executorService);
                    TimeUnit.SECONDS.sleep(3);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
        t.start();

        //记录执行时间
        long start = System.currentTimeMillis();
        for (int i = 0; i < 10; i++) {
            int x = i;
            CompletableFuture.runAsync(() -> {
                try {
                    System.out.println("running..." + x);
                    if (x == 7) {
                        TimeUnit.SECONDS.sleep(20);
                    }else {
                        TimeUnit.SECONDS.sleep(5);
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }, executorService).toCompletableFuture().whenComplete((aVoid, throwable) -> {
                //每个任务执行完成的需要的时间
                System.out.println(System.currentTimeMillis() - start);
            });
        }

        //执行shutdown
        if (!executorService.isShutdown()) {
            executorService.shutdown();
            System.out.println("start shutdown ...");
            //等待执行结束
            executorService.awaitTermination(2, TimeUnit.MINUTES);
        }
    }

执行结果

java.util.concurrent.ThreadPoolExecutor@1866f339[Running, pool size = 0, active threads = 0, queued tasks = 0, completed tasks = 0]
running...0
running...1
running...2
running...3
running...4
start shutdown ...
java.util.concurrent.ThreadPoolExecutor@1866f339[Shutting down, pool size = 5, active threads = 5, queued tasks = 5, completed tasks = 0]
5003
running...5
5004
5004
5004
running...7
running...6
5004
running...8
running...9
java.util.concurrent.ThreadPoolExecutor@1866f339[Shutting down, pool size = 5, active threads = 5, queued tasks = 0, completed tasks = 5]
java.util.concurrent.ThreadPoolExecutor@1866f339[Shutting down, pool size = 5, active threads = 5, queued tasks = 0, completed tasks = 5]
10003
10005
10005
10005
java.util.concurrent.ThreadPoolExecutor@1866f339[Shutting down, pool size = 1, active threads = 1, queued tasks = 0, completed tasks = 9]
java.util.concurrent.ThreadPoolExecutor@1866f339[Shutting down, pool size = 1, active threads = 1, queued tasks = 0, completed tasks = 9]
java.util.concurrent.ThreadPoolExecutor@1866f339[Shutting down, pool size = 1, active threads = 1, queued tasks = 0, completed tasks = 9]
java.util.concurrent.ThreadPoolExecutor@1866f339[Shutting down, pool size = 1, active threads = 1, queued tasks = 0, completed tasks = 9]
java.util.concurrent.ThreadPoolExecutor@1866f339[Shutting down, pool size = 1, active threads = 1, queued tasks = 0, completed tasks = 9]
25005

解析

这里使用了awaitTermination和shutdown来配合，可以看到最终的执行时间是25s，即一般线程5秒和最长线程20s的和，这里用id=7的为最长，可以实验下，如果改成id=4为最长执行时间，因为4<5，5是核心线程池
数，id=4就属于所有任务前半部分（先提交的部分），所有任务最长执行时间约20s。有人会问，为什么不用shutdownNow，因为shutdownNow会将所有的执行线程设置为interrupt，包括正在活跃的。而shutdown只将空闲等待状态的线程做状态变更，不会影响正在执行的。
可以试验下，如果改成shutdownNow，后续任务是没法执行成功的。其中sleep会被interrupt打断。