2. 程式人生 > >如何優雅的使用和理解線程池----轉

如何優雅的使用和理解線程池----轉

阿新 • • 發佈：2018-10-09
sin rate 但是 監控 spring 所有 [] 裏的 reject

線程池原理

談到線程池就會想到池化技術，其中最核心的思想就是把寶貴的資源放到一個池子中；每次使用都從裏面獲取，用完之後又放回池子供其他人使用，有點吃大鍋飯的意思。

那在 Java 中又是如何實現的呢？

在 JDK 1.5 之後推出了相關的 api，常見的創建線程池方式有以下幾種：

  • Executors.newCachedThreadPool()：無限線程池。
  • Executors.newFixedThreadPool(nThreads)：創建固定大小的線程池。
  • Executors.newSingleThreadExecutor()：創建單個線程的線程池。

其實看這三種方式創建的源碼就會發現：

1
 
 public static ExecutorService newCachedThreadPool() {
2     return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
3                                   60L, TimeUnit.SECONDS,
4                                   new SynchronousQueue<Runnable>());
5 }


所以我們重點來看下 ThreadPoolExecutor 是怎麽玩的。實際上還是利用 ThreadPoolExecutor

類實現的。

首先是創建線程的 api：

1 ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, RejectedExecutionHandler handler)

corePoolSize 為線程池的基本大小。這幾個核心參數的作用：

  • maximumPoolSize 為線程池最大線程大小。
  • keepAliveTime 和 unit 則是線程空閑後的存活時間。
  • workQueue
    用於存放任務的阻塞隊列。
  • handler 當隊列和最大線程池都滿了之後的飽和策略。

了解了這幾個參數再來看看實際的運用。

通常我們都是使用:

1 threadPool.execute(new Job());

在具體分析之前先了解下線程池中所定義的狀態，這些狀態都和線程的執行密切相關：這樣的方式來提交一個任務到線程池中，所以核心的邏輯就是 execute() 函數了。

技術分享圖片

  • RUNNING 自然是運行狀態，指可以接受任務執行隊列裏的任務
  • SHUTDOWN 指調用了 shutdown() 方法，不再接受新任務了，但是隊列裏的任務得執行完畢。
  • STOP 指調用了 shutdownNow() 方法，不再接受新任務，同時拋棄阻塞隊列裏的所有任務並中斷所有正在執行任務。
  • TIDYING 所有任務都執行完畢，在調用 shutdown()/shutdownNow() 中都會嘗試更新為這個狀態。
  • TERMINATED 終止狀態，當執行 terminated() 後會更新為這個狀態。

用圖表示為：

技術分享圖片

然後看看 execute() 方法是如何處理的：

技術分享圖片

  1. 獲取當前線程池的狀態。
  2. 當前線程數量小於 coreSize 時創建一個新的線程運行。
  3. 如果當前線程處於運行狀態，並且寫入阻塞隊列成功。
  4. 雙重檢查，再次獲取線程狀態；如果線程狀態變了（非運行狀態）就需要從阻塞隊列移除任務，並嘗試判斷線程是否全部執行完畢。同時執行拒絕策略。
  5. 如果當前線程池為空就新創建一個線程並執行。
  6. 如果在第三步的判斷為非運行狀態，嘗試新建線程，如果失敗則執行拒絕策略。

這裏借助《聊聊並發》的一張圖來描述這個流程：

技術分享圖片

如何配置線程

流程聊完了再來看看上文提到了幾個核心參數應該如何配置呢？

有一點是肯定的，線程池肯定是不是越大越好。

通常我們是需要根據這批任務執行的性質來確定的。

  • IO 密集型任務：由於線程並不是一直在運行，所以可以盡可能的多配置線程，比如 CPU 個數 * 2
  • CPU 密集型任務（大量復雜的運算）應當分配較少的線程，比如 CPU 個數相當的大小。

當然這些都是經驗值，最好的方式還是根據實際情況測試得出最佳配置。

優雅的關閉線程池

有運行任務自然也有關閉任務，從上文提到的 5 個狀態就能看出如何來關閉線程池。

其實無非就是兩個方法 shutdown()/shutdownNow()。

但他們有著重要的區別：

  • shutdown() 執行後停止接受新任務，會把隊列的任務執行完畢。
  • shutdownNow() 也是停止接受新任務，但會中斷所有的任務，將線程池狀態變為 stop。

兩個方法都會中斷線程，用戶可自行判斷是否需要響應中斷。

shutdownNow() 要更簡單粗暴，可以根據實際場景選擇不同的方法。

我通常是按照以下方式關閉線程池的：

 1 long start = System.currentTimeMillis();
 2 for (int i = 0; i <= 5; i++) {
 3     pool.execute(new Job());
 4 }
 5 pool.shutdown();
 6 while (!pool.awaitTermination(1, TimeUnit.SECONDS)) {
 7     LOGGER.info("線程還在執行。。。");
 8 }
 9 long end = System.currentTimeMillis();
