2. 程式人生 > >執行緒池的優雅關閉實踐

執行緒池的優雅關閉實踐

阿新 • • 發佈：2018-12-10

原文：https://www.jianshu.com/p/bdf06e2c1541

平時開發中，大家更多的關注的是執行緒池的建立、任務的提交和執行。往往會忽略執行緒池的關閉，甚至忘記呼叫shutdown()方法，導致記憶體溢位。大多知道需要呼叫shutdown()關閉執行緒池，也少研究其真正的關閉過程。

首先看原始碼中的一句註釋：

A pool that is no longer referenced in a program and has no remaining threads will be shutdown automatically.
如果程式中不再持有執行緒池的引用，並且執行緒池中沒有執行緒時，執行緒池將會自動關閉。

執行緒池自動關閉的兩個條件：1、執行緒池的引用不可達；2、執行緒池中沒有執行緒；

這裡對於條件2解釋一下，執行緒池中沒有執行緒是指執行緒池中的所有執行緒都已執行完自動消亡。然而我們常用的FixedThreadPool的核心執行緒沒有超時策略，所以並不會自動關閉。

展示兩種不同執行緒池 不關閉 的情況：

1、FixedThreadPool 示例

public static void main(String[] args) {
    while(true) {
        ExecutorService executorService = Executors.newFixedThreadPool(8);
        executorService.execute(() -> System.out.println("running"));
        executorService = null;
    }
}

輸出結果：

running
......
running
Exception in thread "main" java.lang.OutOfMemoryError: unable to create new native thread
    at java.lang.Thread.start0(Native Method)
    at java.lang.Thread.start(Thread.java:714)
    at java.util.concurrent.ThreadPoolExecutor.addWorker(ThreadPoolExecutor.java:950)
    at java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:1357)
    at test.PoolTest.main(PoolTest.java:29)

因為FixedThreadPool的核心執行緒不會自動超時關閉，使用時必須在適當的時候呼叫shutdown()方法。

2、 CachedThreadPool 示例

public static void main(String[] args) {
    while(true) {
        // 預設keepAliveTime為 60s
        ExecutorService executorService = Executors.newCachedThreadPool(); 
        ThreadPoolExecutor threadPoolExecutor = (ThreadPoolExecutor) executorService;
        // 為了更好的模擬，動態修改為1納秒
        threadPoolExecutor.setKeepAliveTime(1, TimeUnit.NANOSECONDS);
        threadPoolExecutor.execute(() -> System.out.println("running"));
    }
}

輸出結果：

running
running
running
running
running
......

CachedThreadPool 的執行緒 keepAliveTime 預設為 60s ，核心執行緒數量為 0 ，所以不會有核心執行緒存活阻止執行緒池自動關閉。 詳見 執行緒池之ThreadPoolExecutor構造 ，為了更快的模擬，構造後將 keepAliveTime 修改為1納秒，相當於執行緒執行完馬上會消亡，所以執行緒池可以被回收。實際開發中，如果CachedThreadPool 確實忘記關閉，在一定時間後是可以被回收的。但仍然建議顯示關閉。

然而，執行緒池關閉的意義不僅僅在於結束執行緒執行，避免記憶體溢位，因為大多使用的場景並非上述示例那樣 朝生夕死。執行緒池一般是持續工作的全域性場景，如資料庫連線池。

本文更多要討論的是當執行緒池呼叫shutdown方法後，會經歷些什麼？思考一下幾個問題：

  1. 是否可以繼續接受新任務？繼續提交新任務會怎樣？
  2. 等待佇列裡的任務是否還會執行？
  3. 正在執行的任務是否會立即中斷？

問題1：是否可以繼續接受新任務？繼續提交新任務會怎樣？

public static void main(String[] args) {
    ThreadPoolExecutor executor = new ThreadPoolExecutor(4, 4, 10, TimeUnit.SECONDS, new LinkedBlockingQueue<>());
    executor.execute(() -> System.out.println("before shutdown"));
    executor.shutdown();
    executor.execute(() -> System.out.println("after shutdown"));
}

輸出結果如下：

before shutdown
Exception in thread "main" java.util.concurrent.RejectedExecutionException: Task PoolTest$$Lambda$2/[email protected] rejected from [email protected][Terminated, pool size = 0, active threads = 0, queued tasks = 0, completed tasks = 1]
    at java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(ThreadPoolExecutor.java:2047)
    at java.util.concurrent.ThreadPoolExecutor.reject(ThreadPoolExecutor.java:823)
    at java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:1369)
    at PoolTest.main(PoolTest.java:12)

