ThreadPoolExecutor

newknight發表於2022-03-07
thread

ThreadPoolExecutor機制 
一、概述 
1、ThreadPoolExecutor作為java.util.concurrent包對外提供基礎實現，以內部執行緒池的形式對外提供管理任務執行，執行緒排程，執行緒池管理等等服務； 
2、Executors方法提供的執行緒服務，都是通過引數設定來實現不同的執行緒池機制。 
3、先來了解其執行緒池管理的機制，有助於正確使用，避免錯誤使用導致嚴重故障。同時可以根據自己的需求實現自己的執行緒池 

二、核心構造方法講解 
下面是ThreadPoolExecutor最核心的構造方法 

Java程式碼  收藏程式碼
  1. public ThreadPoolExecutor(int corePoolSize,  
  2.                               int maximumPoolSize,  
  3.                               long keepAliveTime,  
  4.                               TimeUnit unit,  
  5.                               BlockingQueue<Runnable> workQueue,  
  6.                               ThreadFactory threadFactory,  
  7.                               RejectedExecutionHandler handler) {  
  8.         if (corePoolSize < 0 ||  
  9.             maximumPoolSize <= 0 ||  
  10.             maximumPoolSize < corePoolSize ||  
  11.             keepAliveTime < 0)  
  12.             throw new IllegalArgumentException();  
  13.         if (workQueue == null || threadFactory == null || handler == null)  
  14.             throw new NullPointerException();  
  15.         this.corePoolSize = corePoolSize;  
  16.         this.maximumPoolSize = maximumPoolSize;  
  17.         this.workQueue = workQueue;  
  18.         this.keepAliveTime = unit.toNanos(keepAliveTime);  
  19.         this.threadFactory = threadFactory;  
  20.         this.handler = handler;  
  21.     }  


構造方法引數講解 

引數名 作用
corePoolSize 核心執行緒池大小
maximumPoolSize 最大執行緒池大小
keepAliveTime 執行緒池中超過corePoolSize數目的空閒執行緒最大存活時間；可以allowCoreThreadTimeOut(true)使得核心執行緒有效時間
TimeUnit keepAliveTime時間單位
workQueue 阻塞任務佇列
threadFactory 新建執行緒工廠
RejectedExecutionHandler 當提交任務數超過maxmumPoolSize+workQueue之和時，任務會交給RejectedExecutionHandler來處理



重點講解： 
其中比較容易讓人誤解的是：corePoolSize，maximumPoolSize，workQueue之間關係。 

1.當執行緒池小於corePoolSize時，新提交任務將建立一個新執行緒執行任務，即使此時執行緒池中存在空閒執行緒。 
2.當執行緒池達到corePoolSize時，新提交任務將被放入workQueue中，等待執行緒池中任務排程執行 
3.當workQueue已滿，且maximumPoolSize>corePoolSize時，新提交任務會建立新執行緒執行任務 
4.當提交任務數超過maximumPoolSize時，新提交任務由RejectedExecutionHandler處理 
5.當執行緒池中超過corePoolSize執行緒，空閒時間達到keepAliveTime時，關閉空閒執行緒 
6.當設定allowCoreThreadTimeOut(true)時，執行緒池中corePoolSize執行緒空閒時間達到keepAliveTime也將關閉 

執行緒管理機制圖示： 


三、Executors提供的執行緒池配置方案 

1、構造一個固定執行緒數目的執行緒池，配置的corePoolSize與maximumPoolSize大小相同，同時使用了一個無界LinkedBlockingQueue存放阻塞任務，因此多餘的任務將存在再阻塞佇列，不會由RejectedExecutionHandler處理 

Java程式碼  收藏程式碼
  1. public static ExecutorService newFixedThreadPool(int nThreads) {  
  2.         return new ThreadPoolExecutor(nThreads, nThreads,  
  3.                                       0L, TimeUnit.MILLISECONDS,  
  4.                                       new LinkedBlockingQueue<Runnable>());  
  5.     }  


