併發編程（五）——線程池及原理剖析

線程池

什麼是線程池

      Java中的線程池是運用場景最多的併發框架，幾乎所有需要異步或併發執行任務的程序都可以使用線程池。在開發過程中，合理地使用線程池能夠帶來3個好處。

• 第一：降低資源消耗。通過重複利用已創建的線程降低線程創建和銷燬造成的消耗。
• 第二：提高響應速度。當任務到達時，任務可以不需要等到線程創建就能立即執行。
• 第三：提高線程的可管理性。線程是稀缺資源，如果無限制地創建，不僅會消耗系統資源，

      還會降低系統的穩定性，使用線程池可以進行統一分配、調優和監控。但是，要做到合理利用線程池，必須對其實現原理了如指掌。

線程池作用

      線程池是爲突然大量爆發的線程設計的，通過有限的幾個固定線程爲大量的操作服務，減少了創建和銷燬線程所需的時間，從而提高效率。

      如果一個線程的時間非常長，就沒必要用線程池了(不是不能作長時間操作，而是不宜。)，況且我們還不能控制線程池中線程的開始、掛起、和中止。

線程池的分類

ThreadPoolExecutor

      Java是天生就支持併發的語言，支持併發意味着多線程，線程的頻繁創建在高併發及大數據量是非常消耗資源的，因爲java提供了線程池。在jdk1.5以前的版本中，線程池的使用是及其簡陋的，但是在JDK1.5後，有了很大的改善。JDK1.5之後加入了java.util.concurrent包，java.util.concurrent包的加入給予開發人員開發併發程序以及解決併發問題很大的幫助。這篇文章主要介紹下併發包下的Executor接口，Executor接口雖然作爲一個非常舊的接口（JDK1.5 2004年發佈），但是很多程序員對於其中的一些原理還是不熟悉，因此寫這篇文章來介紹下Executor接口，同時鞏固下自己的知識。如果文章中有出現錯誤，歡迎大家指出。

      Executor框架的最頂層實現是ThreadPoolExecutor類，Executors工廠類中提供的newScheduledThreadPool、newFixedThreadPool、newCachedThreadPool方法其實也只是ThreadPoolExecutor的構造函數參數不同而已。通過傳入不同的參數，就可以構造出適用於不同應用場景下的線程池，那麼它的底層原理是怎樣實現的呢，這篇就來介紹下ThreadPoolExecutor線程池的運行過程。

• corePoolSize： 核心池的大小。 當有任務來之後，就會創建一個線程去執行任務，當線程池中的線程數目達到corePoolSize後，就會把到達的任務放到緩存隊列當中

• maximumPoolSize： 線程池最大線程數，它表示在線程池中最多能創建多少個線程；

• keepAliveTime： 表示線程沒有任務執行時最多保持多久時間會終止。

• unit： 參數keepAliveTime的時間單位，有7種取值，在TimeUnit類中有7種靜態屬性：

線程池四種創建方式

Java通過Executors（jdk1.5併發包）提供四種線程池，分別爲：

• newCachedThreadPool創建一個可緩存線程池，如果線程池長度超過處理需要，可靈活回收空閒線程，若無可回收，則新建線程。

• newFixedThreadPool 創建一個定長線程池，可控制線程最大併發數，超出的線程會在隊列中等待。

• newScheduledThreadPool 創建一個定長線程池，支持定時及週期性任務執行。

• newSingleThreadExecutor 創建一個單線程化的線程池，它只會用唯一的工作線程來執行任務，保證所有任務按照指定順序(FIFO, LIFO, 優先級)執行。

newCachedThreadPool

      創建一個可緩存線程池，如果線程池長度超過處理需要，可靈活回收空閒線程，若無可回收，則新建線程。示例代碼如下：

// 無限大小線程池 jvm自動回收
ExecutorService newCachedThreadPool = Executors.newCachedThreadPool();
for (int i = 0; i < 10; i++) {
	final int temp = i;
	newCachedThreadPool.execute(new Runnable() {

		@Override
		public void run() {
			try {
				Thread.sleep(100);
			} catch (Exception e) {
				// TODO: handle exception
			}
			System.out.println(Thread.currentThread().getName() + ",i:" + temp);

		}
	});
}

      總結: 線程池爲無限大，當執行第二個任務時第一個任務已經完成，會複用執行第一個任務的線程，而不用每次新建線程。

newFixedThreadPool

      創建一個定長線程池，可控制線程最大併發數，超出的線程會在隊列中等待。示例代碼如下：

ExecutorService newFixedThreadPool = Executors.newFixedThreadPool(5);
		for (int i = 0; i < 10; i++) {
			final int temp = i;
			newFixedThreadPool.execute(new Runnable() {

				@Override
				public void run() {
					System.out.println(Thread.currentThread().getId() + ",i:" + temp);

				}
			});
		}

      總結:因爲線程池大小爲3，每個任務輸出index後sleep 2秒，所以每兩秒打印3個數字。

      定長線程池的大小最好根據系統資源進行設置。如Runtime.getRuntime().availableProcessors()

newScheduledThreadPool

      創建一個定長線程池，支持定時及週期性任務執行。延遲執行示例代碼如下：

ScheduledExecutorService newScheduledThreadPool = Executors.newScheduledThreadPool(5);
		for (int i = 0; i < 10; i++) {
			final int temp = i;
			newScheduledThreadPool.schedule(new Runnable() {
				public void run() {
					System.out.println("i:" + temp);
				}
			}, 3, TimeUnit.SECONDS);
}

      表示延遲3秒執行。

newSingleThreadExecutor

      創建一個單線程化的線程池，它只會用唯一的工作線程來執行任務，保證所有任務按照指定順序(FIFO, LIFO, 優先級)執行。示例代碼如下：