當執行緒池關閉後，繼續提交新任務會丟擲異常。這句話也不夠準確，不一定是丟擲異常，而是執行拒絕策略，預設的拒絕策略是丟擲異常。可參見 執行緒池之ThreadPoolExecutor構造 裡面自定義執行緒池的例子，自定義了忽略策略，但被拒絕時並沒有丟擲異常。

問題2：等待佇列裡的任務是否還會執行？

public class WaitqueueTest {
    public static void main(String[] args) {
        BlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<>();
        for(int i = 1; i <= 100 ; i++){
            workQueue.add(new Task(String.valueOf(i)));
        }
        ThreadPoolExecutor executor = new ThreadPoolExecutor(1, 1, 10, TimeUnit.SECONDS, workQueue);
        executor.execute(new Task("0"));
        executor.shutdown();
        System.out.println("workQueue size = " + workQueue.size() + " after shutdown");
    }
    
    static class Task implements Runnable{
        String name;
        
        public Task(String name) {
            this.name = name;
        }
        
        @Override
        public void run() {
            for(int i = 1; i <= 10; i++){
                System.out.println("task " + name + " is running");
            }
            System.out.println("task " + name + " is over");
        }
    }
}

這個demo解釋一下，我們用LinkedBlockingQueue構造了一個執行緒池，線上程池啟動前，我們先將工作佇列填充100個任務，然後執行task 0 後立即shutdown()執行緒池，來驗證執行緒池關閉佇列的任務執行狀態。
輸出結果如下：

......
task 0 is running
task 0 is over
workQueue size = 100 after shutdown //表示執行緒池關閉後，佇列任然有100個任務
task 1 is running
......
task 100 is running
task 100 is over

從結果中我們可以看到，執行緒池雖然關閉，但是佇列中的任務任然繼續執行，所以用 shutdown()方式關閉執行緒池時需要考慮是否是你想要的效果。

如果你希望執行緒池中的等待佇列中的任務不繼續執行，可以使用shutdownNow()方法，將上述程式碼進行調整，如下：

public class WaitqueueTest {
    public static void main(String[] args) {
        BlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<>();
        for(int i = 1; i <= 100 ; i++){
            workQueue.add(new Task(String.valueOf(i)));
        }
        ThreadPoolExecutor executor = new ThreadPoolExecutor(1, 1, 10, TimeUnit.SECONDS, workQueue);
        executor.execute(new Task("0"));
        // shutdownNow有返回值，返回被拋棄的任務list
        List<Runnable> dropList = executor.shutdownNow();
        System.out.println("workQueue size = " + workQueue.size() + " after shutdown");
        System.out.println("dropList size = " + dropList.size());
    }
    
    static class Task implements Runnable{
        String name;
        
        public Task(String name) {
            this.name = name;
        }
        
        @Override
        public void run() {
            for(int i = 1; i <= 10; i++){
                System.out.println("task " + name + " is running");
            }
            System.out.println("task " + name + " is over");
        }
    }
}

輸出結果如下：

task 0 is running
workQueue size = 0 after shutdown
task 0 is running
task 0 is running
task 0 is running
task 0 is running
task 0 is running
task 0 is running
task 0 is running
task 0 is running
task 0 is running
dropList size = 100
task 0 is over

從上述輸出可以看到，只有任務0執行完畢，其他任務都被drop掉了，dropList的size為100。通過dropList我們可以對未處理的任務進行進一步的處理，如log記錄，轉發等；

問題3：正在執行的任務是否會立即中斷？

要驗證這個問題，需要對執行緒的 interrupt 方法有一定了解。

推薦閱讀 ——執行緒中斷機制
關於 interrupt 方法：
首先，一個執行緒不應該由其他執行緒來強制中斷或停止，而是應該由執行緒自己自行停止。
所以，Thread.stop, Thread.suspend, Thread.resume 都已經被廢棄了。
而 Thread.interrupt 的作用其實也不是中斷執行緒，而是「通知執行緒應該中斷了」，具體到底中斷還是繼續執行，應該由被通知的執行緒自己處理。
具體來說，當對一個執行緒，呼叫 interrupt() 時，
① 如果執行緒處於被阻塞狀態（例如處於sleep, wait, join 等狀態），那麼執行緒將立即退出被阻塞狀態，並丟擲一個InterruptedException異常。僅此而已。
② 如果執行緒處於正常活動狀態，那麼會將該執行緒的中斷標誌設定為 true，僅此而已。被設定中斷標誌的執行緒將繼續正常執行，不受影響。
interrupt() 並不能真正的中斷執行緒，需要被呼叫的執行緒自己進行配合才行。也就是說，一個執行緒如果有被中斷的需求，那麼就可以這樣做。
① 在正常執行任務時，經常檢查本執行緒的中斷標誌位，如果被設定了中斷標誌就自行停止執行緒。
② 在呼叫阻塞方法時正確處理InterruptedException異常。（例如，catch異常後就結束執行緒。）