2、構造一個緩衝功能的執行緒池，配置corePoolSize=0，maximumPoolSize=Integer.MAX_VALUE，keepAliveTime=60s,以及一個無容量的阻塞佇列 SynchronousQueue，因此任務提交之後，將會建立新的執行緒執行；執行緒空閒超過60s將會銷燬 

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


3、構造一個只支援一個執行緒的執行緒池，配置corePoolSize=maximumPoolSize=1，無界阻塞佇列LinkedBlockingQueue；保證任務由一個執行緒序列執行 

Java程式碼  收藏程式碼
  1. public static ExecutorService newSingleThreadExecutor() {  
  2.         return new FinalizableDelegatedExecutorService  
  3.             (new ThreadPoolExecutor(1, 1,  
  4.                                     0L, TimeUnit.MILLISECONDS,  
  5.                                     new LinkedBlockingQueue<Runnable>()));  
  6.     }  


4、構造有定時功能的執行緒池，配置corePoolSize，無界延遲阻塞佇列DelayedWorkQueue；有意思的是：maximumPoolSize=Integer.MAX_VALUE，由於DelayedWorkQueue是無界佇列，所以這個值是沒有意義的 

Java程式碼  收藏程式碼
  1. public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {  
  2.         return new ScheduledThreadPoolExecutor(corePoolSize);  
  3.     }  
  4.   
  5. public static ScheduledExecutorService newScheduledThreadPool(  
  6.             int corePoolSize, ThreadFactory threadFactory) {  
  7.         return new ScheduledThreadPoolExecutor(corePoolSize, threadFactory);  
  8.     }  
  9.   
  10. public ScheduledThreadPoolExecutor(int corePoolSize,  
  11.                              ThreadFactory threadFactory) {  
  12.         super(corePoolSize, Integer.MAX_VALUE, 0, TimeUnit.NANOSECONDS,  
  13.               new DelayedWorkQueue(), threadFactory);  
  14.     }  



四、定製屬於自己的非阻塞執行緒池 