10 LOGGER.info("一共處理了【{}】", (end - start));

pool.awaitTermination(1, TimeUnit.SECONDS) 會每隔一秒鐘檢查一次是否執行完畢（狀態為 TERMINATED），當從 while 循環退出時就表明線程池已經完全終止了。

SpringBoot 使用線程池

2018 年了，SpringBoot 盛行；來看看在 SpringBoot 中應當怎麽配置和使用線程池。

既然用了 SpringBoot ，那自然得發揮 Spring 的特性，所以需要 Spring 來幫我們管理線程池：

 1 @Configuration
 2 public class TreadPoolConfig {
 3     /**
 4      * 消費隊列線程
 5      * @return
 6      */
 7     @Bean(value = "consumerQueueThreadPool")
 8     public ExecutorService buildConsumerQueueThreadPool(){
 9         ThreadFactory namedThreadFactory = new ThreadFactoryBuilder()
10                 .setNameFormat("consumer-queue-thread-%d").build();
11         ExecutorService pool = new ThreadPoolExecutor(5, 5, 0L, TimeUnit.MILLISECONDS,
12                 new ArrayBlockingQueue<Runnable>(5),namedThreadFactory,new ThreadPoolExecutor.AbortPolicy());
13         return pool ;
14     }
15 }

使用時：

1 @Resource(name = "consumerQueueThreadPool")
2 private ExecutorService consumerQueueThreadPool;
3 @Override
4 public void execute() {
5     //消費隊列
6     for (int i = 0; i < 5; i++) {
7         consumerQueueThreadPool.execute(new ConsumerQueueThread());
8     }
9 }

其實也挺簡單，就是創建了一個線程池的 bean，在使用時直接從 Spring 中取出即可。

監控線程池

談到了 SpringBoot，也可利用它 actuator 組件來做線程池的監控。

線程怎麽說都是稀缺資源，對線程池的監控可以知道自己任務執行的狀況、效率等。

關於 actuator 就不再細說了，感興趣的可以看看這篇，有詳細整理過如何暴露監控端點。

其實 ThreadPool 本身已經提供了不少 api 可以獲取線程狀態：

技術分享圖片

很多方法看名字就知道其含義，只需要將這些信息暴露到 SpringBoot 的監控端點中，我們就可以在可視化頁面查看當前的線程池狀態了。

甚至我們可以繼承線程池擴展其中的幾個函數來自定義監控邏輯：

技術分享圖片

技術分享圖片

看這些名稱和定義都知道，這是讓子類來實現的。

可以在線程執行前、後、終止狀態執行自定義邏輯。

線程池隔離

線程池看似很美好，但也會帶來一些問題。

如果我們很多業務都依賴於同一個線程池,當其中一個業務因為各種不可控的原因消耗了所有的線程，導致線程池全部占滿。

這樣其他的業務也就不能正常運轉了，這對系統的打擊是巨大的。

比如我們 Tomcat 接受請求的線程池，假設其中一些響應特別慢，線程資源得不到回收釋放；線程池慢慢被占滿，最壞的情況就是整個應用都不能提供服務。

所以我們需要將線程池進行隔離。

通常的做法是按照業務進行劃分：

比如下單的任務用一個線程池，獲取數據的任務用另一個線程池。這樣即使其中一個出現問題把線程池耗盡，那也不會影響其他的任務運行。

hystrix 隔離

這樣的需求 Hystrix 已經幫我們實現了。

Hystrix 是一款開源的容錯插件，具有依賴隔離、系統容錯降級等功能。

下面來看看 Hystrix 簡單的應用：

