我正在参加「启航方案」

1. 布景

某年某月某日，和我的卧龙搭档聊一个需求，说是有个数据查询的功用，由于涉及到多个第三方接口调用，想用线程池并行来做。

很正常的一个方案，可是上线后发现，每次服务发布的时分，这个数据查询的功用就会挂掉，后来发现是线程池没有做好封闭，这儿总结一下。

关键字：线程池；shutdown；shutdownNow；interrupt

2. 线程中止 interrupt

先补一补根底的常识：线程中止。

线程中止的意义，并不是强制把运转中的线程给“咔嚓”中止，而是把线程的中止标志方位为true，这样等线程之后堵塞（wait、join、sleep）的时分，就会抛出 InterruptedException，程序通过捕获 InterruptedException 来做必定的善后处理，然后让线程退出。

来看个比如，下面这段代码是起一个线程，打印一百行文本，打印进程中，会把线程的中止标志方位为true

public static void test02() throws InterruptedException {
    Thread t = new Thread(() -> {
    for (int i = 0; i < 100; i++) {
        System.out.println("process i=" + i + "，interrupted：" + Thread.currentThread().isInterrupted());
    }
    });
    t.start();
    Thread.sleep(1);
    t.interrupt();
}

看看控制台的输出，发现在打印到 57 的时分，中止标志位现已成功置为true了，可是线程任然在打印，阐明仅仅设置了中止标志位，而不是直接粗暴的把线程中止。

…

process i=55，interrupted：false

process i=56，interrupted：false

process i=57，interrupted：true

process i=58，interrupted：true

process i=59，interrupted：true

…

再看看这个示例，同样是打印一百行文本，打印进程中会判别中止标志位，假如中止就自行退出。

public static void test02() throws InterruptedException {
    Thread t = new Thread(() -> {
    for (int i = 0; i < 100; i++) {
        if (Thread.interrupted()) {
            System.out.println("线程已中止，退出履行");
            break;
        }
        System.out.println("process i=" + i + "，interrupted：" + Thread.currentThread().isInterrupted());
    }
    });
    t.start();
    Thread.sleep(1);
    t.interrupt();
}

控制台输出如下，：

process i=49，interrupted：false

process i=50，interrupted：false

process i=51，interrupted：false

线程已中止，退出履行

3. 线程池的封闭 shutdown 办法

了解完线程中止，再来看看线程池的封闭办法。

封闭线程池有两个办法 shutdown() 和 shutdownNow()，具体有什么区别？咱们先来看看 shutdown() 办法

    /**
     * Initiates an orderly shutdown in which previously submitted
     * tasks are executed, but no new tasks will be accepted.
     * Invocation has no additional effect if already shut down.
     *
     * <p>This method does not wait for previously submitted tasks to
     * complete execution.  Use {@link #awaitTermination awaitTermination}
     * to do that.
     *
     * @throws SecurityException {@inheritDoc}
     */
    public void shutdown() {
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            checkShutdownAccess();
            advanceRunState(SHUTDOWN); // 1. 把线程池的状况设置为 SHUTDOWN
            interruptIdleWorkers(); // 2. 把闲暇的作业线程置为中止
            onShutdown(); // 3. 一个空完成，暂不用重视
        } finally {
            mainLock.unlock();
        }
        tryTerminate();
    }

看源码先看注释，我用我英语四级的超高水准水平翻译下：

发动有序封闭会履行以前提交的使命，但不承受任何新使命。

假如现已封闭，则调用不会产生额外的影响。

此办法不等候活动履行的使命停止。假如需要，可运用 awaitTermination() 做到这一点。

3.1 第一步：advanceRunState(SHUTDOWN) 把线程池置为 SHUTDOWN

线程池状况流通如下。调用 shutdown() 办法会把线程池的状况置为 SHUTDOWN，后续再往线程池提交使命就会被拒绝（execute() 办法中做了判别）。

3.2 第二步：interruptIdleWorkers() 把闲暇的作业线程置为中止

interruptIdleWorkers() 办法遍历一切的作业线程，假如 tryLock() 成功，就把线程置为中止。