Java程式碼  收藏程式碼
  1. import java.util.concurrent.ArrayBlockingQueue;  
  2. import java.util.concurrent.ExecutorService;  
  3. import java.util.concurrent.RejectedExecutionHandler;  
  4. import java.util.concurrent.ThreadFactory;  
  5. import java.util.concurrent.ThreadPoolExecutor;  
  6. import java.util.concurrent.TimeUnit;  
  7. import java.util.concurrent.atomic.AtomicInteger;  
  8.   
  9.   
  10. public class CustomThreadPoolExecutor {  
  11.   
  12.       
  13.     private ThreadPoolExecutor pool = null;  
  14.       
  15.       
  16.     /** 
  17.      * 執行緒池初始化方法 
  18.      *  
  19.      * corePoolSize 核心執行緒池大小----10 
  20.      * maximumPoolSize 最大執行緒池大小----30 
  21.      * keepAliveTime 執行緒池中超過corePoolSize數目的空閒執行緒最大存活時間----30+單位TimeUnit 
  22.      * TimeUnit keepAliveTime時間單位----TimeUnit.MINUTES 
  23.      * workQueue 阻塞佇列----new ArrayBlockingQueue<Runnable>(10)====10容量的阻塞佇列 
  24.      * threadFactory 新建執行緒工廠----new CustomThreadFactory()====定製的執行緒工廠 
  25.      * rejectedExecutionHandler 當提交任務數超過maxmumPoolSize+workQueue之和時, 
  26.      *                          即當提交第41個任務時(前面執行緒都沒有執行完,此測試方法中用sleep(100)), 
  27.      *                                任務會交給RejectedExecutionHandler來處理 
  28.      */  
  29.     public void init() {  
  30.         pool = new ThreadPoolExecutor(  
  31.                 10,  
  32.                 30,  
  33.                 30,  
  34.                 TimeUnit.MINUTES,  
  35.                 new ArrayBlockingQueue<Runnable>(10),  
  36.                 new CustomThreadFactory(),  
  37.                 new CustomRejectedExecutionHandler());  
  38.     }  
  39.   
  40.       
  41.     public void destory() {  
  42.         if(pool != null) {  
  43.             pool.shutdownNow();  
  44.         }  
  45.     }  
  46.       
  47.       
  48.     public ExecutorService getCustomThreadPoolExecutor() {  
  49.         return this.pool;  
  50.     }  
  51.       
  52.     private class CustomThreadFactory implements ThreadFactory {  
  53.   
  54.         private AtomicInteger count = new AtomicInteger(0);  
  55.           
  56.         @Override  
  57.         public Thread newThread(Runnable r) {  
  58.             Thread t = new Thread(r);  
  59.             String threadName = CustomThreadPoolExecutor.class.getSimpleName() + count.addAndGet(1);  
  60.             System.out.println(threadName);  
  61.             t.setName(threadName);  
  62.             return t;  
  63.         }  
  64.     }  
  65.       
  66.       
  67.     private class CustomRejectedExecutionHandler implements RejectedExecutionHandler {  
  68.   
  69.         @Override  
  70.         public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {  
  71.             // 記錄異常  
  72.             // 報警處理等  
  73.             System.out.println("error.............");  
  74.         }  
  75.     }  
  76.       
  77.       
  78.       
  79.     // 測試構造的執行緒池  
  80.     public static void main(String[] args) {  
  81.         CustomThreadPoolExecutor exec = new CustomThreadPoolExecutor();  
  82.         // 1.初始化  
  83.         exec.init();  
  84.           
  85.         ExecutorService pool = exec.getCustomThreadPoolExecutor();  
  86.         for(int i=1; i<100; i++) {  
  87.             System.out.println("提交第" + i + "個任務!");  
  88.             pool.execute(new Runnable() {  
  89.                 @Override  
  90.                 public void run() {  
  91.                     try {  
  92.                         Thread.sleep(3000);  
  93.                     } catch (InterruptedException e) {  
  94.                         e.printStackTrace();  
  95.                     }  
  96.                     System.out.println("running=====");  
  97.                 }  
  98.             });  
  99.         }  
  100.           
  101.           
  102.           
  103.         // 2.銷燬----此處不能銷燬,因為任務沒有提交執行完,如果銷燬執行緒池,任務也就無法執行了  
  104.         // exec.destory();  
  105.           
  106.         try {  
  107.             Thread.sleep(10000);  
  108.         } catch (InterruptedException e) {  
  109.             e.printStackTrace();  
  110.         }  
  111.     }  
  112. }  


方法中建立一個核心執行緒數為30個，緩衝佇列有10個的執行緒池。每個執行緒任務，執行時會先睡眠3秒，保證提交10任務時，執行緒數目被佔用完，再提交30任務時，阻塞佇列被佔用完，，這樣提交第41個任務是，會交給CustomRejectedExecutionHandler 異常處理類來處理。 

提交任務的程式碼如下： 

Java程式碼  收藏程式碼
  1. public void execute(Runnable command) {  
  2.         if (command == null)  
  3.             throw new NullPointerException();  
  4.         /* 
  5.          * Proceed in 3 steps: 
  6.          * 
  7.          * 1. If fewer than corePoolSize threads are running, try to 
  8.          * start a new thread with the given command as its first 
  9.          * task.  The call to addWorker atomically checks runState and 
  10.          * workerCount, and so prevents false alarms that would add 
  11.          * threads when it shouldn't, by returning false. 
  12.          * 
  13.          * 2. If a task can be successfully queued, then we still need 
  14.          * to double-check whether we should have added a thread 
  15.          * (because existing ones died since last checking) or that 
  16.          * the pool shut down since entry into this method. So we 
  17.          * recheck state and if necessary roll back the enqueuing if 
  18.          * stopped, or start a new thread if there are none. 
  19.          * 
  20.          * 3. If we cannot queue task, then we try to add a new 
  21.          * thread.  If it fails, we know we are shut down or saturated 
  22.          * and so reject the task. 
  23.          */  
  24.         int c = ctl.get();  
  25.         if (workerCountOf(c) < corePoolSize) {  
  26.             if (addWorker(command, true))  
  27.                 return;  
  28.             c = ctl.get();  
  29.         }  
  30.         if (isRunning(c) && workQueue.offer(command)) {  
  31.             int recheck = ctl.get();  
  32.             if (! isRunning(recheck) && remove(command))  
  33.                 reject(command);  
  34.             else if (workerCountOf(recheck) == 0)  
  35.                 addWorker(null, false);  
  36.         }  
  37.         else if (!addWorker(command, false))  
  38.             reject(command);  
  39.     }  