首先需要定義兩個線程池，分別用於執行訂單、處理用戶。

 1 /**
 2  * Function:訂單服務
 3  *
 4  * @author crossoverJie
 5  *         Date: 2018/7/28 16:43
 6  * @since JDK 1.8
 7  */
 8 public class CommandOrder extends HystrixCommand<String> {
 9     private final static Logger LOGGER = LoggerFactory.getLogger(CommandOrder.class);
10     private String orderName;
11     public CommandOrder(String orderName) {
12         super(Setter.withGroupKey(
13                 //服務分組
14                 HystrixCommandGroupKey.Factory.asKey("OrderGroup"))
15                 //線程分組
16                 .andThreadPoolKey(HystrixThreadPoolKey.Factory.asKey("OrderPool"))
17                 //線程池配置
18                 .andThreadPoolPropertiesDefaults(HystrixThreadPoolProperties.Setter()
19                         .withCoreSize(10)
20                         .withKeepAliveTimeMinutes(5)
21                         .withMaxQueueSize(10)
22                         .withQueueSizeRejectionThreshold(10000))
23                 .andCommandPropertiesDefaults(
24                         HystrixCommandProperties.Setter()
25                                 .withExecutionIsolationStrategy(HystrixCommandProperties.ExecutionIsolationStrategy.THREAD))
26         )
27         ;
28         this.orderName = orderName;
29     }
30     @Override
31     public String run() throws Exception {
32         LOGGER.info("orderName=[{}]", orderName);
33         TimeUnit.MILLISECONDS.sleep(100);
34         return "OrderName=" + orderName;
35     }
36 }
37 /**
38  * Function:用戶服務
39  *
40  * @author crossoverJie
41  *         Date: 2018/7/28 16:43
42  * @since JDK 1.8
43  */
44 public class CommandUser extends HystrixCommand<String> {
45     private final static Logger LOGGER = LoggerFactory.getLogger(CommandUser.class);
46     private String userName;
47     public CommandUser(String userName) {
48         super(Setter.withGroupKey(
49                 //服務分組
50                 HystrixCommandGroupKey.Factory.asKey("UserGroup"))
51                 //線程分組
52                 .andThreadPoolKey(HystrixThreadPoolKey.Factory.asKey("UserPool"))
53                 //線程池配置
54                 .andThreadPoolPropertiesDefaults(HystrixThreadPoolProperties.Setter()
55                         .withCoreSize(10)
56                         .withKeepAliveTimeMinutes(5)
57                         .withMaxQueueSize(10)
58                         .withQueueSizeRejectionThreshold(10000))
59                 //線程池隔離
60                 .andCommandPropertiesDefaults(
61                         HystrixCommandProperties.Setter()
62                                 .withExecutionIsolationStrategy(HystrixCommandProperties.ExecutionIsolationStrategy.THREAD))
63         )
64         ;
65         this.userName = userName;
66     }
67     @Override
68     public String run() throws Exception {
69         LOGGER.info("userName=[{}]", userName);
70         TimeUnit.MILLISECONDS.sleep(100);
71         return "userName=" + userName;
72     }
73 }

api 特別簡潔易懂，具體詳情請查看官方文檔。

然後模擬運行：

 1 public static void main(String[] args) throws Exception {
 2     CommandOrder commandPhone = new CommandOrder("手機");
 3     CommandOrder command = new CommandOrder("電視");
 4     //阻塞方式執行
 5     String execute = commandPhone.execute();
 6     LOGGER.info("execute=[{}]", execute);
 7     //異步非阻塞方式
 8     Future<String> queue = command.queue();
 9     String value = queue.get(200, TimeUnit.MILLISECONDS);
10     LOGGER.info("value=[{}]", value);
11     CommandUser commandUser = new CommandUser("張三");
12     String name = commandUser.execute();
13     LOGGER.info("name=[{}]", name);
14 }

運行結果：


技術分享圖片

可以看到兩個任務分成了兩個線程池運行，他們之間互不幹擾。

獲取任務任務結果支持同步阻塞和異步非阻塞方式，可自行選擇。

它的實現原理其實容易猜到：

利用一個 Map 來存放不同業務對應的線程池。

通過剛才的構造函數也能證明：

技術分享圖片

還要註意的一點是：

自定義的 Command 並不是一個單例，每次執行需要 new 一個實例，不然會報 This instance can only be executed once. Please instantiate a new instance. 異常。

總結

池化技術確實在平時應用廣泛，熟練掌握能提高不少效率。

原文地址：

https://crossoverjie.top/2018/07/29/java-senior/ThreadPool/

如何優雅的使用和理解線程池----轉

相關推薦

如何優雅的使用和理解線程池----轉

sin rate 但是 監控 spring 所有 [] 裏的 reject 線程池原理 談到線程池就會想到池化技術，其中最核心的思想就是把寶貴的資源放到一個池子中；每次使用都從裏面獲取，用完之後又放回池子供其他人使用，有點吃大鍋飯的意思。 那在 Java 中又是如何實現的呢

如何優雅的使用和理解線程池

cache 但是 發的 kqueue set 最好的 cte 並且 pub 前言 平時接觸過多線程開發的童鞋應該都或多或少了解過線程池，之前發布的《阿裏巴巴 Java 手冊》裏也有一條： 可見線程池的重要性。 簡單來說使用線程池有以下幾個目的：

java和spring 線程池總結

一段 getname span 只有一個 [] 觸發 sts time execute 1. spring 的線程池 ThreadPoolTaskExecutor @Configuration public class ThreadPoolConfig {

Unity主線程和子線程跳轉調用（2)

date har body edit 繼續 clas turn lec 任務 　　在上一篇介紹了多線程和Unity交互方式，但是由於我的項目是一個unity編輯器插件項目，很顯然上一篇的代碼需要加以修改，在編輯器下實現Loom. 　　1，Editor下的沒有Update這個