public class InteruptTest {

    public static void main(String[] args) throws InterruptedException {
        ThreadPoolExecutor executor = new ThreadPoolExecutor(1, 1, 10, TimeUnit.SECONDS, new LinkedBlockingQueue<>());
        executor.execute(new Task("0"));
        Thread.sleep(1);
        executor.shutdown();
        System.out.println("executor has been shutdown");
    }

    static class Task implements Runnable {
        String name;

        public Task(String name) {
            this.name = name;
        }

        @Override
        public void run() {
            
            for (int i = 1; i <= 100 && !Thread.interrupted(); i++) {
                Thread.yield();
                System.out.println("task " + name + " is running, round " + i);
            }
            
        }
    }
}

輸出結果如下：

task 0 is running, round 1
task 0 is running, round 2
task 0 is running, round 3
......
task 0 is running, round 28
executor has been shutdown
......
task 0 is running, round 99
task 0 is running, round 100

為了體現在任務執行中打斷，在主執行緒進行短暫 sleep ， task 中 呼叫 Thread.yield() ，出讓時間片。從結果中可以看到，執行緒池被關閉後，正則執行的任務沒有被 interrupt。說明shutdown()方法不會 interrupt 執行中執行緒。再將其改修改為shutdownNow() 後輸出結果如下：

task 0 is running, round 1
task 0 is running, round 2
......
task 0 is running, round 56
task 0 is running, round 57
task 0 is running, round 58
task 0 is running, round 59
executor has been shutdown

修改為shutdownNow() 後，task任務沒有執行完，執行到中間的時候就被 interrupt 後沒有繼續執行了。

總結，想要正確的關閉執行緒池，並不是簡單的呼叫shutdown方法那麼簡單，要考慮到應用場景的需求，如何拒絕新來的請求任務？如何處理等待佇列中的任務？如何處理正在執行的任務？想好這幾個問題，在確定如何優雅而正確的關閉執行緒池。

PS：執行緒被 interrupt 後，需要再run方法中單獨處理 interrupted 狀態，interrupt 更類似一個標誌位，不會直接打斷執行緒的執行。



作者：徐志毅
連結：https://www.jianshu.com/p/bdf06e2c1541
來源：簡書
簡書著作權歸作者所有，任何形式的轉載都請聯絡作者獲得授權並註明出處。

相關推薦

java執行緒池和關閉執行緒池中的執行緒

如果執行緒經常喜歡去new的話是不對的，你需要一個池子管理。 newCachedThreadPool 這個一個帶快取的執行緒池，是個可以無限大的執行緒池，新建的執行緒放倒這個池子裡，當執行緒停掉了的時候，下個個執行緒進來，可以複用這個執行緒。 newFixe

執行緒池的優雅關閉實踐

原文：https://www.jianshu.com/p/bdf06e2c1541 平時開發中，大家更多的關注的是執行緒池的建立、任務的提交和執行。往往會忽略執行緒池的關閉，甚至忘記呼叫shutdown()方法，導致記憶體溢位。大多知道需要呼叫shutdown()關閉執行緒池，也少研究其真正的關

優雅的關閉執行緒池