这儿，假如 tryLock() 成功，阐明对应的 woker 是一个闲暇的，没有在履行使命的线程，假如没成功，阐明对应的 worker 正在履行使命。也便是说，这儿的中止，对正在履行中的使命并没有影响。

    private void interruptIdleWorkers(boolean onlyOne) {
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            for (Worker w : workers) {
                Thread t = w.thread;
                if (!t.isInterrupted() && w.tryLock()) {
                    try {
                        t.interrupt();
                    } catch (SecurityException ignore) {
                    } finally {
                        w.unlock();
                    }
                }
                if (onlyOne)
                    break;
            }
        } finally {
            mainLock.unlock();
        }
    }

3.3 第三步：onShutdown() 一个空完成，暂不用重视

这个没啥，便是个留空的办法。

3.4 总结

shutdown() 办法干两件事：

把线程池状况置为 SHUTDOWN 状况
中止闲暇线程

咱们来看个比如，加深下形象。

    public static void test01() throws InterruptedException {
        // corePoolSize 是 2，maximumPoolSize 是 2
        ThreadPoolExecutor es = new ThreadPoolExecutor(2, 2,
                60L, TimeUnit.SECONDS,
                new LinkedBlockingQueue<>());
        es.prestartAllCoreThreads(); // 发动一切 worker
        es.execute(new Task()); // Task是一个访问某网站的 HTTP 恳求，跑的慢，后面会贴出来完好代码，这儿把他作为一个跑的慢的异步使命就行
        es.shutdown();
        es.execute(new Task()); // 在线程池 shutdown() 后 持续增加使命，这儿预期是抛出异常
    }

这个比如咱们首要观察两个现象。

一个是线程池会有两个woker（ prestartAllCoreThreads() 办法的调用使得已发动就有两个 worker），其中一个正在履行，一个处于闲暇。所以当调用shutdown() 办法，走进 interruptIdleWorkers() 的时分，只有那个闲暇的线程会调用 t.interrupt()。

第二个是调用 shutdown() 办法后，再调用 execute() 时，会抛出异常，由于线程池的状况现已置为 SHUTDOWN，不再承受新的使命增加进来。

4. 线程池的封闭 shutdownNow 方式

    /**
     * Attempts to stop all actively executing tasks, halts the
     * processing of waiting tasks, and returns a list of the tasks
     * that were awaiting execution. These tasks are drained (removed)
     * from the task queue upon return from this method.
     *
     * <p>This method does not wait for actively executing tasks to
     * terminate.  Use {@link #awaitTermination awaitTermination} to
     * do that.
     *
     * <p>There are no guarantees beyond best-effort attempts to stop
     * processing actively executing tasks.  This implementation
     * cancels tasks via {@link Thread#interrupt}, so any task that
     * fails to respond to interrupts may never terminate.
     *
     * @throws SecurityException {@inheritDoc}
     */
    public List<Runnable> shutdownNow() {
        List<Runnable> tasks;
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            checkShutdownAccess();
            advanceRunState(STOP); // 1：把线程池设置为STOP
            interruptWorkers(); // 2.中止作业线程
            tasks = drainQueue(); // 3.把线程池中的使命都 drain 出来
        } finally {
            mainLock.unlock();
        }
        tryTerminate();
        return tasks;
    }

注释的意思是：

测验中止一切正在履行的使命，暂停正在等候的使命的处理，并回来等候履行的使命列表。从该办法回来时，这些使命将从使命队列中清空(移除)。

此办法不等候活动履行的使命停止。假如需要，可运用 awaitTermination() 做到这一点。

除了尽最大努力测验中止处理主动履行的使命之外，没有其他确保。

此完成通过 Thread.Interrupt() 取消使命，因而任何无法呼应中止的使命都可能永久不会停止。

4.1 第一步：advanceRunState() 把线程池设置为STOP

和 shutdown() 办法不同的是，shutdownNow() 办法会把线程池的状况设置为 STOP。

4.2 第二步：interruptWorkers() 中止作业线程

interruptWorkers() 如下，能够看到，和 shutdown() 办法不同的是，一切的作业线程都调用了 interrupt() 办法

    /**
     * Interrupts all threads, even if active. Ignores SecurityExceptions
     * (in which case some threads may remain uninterrupted).
     */
    private void interruptWorkers() {
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            for (Worker w : workers)
                w.interruptIfStarted();
        } finally {
            mainLock.unlock();
        }
    }

