一、任務與執行策略間的隱形耦合

1、執行緒飢餓死鎖

當任務都是同類、獨立的時候，執行緒池才會有最好的工作表現。如果將耗時的短期的任務混合在一起，除非執行緒池很大，否則會有“塞車”的風險；如果提交的任務要依賴其他的任務，除非池是無限的，否則有產生死鎖的風險。如下程式碼所示，對於一個單執行緒化的Executor，一個任務將另一個任務提交到相同的Executor中，並等待新提交的任務的結果，第二個任務滯留在工作佇列中，直到第一個任務完成，但是第一個任務在等待第一個任務完成，這就引發了死鎖。在一個大的執行緒池中，如果所有執行緒執行的任務都阻塞線上程池中，等待著仍處於同一佇列中的其他任務，也會發生死鎖。

class TheadDeadlock{
	ExecutorService exec = Executors.newSingleThreadExecutor();
	class RenderPageTask implements Callable<String>{
		public String call() {
			Future<String> header,footer;
			header = exec.submit(new LoadFileTask("header.html"));
			footer = exec.submit(new LoadFileTask("footer.html"));
			String page = renderBody();
			return header.get() + page + footer.get();
		}
	}
}
 

2、耗時操作

如果任務由於過長的時間週期而阻塞，那麼即使不可能出現死鎖，執行緒池的響應性也會變得很差。耗時任務會造成執行緒池堵塞，還會延長服務時間。可以限定任務等待資源的時間來緩解耗時操作帶來的影響。

二、定製執行緒池的大小

執行緒池過大：執行緒對稀缺的CPU和記憶體資源的競爭，會導致記憶體的高使用量，還可能耗盡資源。

執行緒池過小：由於存在很多可用的處理器資源卻未在工作，會對吞吐量造成損失。

如果有不同類別的任務，他們擁有差別很大的行為，那麼要使用多個執行緒池，這樣每個執行緒池可以根據不同任務的工作負載進行調節。

對於計算密集型的任務，一個有N個處理器的系統通常使用N+1個執行緒的執行緒池來獲得最優的利用率。

對於包含了I/O和其他阻塞操作的任務，不是所有的執行緒都會在所有的時間被排程，因此需要一個更大的執行緒池。

給定下列定義：

N = CPU的數量

U = 目標CPU的使用率，0 <= U <= 1

W/C = 等待時間與計算時間的比率

為保持處理器達到期望的使用率，最優的池的大小等於

Num = N * U * （1 + W/C）

可以通過Runtime.getRuntime().availableProcessors();來獲得CPU的數目

CPU週期並不是唯一可以約束資源池大小的資源，其他還有：記憶體、檔案控制代碼、套接字控制代碼和資料庫連線等。計算這些型別資源池的大小：首先累加每一個任務需要的這些資源的總量，然後除以可用的總量，所得結果是池大小的上限。

三、配置ThreadPoolExecutor

1、執行緒的建立與銷燬

核心池大小：即執行緒池的實現試圖維護的池的大小，即使沒有任務執行，池的大小也等於核心池的大小，並且直到工作佇列充滿前，池都不會建立更多的執行緒。

最大池的大小：可同時活動的執行緒數的上限

存活時間：如果一個執行緒已經閒置的時間超過了存活時間，它將成為一個被回收的候選者，如果池的大小超過了核心池的大小，執行緒池會終止它。

newFixedThreadPool工廠為請求的池設定了核心池的大小和最大池的大小，而且存活時間是無限的

newCachedThreadPool工廠將最大池的大小設定為Integer.MAX_VALUE，核心池的大小設定為0，超時設定為1分鐘

2、管理佇列任務

當新請求到達的頻率超過了執行緒池能夠處理它們的速度，這些多出來的請求會在一個由Executor管理的Runnable佇列中等候。

ThreadPoolExecutor允許使用一個BlockingQueue來持有等待執行的任務。任務排隊有3種基本方法：無限佇列、有限佇列和同步移交。

newFixedThreadPool和newSingleThreadExecutor預設使用的是一個無限的LinkedBlockingQueue。如果執行緒池中的所有執行緒都處於忙碌狀態，任務將會在佇列中等候。如果等候的任務超出了佇列的長度，佇列也會無限制地增加。

newCachedThreadPool使用SynchronousQueue，將任務直接從生產者移交給工作者執行緒。為了把一個元素放入到SynchronousQueue中，必須有另一個執行緒正在等待接受移交的任務。如果沒有這樣一個執行緒，只要當前池的大小還小於最大值，ThreadPoolExecutor就會建立一個新的執行緒；否則根據飽和策略，任務會被拒絕。只有當池是無限的，或者可以接受任務被拒絕，SynchronousQueue才是一個好的選擇。

