為提高處理能力和并發度，Web容器一般會把處理請求的任務放到線程池，而JDK的原生線程池先天適合CPU密集型任務，并不適合我們通常的 I/O 密集任務處理，于是Tomcat改造之。

Tomcat 線程池原理

其實ThreadPoolExecutor的參數主要有如下關鍵點：

• 限制線程個數 

• 限制隊列長度

而Tomcat對這倆資源都需要限制，否則高并發下CPU、內存都有被耗盡可能。因此Tomcat的線程池傳參：

1. // 定制的任務隊列 
2. taskqueue = new TaskQueue(maxQueueSize); 
3.  
4. // 定制的線程工廠 
5. TaskThreadFactory tf = new TaskThreadFactory(namePrefix, 
6.                                daemon, 
7.                                getThreadPriority() 
8. ); 
9.  
10. // 定制線程池 
11. executor = new ThreadPoolExecutor(getMinSpareThreads(), 
12.                   getMaxThreads(), 
13.                      maxIdleTime,  
14.                      TimeUnit.MILLISECONDS, 
15.                      taskqueue, 
16.                      tf); 

Tomcat對線程數也有限制，設置：

• 核心線程數(minSpareThreads)
• 最大線程池數(maxThreads)

Tomcat線程池還有自己的特色任務處理流程，通過重寫execute方法實現了自己的特色任務處理邏輯：

1. 前corePoolSize個任務時，來一個任務就創建一個新線程
2. 再有任務，就把任務放入任務隊列，讓所有線程去搶。若隊列滿，就創建臨時線程
3. 總線程數達到maximumPoolSize，則繼續嘗試把任務放入任務隊列
4. 若緩沖隊列也滿了，插入失敗，執行拒絕策略

和 JDK 線程池的區別就在step3，Tomcat在線程總數達到最大數時，不是立即執行拒絕策略，而是再嘗試向任務隊列添加任務，添加失敗后再執行拒絕策略。

具體又是如何實現的呢?

1. public void execute(Runnable command, long timeout, TimeUnit unit) { 
2.     submittedCount.incrementAndGet(); 
3.     try { 
4.         // 調用JDK原生線程池的execute執行任務 
5.         super.execute(command); 
6.     } catch (RejectedExecutionException rx) { 
7.        // 總線程數達到maximumPoolSize后，JDK原生線程池會執行默認拒絕策略 
8.         if (super.getQueue() instanceof TaskQueue) { 
9.             final TaskQueue queue = (TaskQueue)super.getQueue(); 
10.             try { 
11.                 // 繼續嘗試把任務放入任務隊列 
12.                 if (!queue.force(command, timeout, unit)) { 
13.                     submittedCount.decrementAndGet(); 
14.                     // 若緩沖隊列還是滿了，插入失敗，執行拒絕策略。 
15.                     throw new RejectedExecutionException("..."); 
16.                 } 
17.             }  
18.         } 
19.     } 
20. } 

定制任務隊列

Tomcat線程池的execute方法第一行：

1. submittedCount.incrementAndGet(); 

任務執行失敗，拋異常時，將該計數器減一：

1. submittedCount.decrementAndGet(); 

Tomcat線程池使用 submittedCount 變量維護已提交到線程池，但未執行完的任務數量。

為何要維護這樣一個變量呢?

Tomcat的任務隊列TaskQueue擴展了JDK的LinkedBlockingQueue，Tomcat給了它一個capacity，傳給父類LinkedBlockingQueue的構造器。

1. public class TaskQueue extends LinkedBlockingQueue<Runnable> { 
2.  
3.   public TaskQueue(int capacity) { 
4.       super(capacity); 
5.   } 
6.   ... 
7. } 

capacity參數通過Tomcat的 maxQueueSize 參數設置，但maxQueueSize默認值為Integer.MAX_VALUE：這樣，當前線程數達到核心線程數后，再來的任務，線程池會把任務添加到任務隊列，并且總會成功，就永遠無機會創建新線程了。

為此，TaskQueue重寫了LinkedBlockingQueue#offer，在合適時機返回false，表示任務添加失敗，線程池此時會創建新的線程。

什么叫合適時機?

1. public class TaskQueue extends LinkedBlockingQueue<Runnable> { 
2.  
3.   ... 
4.    @Override 
5.   // 線程池調用任務隊列的方法時，當前線程數 ＞ core線程數 
6.   public boolean offer(Runnable o) { 
7.  
8.       // 若線程數已達max，則不能創建新線程，只能放入任務隊列 
9.       if (parent.getPoolSize() == parent.getMaximumPoolSize())  
10.           return super.offer(o); 
11.            
12.       // 至此，表明 max線程數 > 當前線程數 ＞ core線程數 
13.       // 說明可創建新線程： 
14.        
15.       // 1. 若已提交任務數 ＜ 當前線程數 
16.       //    表明還有空閑線程，無需創建新線程 
17.       if (parent.getSubmittedCount()<=(parent.getPoolSize()))  
18.           return super.offer(o); 
19.            
20.       // 2. 若已提交任務數 ＞ 當前線程數 
21.       //    線程不夠用了，返回false去創建新線程 
22.       if (parent.getPoolSize()<parent.getMaximumPoolSize())  
23.           return false; 
24.            
25.       // 默認情況下總是把任務放入任務隊列 
26.       return super.offer(o); 
27.   } 
28.    
29. } 

所以Tomcat維護 已提交任務數 是為了在任務隊列長度無限時，讓線程池還能有機會創建新線程。

原文鏈接：https://mp.weixin.qq.com/s/7MOOhnI5qsoi8uAihLXy7A