ExecutorService newSingleThreadExecutor = Executors.newSingleThreadExecutor();
	for (int i = 0; i < 10; i++) {
		final int index = i;
		newSingleThreadExecutor.execute(new Runnable() {

			@Override
			public void run() {
				System.out.println("index:" + index);
				try {
					Thread.sleep(200);
				} catch (Exception e) {
					// TODO: handle exception
				}
			}
		});
	}

      注意: 結果依次輸出，相當於順序執行各個任務。

線程池原理剖析

      提交一個任務到線程池中，線程池的處理流程如下：

• 1、判斷線程池裏的核心線程是否都在執行任務，如果不是（核心線程空閒或者還有核心線程沒有被創建）則創建一個新的工作線程來執行任務。如果核心線程都在執行任務，則進入下個流程。

• 2、線程池判斷工作隊列是否已滿，如果工作隊列沒有滿，則將新提交的任務存儲在這個工作隊列裏。如果工作隊列滿了，則進入下個流程。

• 3、判斷線程池裏的線程是否都處於工作狀態，如果沒有，則創建一個新的工作線程來執行任務。如果已經滿了，則交給飽和策略來處理這個任務。
  

自定義線程線程池

      如果當前線程池中的線程數目小於corePoolSize，則每來一個任務，就會創建一個線程去執行這個任務；

      如果當前線程池中的線程數目>=corePoolSize，則每來一個任務，會嘗試將其添加到任務緩存隊列當中，若添加成功，則該任務會等待空閒線程將其取出去執行；若添加失敗（一般來說是任務緩存隊列已滿），則會嘗試創建新的線程去執行這個任務；

      如果隊列已經滿了，則在總線程數不大於maximumPoolSize的前提下，則創建新的線程

      如果當前線程池中的線程數目達到maximumPoolSize，則會採取任務拒絕策略進行處理；

      如果線程池中的線程數量大於 corePoolSize時，如果某線程空閒時間超過keepAliveTime，線程將被終止，直至線程池中的線程數目不大於corePoolSize；如果允許爲核心池中的線程設置存活時間，那麼核心池中的線程空閒時間超過keepAliveTime，線程也會被終止。

public class Test0007 {

	public static void main(String[] args) {
		ThreadPoolExecutor executor = new ThreadPoolExecutor(1, 2, 60L, TimeUnit.SECONDS, new ArrayBlockingQueue<>(3));
		for (int i = 1; i <= 6; i++) {
			TaskThred t1 = new TaskThred("任務" + i);
			executor.execute(t1);
		}
		executor.shutdown();
	}
}

class TaskThred implements Runnable {
	private String taskName;

	public TaskThred(String taskName) {
		this.taskName = taskName;
	}

	@Override
	public void run() {
		System.out.println(Thread.currentThread().getName()+taskName);
	}

}

合理配置線程池

CPU密集

      CPU密集的意思是該任務需要大量的運算，而沒有阻塞，CPU一直全速運行。
      CPU密集任務只有在真正的多核CPU上纔可能得到加速(通過多線程)，而在單核CPU上，無論你開幾個模擬的多線程，該任務都不可能得到加速，因爲CPU總的運算能力就那些。

IO密集

      IO密集型，即該任務需要大量的IO，即大量的阻塞。在單線程上運行IO密集型的任務會導致浪費大量的CPU運算能力浪費在等待。所以在IO密集型任務中使用多線程可以大大的加速程序運行，即時在單核CPU上，這種加速主要就是利用了被浪費掉的阻塞時間。

      接着上一篇探討線程池留下的尾巴，如何合理的設置線程池大小。

      要想合理的配置線程池的大小，首先得分析任務的特性，可以從以下幾個角度分析：

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

      性質不同的任務可以交給不同規模的線程池執行。

      對於不同性質的任務來說，CPU密集型任務應配置儘可能小的線程，如配置CPU個數+1的線程數，IO密集型任務應配置儘可能多的線程，因爲IO操作不佔用CPU，不要讓CPU閒下來，應加大線程數量，如配置兩倍CPU個數+1，而對於混合型的任務，如果可以拆分，拆分成IO密集型和CPU密集型分別處理，前提是兩者運行的時間是差不多的，如果處理時間相差很大，則沒必要拆分了。

      若任務對其他系統資源有依賴，如某個任務依賴數據庫的連接返回的結果，這時候等待的時間越長，則CPU空閒的時間越長，那麼線程數量應設置得越大，才能更好的利用CPU。

      當然具體合理線程池值大小，需要結合系統實際情況，在大量的嘗試下比較才能得出，以上只是前人總結的規律。

最佳線程數目 = （（線程等待時間+線程CPU時間）/線程CPU時間 ）* CPU數目

      比如平均每個線程CPU運行時間爲0.5s，而線程等待時間（非CPU運行時間，比如IO）爲1.5s，CPU核心數爲8，那麼根據上面這個公式估算得到：((0.5+1.5)/0.5)*8=32。

      這個公式進一步轉化爲：

最佳線程數目 = （線程等待時間與線程CPU時間之比 + 1）* CPU數目

      可以得出一個結論：

      線程等待時間所佔比例越高，需要越多線程。線程CPU時間所佔比例越高，需要越少線程。
      以上公式與之前的CPU和IO密集型任務設置線程數基本吻合。

      CPU密集型時，任務可以少配置線程數，大概和機器的cpu核數相當，這樣可以使得每個線程都在執行任務

      IO密集型時，大部分線程都阻塞，故需要多配置線程數，2*cpu核數

      操作系統之名稱解釋：
      某些進程花費了絕大多數時間在計算上，而其他則在等待I/O上花費了大多是時間，前者稱爲計算密集型（CPU密集型）computer-bound，後者稱爲I/O密集型，I/O-bound。