另外，使用有限佇列比如ArrayBlockingQueue或者有限的LinkedBlockingQueue以及PriorityBlockingQueue有助於避免資源耗盡的情況發生，但是它又引入了新問題：當佇列已滿後，新的任務怎麼辦？有很多飽和策略可以處理這個問題。對於一個有界佇列，佇列的長度與吃的長度必須一起調節。一個大佇列加一個小池，可以控制對記憶體和CPU的使用，還可以減少上下文切換。

當任務彼此獨立時，有限執行緒池或者有限工作佇列的使用是合理的。倘若任務之間相互依賴，有限的執行緒池或佇列就可能引起執行緒飢餓死鎖，就要使用一個無限的池配置。

3、飽和策略

當有限的等待佇列填滿後，飽和策略開始起作用。ThreadPoolExecutor的飽和策略可以通過呼叫setRejectedExecutionHandler來修改。JDK提供了幾種不同的RejectedExecutionHandler的實現：

（1）AbortPolicy：預設的“中止”策略會引起execute丟擲未檢查的RejectedExecutionException，呼叫者可以捕獲這個異常，然後編寫能滿足自己需求的處理程式碼。

（2）DiscardPolicy：“遺棄”策略會放棄這個任務

（3）DiscardOldestPolicy：“遺棄最舊的”策略選擇丟棄的任務是本應該接下來就執行的任務，然後嘗試重新提交新任務。如果工作佇列是優先順序佇列，那麼它選擇丟棄的是優先順序最高的任務，所以優先順序佇列和“遺棄最舊的”策略不能一塊使用

（4）CallerRunsPolicy：“呼叫者執行”策略會把一下任務推回到呼叫者那裡，以此減緩新任務流。當所有執行緒都被佔用，工作佇列已充滿後，下一個任務會在主執行緒中執行。主執行緒呼叫execute執行這個任務。因為這將花費一些時間，所以主執行緒在一段時間內不能提交任何任務。同時這也給了工作者執行緒時間來追趕進度。這期間主執行緒也不會呼叫accept，所以外來的請求不會出現在應用程式中，而會在TCP層的佇列中等候。如果持續高負載的話，最終會由TCP層判斷它的連線請求佇列是否已經排滿，如果已滿就開始丟棄請求任務。

（5）使用Semaphore來遏制任務的提交，使用一個非受限佇列，設定Semaphore的限制範圍等於池的大小加上你希望允許可排隊的任務數量。如下程式碼所示：

class BoundedExecutor{
	private final Executor exec;
	private final Semaphore semaphore;
	public BoundedExecutor(Executor exec,int bound){
		this.exec = exec;
		this.semaphore = new Semaphore(bound);
	}
	public void submitTask(final Runnable task) throws InterruptedException{
		semaphore.acquire();
		try {
			exec.execute(new Runnable() {
				@Override
				public void run() {
					// TODO Auto-generated method stub
					try{
						task.run();
					}finally{
						semaphore.release();
					}
				}
			});
		} catch (RejectedExecutionException e) {
			// TODO Auto-generated catch block
			semaphore.release();
		}
	}
}

四、擴充套件ThreadPoolExecutor

ThreadPoolExecutor提供了幾個函式讓子類去覆寫：beforeExecute、afterExecute和terminate。執行任務的執行緒會呼叫函式beforeExecute、afterExecute，用於新增日誌、時序、監視器或統計資訊收集的功能。無論任務是正常從run返回，還是丟擲一個異常，afterExecute都會被呼叫。如果beforeExecute丟擲一個RuntimeException，任務將不被執行，afterExecute也不會被呼叫。但所有的任務都已完成且所有工作者執行緒也已經關閉後，會執行terminate，terminate可以用來釋放Executor在生命週期裡分配到的資源，還可以發出通知、記錄日誌或者完成統計資訊。如下程式碼可以使用這三個函式提供日誌和計時功能

class TimingThreadPool extends ThreadPoolExecutor{
	private final ThreadLocal<Long> startTime = new ThreadLocal<Long>();
	private final Logger log = Logger.getLogger("TimingThreadPool");
	private final AtomicLong numTasks = new AtomicLong();
	private final AtomicLong totalTime = new AtomicLong();
	
	protected void beforeExecute(Thread t,Runnable r){
		super.beforeExecute(t,r);
		log.fine(String.format("Thread %s: start %s",t,r));
		startTime.set(System.nanoTime());
	}
	protected void afterExecute(Runnable r,Throwable t){
		try{
			long endTime = System.nanoTime();
			long taskTime = endTime - startTime.get();
			numTasks.incrementAndGet();
			totalTime.addAndGet(taskTime);
			log.fine(String.format("Thread %s: end %s, time=%dns",t,r,taskTime));
		}finally{
			super.afterExecute(r,t);
		}
	}
	protected void terminated(){
		try{
			log.info(String.format("Terminated: time=%dns",totalTime.get()/numTasks.get()));
		}finally{
			super.terminated();
		}
	}
}