注意：41以後提交的任務就不能正常處理了，因為，execute中提交到任務佇列是用的offer方法，如上面程式碼，這個方法是非阻塞的，所以就會交給CustomRejectedExecutionHandler 來處理，所以對於大資料量的任務來說，這種執行緒池，如果不設定佇列長度會OOM，設定佇列長度，會有任務得不到處理，接下來我們構建一個阻塞的自定義執行緒池 

五、定製屬於自己的阻塞執行緒池 

Java程式碼  收藏程式碼
  1. package com.tongbanjie.trade.test.commons;  
  2.   
  3. import java.util.concurrent.ArrayBlockingQueue;  
  4. import java.util.concurrent.ExecutorService;  
  5. import java.util.concurrent.RejectedExecutionHandler;  
  6. import java.util.concurrent.ThreadFactory;  
  7. import java.util.concurrent.ThreadPoolExecutor;  
  8. import java.util.concurrent.TimeUnit;  
  9. import java.util.concurrent.atomic.AtomicInteger;  
  10.   
  11. public class CustomThreadPoolExecutor {    
  12.         
  13.         
  14.     private ThreadPoolExecutor pool = null;    
  15.         
  16.         
  17.     /**  
  18.      * 執行緒池初始化方法  
  19.      *   
  20.      * corePoolSize 核心執行緒池大小----1  
  21.      * maximumPoolSize 最大執行緒池大小----3  
  22.      * keepAliveTime 執行緒池中超過corePoolSize數目的空閒執行緒最大存活時間----30+單位TimeUnit  
  23.      * TimeUnit keepAliveTime時間單位----TimeUnit.MINUTES  
  24.      * workQueue 阻塞佇列----new ArrayBlockingQueue<Runnable>(5)====5容量的阻塞佇列  
  25.      * threadFactory 新建執行緒工廠----new CustomThreadFactory()====定製的執行緒工廠  
  26.      * rejectedExecutionHandler 當提交任務數超過maxmumPoolSize+workQueue之和時,  
  27.      *                          即當提交第41個任務時(前面執行緒都沒有執行完,此測試方法中用sleep(100)),  
  28.      *                                任務會交給RejectedExecutionHandler來處理  
  29.      */    
  30.     public void init() {    
  31.         pool = new ThreadPoolExecutor(    
  32.                 1,    
  33.                 3,    
  34.                 30,    
  35.                 TimeUnit.MINUTES,    
  36.                 new ArrayBlockingQueue<Runnable>(5),    
  37.                 new CustomThreadFactory(),    
  38.                 new CustomRejectedExecutionHandler());    
  39.     }    
  40.     
  41.         
  42.     public void destory() {    
  43.         if(pool != null) {    
  44.             pool.shutdownNow();    
  45.         }    
  46.     }    
  47.         
  48.         
  49.     public ExecutorService getCustomThreadPoolExecutor() {    
  50.         return this.pool;    
  51.     }    
  52.         
  53.     private class CustomThreadFactory implements ThreadFactory {    
  54.     
  55.         private AtomicInteger count = new AtomicInteger(0);    
  56.             
  57.         @Override    
  58.         public Thread newThread(Runnable r) {    
  59.             Thread t = new Thread(r);    
  60.             String threadName = CustomThreadPoolExecutor.class.getSimpleName() + count.addAndGet(1);    
  61.             System.out.println(threadName);    
  62.             t.setName(threadName);    
  63.             return t;    
  64.         }    
  65.     }    
  66.         
  67.         
  68.     private class CustomRejectedExecutionHandler implements RejectedExecutionHandler {    
  69.     
  70.         @Override    
  71.         public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {    
  72.             try {  
  73.                                 // 核心改造點，由blockingqueue的offer改成put阻塞方法  
  74.                 executor.getQueue().put(r);  
  75.             } catch (InterruptedException e) {  
  76.                 e.printStackTrace();  
  77.             }  
  78.         }    
  79.     }    
  80.         
  81.         
  82.         
  83.     // 測試構造的執行緒池    
  84.     public static void main(String[] args) {    
  85.           
  86.         CustomThreadPoolExecutor exec = new CustomThreadPoolExecutor();    
  87.         // 1.初始化    
  88.         exec.init();    
  89.             
  90.         ExecutorService pool = exec.getCustomThreadPoolExecutor();    
  91.         for(int i=1; i<100; i++) {    
  92.             System.out.println("提交第" + i + "個任務!");    
  93.             pool.execute(new Runnable() {    
  94.                 @Override    
  95.                 public void run() {    
  96.                     try {    
  97.                         System.out.println(">>>task is running=====");   
  98.                         TimeUnit.SECONDS.sleep(10);  
  99.                     } catch (InterruptedException e) {    
  100.                         e.printStackTrace();    
  101.                     }    
  102.                 }    
  103.             });    
  104.         }    
  105.             
  106.             
  107.         // 2.銷燬----此處不能銷燬,因為任務沒有提交執行完,如果銷燬執行緒池,任務也就無法執行了    
  108.         // exec.destory();    
  109.             
  110.         try {    
  111.             Thread.sleep(10000);    
  112.         } catch (InterruptedException e) {    
  113.             e.printStackTrace();    
  114.         }    
  115.     }    
  116. }    