4.3 第三步：drainQueue() 把线程池中的使命都 drain 出来

drainQueue() 办法如下，把堵塞队列里边等候的使命都拿出来，并回来。封闭线程池的时分，能够根据这个特性，把回来的使命都打印出来，做个记录。

    /**
     * Drains the task queue into a new list, normally using
     * drainTo. But if the queue is a DelayQueue or any other kind of
     * queue for which poll or drainTo may fail to remove some
     * elements, it deletes them one by one.
     */
    private List<Runnable> drainQueue() {
        BlockingQueue<Runnable> q = workQueue;
        ArrayList<Runnable> taskList = new ArrayList<Runnable>();
        q.drainTo(taskList);
        if (!q.isEmpty()) {
            for (Runnable r : q.toArray(new Runnable[0])) {
                if (q.remove(r))
                    taskList.add(r);
            }
        }
        return taskList;
    }

4.4 总结

shutdownNow() 办法干三件事：

把线程池状况置为 STOP 状况
中止作业线程
把线程池中的使命都 drain 出来并回来

咱们来看个比如，代码合刚才的相同，仅仅封闭线程用的是shutdownNow()

    public static void test01() throws InterruptedException {
        // corePoolSize 是 1，maximumPoolSize 是 1，无限容量
        ThreadPoolExecutor es = new ThreadPoolExecutor(1, 1,
                60L, TimeUnit.SECONDS,
                new LinkedBlockingQueue<>());
        es.prestartAllCoreThreads(); // 发动一切 worker
        es.execute(new Task()); // Task是一个访问某网站的 HTTP 恳求，跑的慢，后面会贴出来完好代码，这儿把他作为一个跑的慢的异步使命就行
        es.execute(new Task());
        List<Runnable> result = es.shutdownNow();
        System.out.println(result);
        es.execute(new Task()); // 在线程池 shutdownNow() 后 持续增加使命，这儿预期是抛出异常
    }

这个比如咱们首要观察三个现象。一个是线程池有两个woker，所以当调用shutdownNow() 办法，走进 interruptWorkers() 的时分，一切的 woker 都会调用 t.interrupt()。

第二个是 shutdownNow() 办法会回来还没来得及履行的task，并打印出来。

第三个是调用 shutdownNow() 办法后，再调用 execute() 时，会抛出异常，由于线程池的状况现已置为 STOP，不再承受新的使命增加

5. 实战，与 JVM 钩子合作

实际作业中，咱们一般是运用 shutdown() 办法，由于它比较“温和”，会等候咱们把线程池中的使命都履行完，这儿也已 shutdown() 办法为例。

咱们回到最最初聊到的那个 case，机器从头发布，可是线程池中还有没履行完使命，机器一关，这些使命悉数被kill，怎么办呢？有什么机制能够堵塞一下，等候这个使命履行完再封闭吗？

有的，用 JVM 的钩子！（深入了解 JVM 钩子能够再看看这篇博文：扫盲 JVM 安全退出机制：shutdownHook，signalHandler）

实例代码如下，一个线程池，提交了三个使命去履行，履行完得半分钟。然后增加一个JVM的钩子，这个钩子能够简单理解为监听器，注册后，JVM在封闭的时分就会调用这个办法，调用完才会正式封闭JVM。

    public static void test01() throws InterruptedException {
        ThreadPoolExecutor es = new ThreadPoolExecutor(1, 1,
                60L, TimeUnit.SECONDS,
                new LinkedBlockingQueue<>());
        es.execute(new Task());
        es.execute(new Task());
        es.execute(new Task());
        Thread shutdownHook = new Thread(() -> {
            es.shutdown();
            try {
                es.awaitTermination(3, TimeUnit.MINUTES);
            } catch (InterruptedException e) {
                e.printStackTrace();
                System.out.println("等候超时，直接封闭");
            }
        });
        Runtime.getRuntime().addShutdownHook(shutdownHook);
    }

在机器上履行，会发现，我运用 ctrl + c （注意不是ctrl + z ）封闭进程，会发现进程并没有直接封闭，线程池任然履行，一向等到线程池的使命履行完，进程才会正式退出。

怎么样，是不是很神奇。

