Java中的線程池——ThreadPoolExecutor的使用

開發過程中，合理地使用線程池可以帶來3個好處：

降低資源消耗：通過重複利用已創建的線程降低線程創建和銷燬造成的消耗。

提高響應速度：當任務到達時，任務可以不需要等到線程創建就能立即執行。

提高線程的可管理性：線程是稀缺資源，如果無限制地創建，不僅會消耗系統資源，還會降低系統的穩定性，使用線程池可以進行統一分配、調優和監控。

1 線程池的創建

ThreadPoolExecutor有以下四個構造方法

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

這裏面需要幾個參數

1  corePoolSize（線程池的基本大小）:當提交一個任務到線程池時，線程池會創建一個線程來執行任務，即使其他空閒的基本線程能夠執行新任務也會創建線程，等到需要執行的任務數大於線程池基本大小時就不再創建。如果調用了prestartAllCoreThreads()方法，線程池會提前創建並啓動所有基本線程。

2  workQueue(任務隊列) : 用於保存等待執行的任務的阻塞隊列。可以選擇以下幾個阻塞隊列：

• ArrayBlockingQueue:是一個基於數組結構的有界阻塞隊列，按FIFO原則進行排序
• LinkedBlockingQueue:一個基於鏈表結構的阻塞隊列，吞吐量高於ArrayBlockingQueue。靜態工廠方法Excutors.newFixedThreadPool()使用了這個隊列
• SynchronousQueue: 一個不存儲元素的阻塞隊列。每個插入操作必須等到另一個線程調用移除操作，否則插入操作一直處於阻塞狀態，吞吐量高於LinkedBlockingQueue，靜態工廠方法Excutors.newCachedThreadPool()使用了這個隊列
• PriorityBlockingQueue:一個具有優先級的無限阻塞隊列。

3  maximumPoolSize（線程池最大數量）：線程池允許創建的最大線程數。如果隊列滿了，並且已創建的線程數小於最大線程數，則線程池會再創建新的線程執行任務。值得注意的是，如果使用了無界的任務隊列這個參數就沒用了。

4 threadFactory（線程工廠）：可以通過線程工廠爲每個創建出來的線程設置更有意義的名字，如開源框架guava

5 RejectedExecutionHandler （飽和策略）：當隊列和線程池都滿了，說明線程池處於飽和狀態，那麼必須採取一種策略還處理新提交的任務。它可以有如下四個選項：

• AbortPolicy:直接拋出異常，默認情況下采用這種策略
• CallerRunsPolicy:只用調用者所在線程來運行任務
• DiscardOldestPolicy:丟棄隊列裏最近的一個任務，並執行當前任務
• DiscardPolicy:不處理，丟棄掉

    更多的時候，我們應該通過實現RejectedExecutionHandler 接口來自定義策略，比如記錄日誌或持久化存儲等。

6 keepAliveTime(線程活動時間):線程池的工作線程空閒後，保持存活的時間。所以如果任務很多，並且每個任務執行的時間比較短，可以調大時間，提高線程利用率。

7 TimeUnit(線程活動時間的單位)：可選的單位有天（Days）、小時（HOURS）、分鐘（MINUTES）、毫秒（MILLISECONDS）、微秒（MICROSECONDS，千分之一毫秒）和納秒（NANOSECONDS，千分之一微秒）。

2 提交任務

可以使用execute和submit兩個方法向線程池提交任務

（1）execute方法用於提交不需要返回值的任務，利用這種方式提交的任務無法得知是否正常執行