解釋：當提交任務被拒絕時，進入拒絕機制，我們實現拒絕方法，把任務重新用阻塞提交方法put提交，實現阻塞提交任務功能，防止佇列過大，OOM，提交被拒絕方法在下面 

   

Java程式碼  收藏程式碼
  1. public void execute(Runnable command) {  
  2.         if (command == null)  
  3.             throw new NullPointerException();  
  4.   
  5.         int c = ctl.get();  
  6.         if (workerCountOf(c) < corePoolSize) {  
  7.             if (addWorker(command, true))  
  8.                 return;  
  9.             c = ctl.get();  
  10.         }  
  11.         if (isRunning(c) && workQueue.offer(command)) {  
  12.             int recheck = ctl.get();  
  13.             if (! isRunning(recheck) && remove(command))  
  14.                 reject(command);  
  15.             else if (workerCountOf(recheck) == 0)  
  16.                 addWorker(null, false);  
  17.         }  
  18.         else if (!addWorker(command, false))  
  19.             // 進入拒絕機制， 我們把runnable任務拿出來，重新用阻塞操作put，來實現提交阻塞功能  
  20.             reject(command);  
  21.     }  




總結： 
1、用ThreadPoolExecutor自定義執行緒池，看執行緒是的用途，如果任務量不大，可以用無界佇列，如果任務量非常大，要用有界佇列，防止OOM 
2、如果任務量很大，還要求每個任務都處理成功，要對提交的任務進行阻塞提交，重寫拒絕機制，改為阻塞提交。保證不拋棄一個任務 
3、最大執行緒數一般設為2N+1最好，N是CPU核數 
4、核心執行緒數，看應用，如果是任務，一天跑一次，設定為0，合適，因為跑完就停掉了，如果是常用執行緒池，看任務量，是保留一個核心還是幾個核心執行緒數 
5、如果要獲取任務執行結果，用CompletionService，但是注意，獲取任務的結果的要重新開一個執行緒獲取，如果在主執行緒獲取，就要等任務都提交後才獲取，就會阻塞大量任務結果，佇列過大OOM，所以最好非同步開個執行緒獲取結果

相關文章