本文中涉及的 Task 的源码如下。这个使命是对 stackoverflow 网站发起 10 次恳求，用来模仿跑的比较慢的使命，当然这不是要点，能够疏忽，有爱好动手试一下本文代码的同学能够参阅下。

    public static class Task implements Runnable {
        @Override
        public void run() {
            System.out.println("task start");
            for (int i = 0; i < 10; i++) {
                httpGet();
                System.out.println("task execute " + i);
            }
            System.out.println("task finish");
        }
        private void httpGet() {
            String url = "https://stackoverflow.com/";
            String result = "";
            BufferedReader in = null;
            try {
                String urlName = url;
                URL realUrl = new URL(urlName);
                // 打开和URL之间的连接
                URLConnection conn = realUrl.openConnection();
                // 设置通用的恳求特点
                conn.setRequestProperty("accept", "*/*");
                conn.setRequestProperty("connection", "Keep-Alive");
                conn.setRequestProperty("user-agent",
                        "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1)");
                // 建立实际的连接
                conn.connect();
                // 获取一切呼应头字段
                Map<String, List<String>> map = conn.getHeaderFields();
//                 遍历一切的呼应头字段
//                for (String key : map.keySet()) {
//                    System.out.println(key + "--->" + map.get(key));
//                }
                // 定义BufferedReader输入流来读取URL的呼应
                in = new BufferedReader(
                        new InputStreamReader(conn.getInputStream()));
                String line;
                while ((line = in.readLine()) != null) {
                    result += "/n" + line;
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
            // 运用finally块来封闭输入流
            finally {
                try {
                    if (in != null) {
                        in.close();
                    }
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
            }
//            System.out.print(result);
        }
    }

6. 总结

想要高雅的封闭线程池，首先要理解线程中止的意义。

其次，封闭线程池有两种方式：shutdown() 和 shutdownNow()，二者最大的区别是 shutdown() 仅仅把闲暇的 woker 置为中止，不影响正在运转的woker，并且会持续把待履行的使命给处理完。shutdonwNow() 则是把一切的 woker 都置为中止，待履行的使命悉数抽出并回来，日常作业中更多是运用 shutdown()。

最终，单纯的运用 shutdown() 也不靠谱，还得运用 awaitTermination() 和 JVM 的钩子，才算高雅的封闭线程池。

都看到这了，给个赞吧

7. Ref

怎么高雅的封闭Java线程池 www.cnblogs.com/qingquanzi/…
java 线程池状况及状况转换 www.yht7.com/news/188264

如何优雅的关闭线程池

1. 布景

2. 线程中止 interrupt

3. 线程池的封闭 shutdown 办法

3.1 第一步：advanceRunState(SHUTDOWN) 把线程池置为 SHUTDOWN

3.2 第二步：interruptIdleWorkers() 把闲暇的作业线程置为中止

3.3 第三步：onShutdown() 一个空完成，暂不用重视

3.4 总结

4. 线程池的封闭 shutdownNow 方式

4.1 第一步：advanceRunState() 把线程池设置为STOP

4.2 第二步：interruptWorkers() 中止作业线程

4.3 第三步：drainQueue() 把线程池中的使命都 drain 出来

4.4 总结

5. 实战，与 JVM 钩子合作

6. 总结

7. Ref

作者信息

推广

如何优雅的关闭线程池

1. 布景

2. 线程中止 interrupt

3. 线程池的封闭 shutdown 办法

3.1 第一步：advanceRunState(SHUTDOWN) 把线程池置为 SHUTDOWN

3.2 第二步：interruptIdleWorkers() 把闲暇的作业线程置为中止

3.3 第三步：onShutdown() 一个空完成，暂不用重视

3.4 总结

4. 线程池的封闭 shutdownNow 方式

4.1 第一步：advanceRunState() 把线程池设置为STOP

4.2 第二步：interruptWorkers() 中止作业线程

4.3 第三步：drainQueue() 把线程池中的使命都 drain 出来

4.4 总结

5. 实战，与 JVM 钩子合作

6. 总结

7. Ref

相关文章

2小时入门Jetpack Compose（下）

Nginx 体系化之深入探究负载均衡

浅析一下：kotlin委托背后的实现机制

对抗生成网络GAN系列——WGAN原理及实战演练

作者信息

推广