threadPoolExecutor.execute(new Runnable() {
			
			@Override
			public void run() {
				try {
					Thread.sleep(5000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		});

（2） submit方法用於提交一個任務並帶有返回值，這個方法將返回一個Future類型對象。可以通過這個返回對象判斷任務是否執行成功，並且可以通過future.get()方法來獲取返回值，get()方法會阻塞當前線程直到任務完成。

Future<?> future=threadPoolExecutor.submit(futureTask);
		
		Object value=future.get();

3 關閉線程池

可以通過調用線程池的shutdown或shutdownNow方法來關閉線程池。他們的原理是遍歷線程池中的工作線程，然後逐個調用線程的interrupt方法來中斷線程，所以無響應中斷的任務可能永遠無法停止。但是他們存在一定的區別，shutdownNow首先將線程池的狀態設置爲STOP，然後嘗試停止所有正在執行或暫停任務的線程，並返回等待執行任務的列表，而shutdown只是將線程池的狀態設置成SHUTDOWN狀態，然後中斷所有正在執行的任務。

只要調用了這兩個關閉方法的一個，isShutdown就會返回true。當所有的任務都關閉後，才表示線程池關閉成功，這是調用isTerminated方法會返回true。至於應該調用哪一種方法來關閉線程池，應該由提交到線程池的任務特性決定，通常調用shutdown方法來關閉線程池，如果任務不一定執行完，則可以調用shutdownNow方法。

4 合理配置線程池

要想合理地配置線程池，首先要分析任務特性

• 任務的性質：CPU密集型任務、IO密集型任務和混合型任務。
• 任務的優先級：高、中和低。
• 任務的執行時間：長、中和短。
• 任務的依賴性：是否依賴其他系統資源，如數據庫連接。

性質不同的任務可以用不同規模的線程池分開處理。CPU密集型任務應該配置儘可能少的線程，如配置N+1個線程，N位CPU的個數。而IO密集型任務線程並不是一直在執行任務，則應配置儘可能多的線程，如2*N。混合型任務，如果可以拆分，將其拆分成一個CPU密集型任務和一個IO密集型任務，只要這兩個任務執行的時間相差不是太大，那麼分解後執行的吞吐量將高於串行執行的吞吐量

優先級不同的任務可以交給優先級隊列PriorityBlcokingQueue來處理。

執行時間不同的任務可以交給不同規模的線程池來處理。

依賴數據庫的任務，因此線程提交SQL後需要等待數據庫返回結果，等待的時間越長，則CPU空閒時間越長，那麼線程數應該設置的越大，這樣能更好滴利用CPU。

5 線程池應用示例

1 示例1 驗證shutdown和shutdownNow的區別

（1）首先構造一個線程池，用ArrayBlockingQueue作爲其等待隊列，隊列初始化容量爲10。該線程池核心容量爲 10，最大容量爲20，線程存活時間爲1分鐘。

static BlockingQueue blockingQueue=new ArrayBlockingQueue<>(10);
	
	static ThreadPoolExecutor threadPoolExecutor=new ThreadPoolExecutor(10, 20, 1, TimeUnit.MINUTES, blockingQueue);

（2）另外構造了一個實現Runable接口的類TaskWithoutResult，其邏輯很簡單，睡眠1秒

/**
 * 無返回值的任務
 * @author songxu
 *
 */
class TaskWithoutResult implements Runnable
{
	private int sleepTime=1000;//默認睡眠時間1s
	public TaskWithoutResult(int sleepTime)
	{
		this.sleepTime=sleepTime;
	}
	@Override
	public void run() 
	{
		System.out.println("線程"+Thread.currentThread()+"開始運行");
		try {
			Thread.sleep(sleepTime);
		} catch (InterruptedException e) {//捕捉中斷異常
			
			System.out.println("線程"+Thread.currentThread()+"被中斷");
		}
		System.out.println("線程"+Thread.currentThread()+"結束運行");
	}
	


}

（3）驗證

/**
	 * 中斷測試
	 */
	public static void  test1()
	{
		for(int i=0;i<10;i++)
		{
			Runnable runnable=new TaskWithoutResult(1000);
			threadPoolExecutor.submit(runnable);
		}
		//threadPoolExecutor.shutdown();//不會觸發中斷
		threadPoolExecutor.shutdownNow();//會觸發中斷
	}

分別測試shutdown和shutdownNow()方法，結果shutdown()方法的調用並不會引發中斷，而shutdownNow()方法則會引發中斷。這也正驗證前面所說的，shutdown方法只是發出了停止信號，等所有線程執行完畢會關閉線程池；而shutdownNow則是立即停止所有任務。

2 示例2 驗證線程池的擴容

在本例中想要驗證線程池擴容到核心數量，然後再擴容到最大數量，最後再縮小到核心數量的過程。

（1）首先構造一個線程池，用ArrayBlockingQueue作爲其等待隊列，隊列初始化容量爲1。該線程池核心容量爲 10，最大容量爲20，線程存活時間爲1分鐘。

  

static BlockingQueue blockingQueue=new ArrayBlockingQueue<>(1);
	
	static ThreadPoolExecutor threadPoolExecutor=new ThreadPoolExecutor(10, 20, 1, TimeUnit.MINUTES, blockingQueue);

 （2）另外構造了一個實現Runable接口的類TaskBusyWithoutResult類，其模擬一個繁忙的任務

 

class TaskBusyWithoutResult implements Runnable
{
	public TaskBusyWithoutResult()
	{
	}
	@Override
	public void run() 
	{
		System.out.println("線程"+Thread.currentThread()+"開始運行");
		int i=10000*10000;
		while(i>0)
		{
			i--;
		}
		System.out.println("線程"+Thread.currentThread()+"運行結束");
	}
	


}

 （3）測試驗證，向線程池提交20個任務

/**
	 * 擴容測試
	 */
	public static void  test2()
	{
		for(int i=0;i<20;i++)
		{
			Runnable runnable=new TaskBusyWithoutResult();
			threadPoolExecutor.submit(runnable);
		}
	}

（4）驗證結果

 在VisualVM中觀察線程的變化，在任務提交的瞬間，線程池完成了預熱到擴容到最大線程，之所以這麼迅速是因爲本例中的等待隊列長度只有1，可以適當地增加隊列長度，但不併不一定能看到擴大最大容量，其原因將在下一節中講到。在線程池中任務都運行完畢後，可以看到線程池回收了多餘的線程，但並沒有完全回收，而是保持在覈心線程數量。從這裏也可以看出，合理地設置核心線程的數量可以減少線程的頻繁創建和回收，而這纔是線程池的真正作用。