当前位置:   article > 正文

关闭Java线程池的正确方法_java 关闭线程池

java 关闭线程池

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();
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

}
看看控制台的输出,发现在打印到 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();
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

}
控制台输出如下,:

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.
  • 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() 后 继续添加任务,这里预期是抛出异常
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

}
这个例子我们主要观察两个现象。

一个是线程池会有两个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.
  • This method does not wait for actively executing tasks to

  • terminate. Use {@link #awaitTermination awaitTermination} to
  • do that.
  • 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 shutdownNow() {
    List 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 drainQueue() {
    BlockingQueue q = workQueue;
    ArrayList taskList = new ArrayList();
    q.drainTo(taskList);
    if (!q.isEmpty()) {
    for (Runnable r : q.toArray(new Runnable[0])) {
    if (q.remove®)
    taskList.add®;
    }
    }
    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() 后 继续添加任务,这里预期是抛出异常
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

}
这个例子我们主要观察三个现象。 一个是线程池有两个woker,所以当调用shutdownNow() 方法,走进 interruptWorkers() 的时候,所有的 woker 都会调用 t.interrupt()。

图片
第二个是 shutdownNow() 方法会返回还没来得及执行的task,并打印出来。

第三个是调用 shutdownNow() 方法后,再调用 execute() 时,会抛出异常,因为线程池的状态已经置为 STOP,不再接受新的任务添加

图片
5实战,与 JVM 钩子配合
实际工作中,我们一般是使用 shutdown() 方法,因为它比较“温和”,会等待我们把线程池中的任务都执行完,这里也已 shutdown() 方法为例。

我们回到最开头聊到的那个 case,机器重新发布,但是线程池中还有没执行完任务,机器一关,这些任务全部被kill,怎么办呢?有什么机制能够阻塞一下,等待这个任务执行完再关闭吗?

有的,用 JVM 的钩子!(深入了解 JVM 钩子可以再看看这篇博文:扫盲 JVM 安全退出机制:shutdownHook,signalHandler[1])

实例代码如下,一个线程池,提交了三个任务去执行,执行完得半分钟。然后增加一个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);
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

}
在机器上执行,会发现,我使用 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();
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31

// 遍历所有的响应头字段
// 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 的钩子,才算优雅的关闭线程池。

声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/知新_RL/article/detail/1004182
推荐阅读
相关标签
  

闽ICP备14008679号