如何使用加拿大28源碼下載理解線程池

出現 command 提交 任務任務 ise ndt shutdown pri 很多 平時接觸過加拿大28源碼下載【dashengba.com】Q3266397597多線程開發的童鞋應該都或多或少了解過線程池，之前發布的《阿裏巴巴 Java 手冊》裏也有一條：可見線程池的重

python創建一個線程和一個線程池

lex targe read pytho imp submit int exe ren 創建一個線程 1.示例代碼 import time import threading def task(arg): time.sleep(2) while True: n

Java線程池關閉1-shutdown和isTerminated<轉>

ride shu csdn nat err interrupt .net fin cat shutdownvoid shutdown()啟動一次順序關閉，執行以前提交的任務，但不接受新任務。若已經關閉，則調用沒有其他作用。拋出：SecurityException - 如果安

記錄一次線程池的在項目中的實際應用，講解一下線程池的配置和參數理解。

div pro 繼續 bstr warn fin autowire string ping 前言：最近項目中與融360項目中接口對接，有反饋接口（也就是我們接收到請求，需要立即響應，並且還要有一個接口推送給他們其他計算結果），推送過程耗時、或者說兩個接口不能是同時返回，有先

深入理解線程和線程池

https 了解 locking actor 核心線程 分享圖片 即使 card 深入 關於線程和線程池的學習，我們可以從以下幾個方面入手： 第一，什麽是線程，線程和進程的區別是什麽 第二，線程中的基本概念，線程的生命周期 第三，單線程和多線程 第四，線程池的原理解

線程池：對ThreadPoolExecutor的理解和源碼探索

cep star 等待 啟動 running 占用 效率 tee 創建線程 對線程池的理解 在沒有引入線程池之前，如果去創建多線程，就會出現這幾種情況：第一，創建現場本身就占用CPU資源，給CPU帶來壓力；第二，線程本身也要占用內存空間，大量的線程會占用內存資源並且可能會

轉：【Java並發編程】之十九：並發新特性—Executor框架與線程池（含代碼）

接口類 容易 20px 了解 大小 執行c 生命周期 schedule p s Executor框架簡介 在Java 5之後，並發編程引入了一堆新的啟動、調度和管理線程的API。Executor框架便是Java 5中引入的，其內部使用了線程池機制，它在java.

ThreadPoolExecutor線程池的分析和使用

pro rep interrupt rup bsp roc 停止 可用 method 1. 引言 合理利用線程池能夠帶來三個好處。 第一：降低資源消耗。通過重復利用已創建的線程降低線程創建和銷毀造成的消耗。 第二：提高響應速度。當任務到達時，任務可以不需要等到線程創建就能立

線程池 概念理解

data clas rejected 更新 dal amp 定時 btn 服務 轉 Java線程池解析 作者

Java線程池的分析和使用

服務器 dex man nan generate att width 微秒 cpu 1. 引言 合理利用線程池能夠帶來三個好處。第一：降低資源消耗。通過重復利用已創建的線程降低線程創建和銷毀造成的消耗。第二：提高響應速度。當任務到達 時，任務可以不需要的等到線程創建就

線程池和任務

pool call public 異常 token 操作系統 null deb gets 線程池 線程池基礎 創建線程和銷毀線程是一個昂貴的操作，要耗費大量的時間。由於操作系統必須調度可運行的線程並執行上線文切換，所以太多的線程還對性能不利。

深入理解Java之線程池

我們 先進先出 tor cor null 討論 等於 影響 log 重要連接：http://www.cnblogs.com/dolphin0520/p/3958019.html 出處：http://www.cnblogs.com/dolphin0520/　　　　 本文歸作者

Android的線程和線程池

ccf pos 在線 bst 網絡請求 四大 ask ron 底層 1、背景 Android中，線程分為主線程和子線程

12.深入線程池_流程和原理

thread 帶來 discard 分享 取消 fixed 由於 ref epo 參考博文：http://blog.csdn.net/mark_lq/article/details/50346999 一、線程池的基本類結構 　　合理利用線程池能夠帶來三個好處。 　　1.降低

AsyncTask、HandlerThread、IntentService和線程池

ssa 輸入參數 異步操作 出現 ams tro run rri 百分比 AsyncTask 　　AsyncTask 是一種輕量級的異步任務類，可以在線程池中執行後臺任務，然後把執行的進度和最終結果傳遞給主線程用於更新UI。 可以直接繼承AsyncTask,在類中實現異步操

線程和線程池的使用

ren 參考 oid 工作 adp pre 定義 ++ edt 參考：http://www.cnblogs.com/dolphin0520/p/3932921.html 1、線程：循環新建10個線程 註意：final定義的變量才能在run()方法裏使用 pack