@PreDestroy public void destory() { try {

優雅關閉執行緒池的方案

![](https://img2020.cnblogs.com/other/2024393/202011/2024393-20201123154303134-2142116595.jpg) * 我們經常在專案中使用的執行緒池，但是是否關心過執行緒池的關閉呢，可能很多時候直接再專案中直接建立執行緒池讓它一直運

SpringBoot使用非同步執行緒池使程式無法關閉

又是一個困擾我在整整一天的難題,到了快23點,終於結束了,雖然很想睡覺,但還是得把它記錄下來.                             

Java執行緒池的理論與實踐

前段時間公司裡有個專案需要進行重構，目標是提高吞吐量和可用性，在這個過程中對原有的執行緒模型和處理邏輯進行了修改，發現有很多基礎的多執行緒的知識已經模糊不清，如底層執行緒的執行情況、現有的執行緒池的策略和邏輯、池中執行緒的健康狀況的監控等，這次重新回顧了一下，其中涉及大量ja

記一次整合spring-amqp後出現執行緒池為正常關閉。導致tomcat無法正常關閉顯示記憶體洩露的問題

起因：因為這幾天閒來無事，所以想著改造下舊專案的訂單自動取消功能，原本是通過定時任務輪詢掃描未支付訂單的，及時性不足並且浪費資料庫io的資源,所以就想用rabbitmq的死信佇列來完成延遲自動取消的功能。於是隨手copy了一段spring-amqp的Java Configur

如何優雅的使用和理解執行緒池

前言 平時接觸過多執行緒開發的童鞋應該都或多或少了解過執行緒池，之前釋出的《阿里巴巴 Java 手冊》裡也有一條： 可見執行緒池的重要性。 簡單來說使用執行緒池有以下幾個目的： 執行緒是稀缺資源，不能頻繁的建立。 解耦作用；執行緒的創建於執行完全分開，方便維護。 應當將其放入一個池子中，可

論如何優雅的自定義ThreadPoolExecutor執行緒池

更好的markDown閱讀體驗可直接訪問我的CSDN部落格：https://blog.csdn.net/u012881584/article/details/85221635 前言 執行緒池想必大家也都用過，JDK的Executors 也自帶一些執行緒池。但是不知道大家有沒有想過，如何才是最優雅的方式去使

dubbo如何關閉一個執行緒池的？

  public static void gracefulShutdown(Executor executor, int timeout) { if (!(executor instanceof ExecutorService) || isShutdown(executor)

關閉執行緒池

關閉執行緒池 程式碼如下： public class ClosePoolTest { public static final Logger LOG = LoggerFactory.getLogger(ClosePoolTest.class); public static

區域性變數Executors建立執行緒池後一定要關閉

參考： http://curious.iteye.com/blog/2298849 網上有很多Executors的例子，但有些寫的非常草率，都只是寫如何建立，但有些沒有附上關閉方法。 Executors作為區域性變數時，建立了執行緒，一定要記得呼叫executor

Java執行緒池關閉2-shutdown和awaitTermination

awaitTermination()是一個阻塞方法。它必須等執行緒池退出後才會結束自身。可以設定阻塞時間。 public class Test { public static void main(String[] args) throws IOException, I

使用執行緒池時候當程式結束時候記得呼叫shutdown關閉執行緒池

在一個方法裡面建立了一個執行緒池，然後做一個分片上傳檔案的任務，有多少個分片就有多少個執行緒使用newSingleThreadExecutor 建立，忘了呼叫shutdown比執行緒池本來以為就算沒關閉也會被垃圾回收，因為執行緒池是方法裡面建立的區域性變數但是非守護執行緒是不

安卓(Android)中如何優雅的 建立/執行 非同步任務/回撥(AsyncTask 、Thread、Job、CallBack、Handler) ？執行緒池(Executor)

How to use? 1、first step: copy the file "ExcuteTaskManager" and "ExcuteTask" to your project 2、second step: init the library in your application or

Linux多執行緒實踐(9) --簡單執行緒池的設計與實現

執行緒池的技術背景   在面向物件程式設計中，建立和銷燬物件是很費時間的，因為建立一個物件要獲取記憶體資源或者其它更多資源。在Java中更是如此，虛擬機器將試圖跟蹤每一個物件，以便能夠在物件銷燬後進行垃圾回收。所以提高服務程式效率的一個手段就是儘可能減少建立和銷燬物件的次數，

執行緒池 多執行緒執行結束後 如何關閉？ ExecutorService的正確關閉方法

前言 最近在使用ExecutorService的時候，對於與ExecutorService相關的概念有些迷糊， 加上本身ExecutorService內部的有些方法名在取名上也容易讓使用者誤解，導致 犯了一些錯誤。在解決的過程中，偶爾看到了日本人寫的一篇文章簡單明瞭

ExecutorService 關閉 and 如何判斷執行緒池中任務執行完畢

ExecutorService 關閉1、shutdown 2、shutdownNow 3、awaitTermination當你使用ExecutorService的時候，你應該記得關閉它，這樣這些被管理的執行緒才會停止執行。舉例：如果你的應用通過main()方法啟動，並且你的

一文教你安全的關閉執行緒池

上篇文章 ShutdownHook- Java 優雅停機解決方案 提到應用停機時需要釋放資源，關閉連線。對於一些定時任務或者網路請求服務將會使用執行緒池，當應用停機時需要正確安全的關閉執行緒池，如果處理不當，可能造成資料丟失，業務請求結果不正確等問題。 關閉執行緒池我們可以選擇什麼都不做，JVM 關閉時自

執行緒(一)——執行緒，執行緒池，Task概念+程式碼實踐

# 執行緒(一)——執行緒，執行緒池，Task概念+程式碼實踐 [toc] ## 摘要 執行緒中的概念很多，如果沒有程式碼示例來理解，會比較晦澀，而且有些概念落不到實處，因此，本文以一些執行示例程式碼，結果來闡述執行緒中的一些基礎概念。讓自己跟讀者一起把執行緒中的概念理解地更深刻。 ## 1 執行緒安