程式碼：

package com.bob.test;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ExecutorServiceTest {
	 static void run(ExecutorService threadPool){
		for(int i=1 ; i < 5; i++ ){
			final int taskId = i;
			threadPool.execute(new Runnable(){

				@Override
				public void run() {
					for(int i = 1; i < 5; i++){
						try {
							Thread.sleep(20);
						} catch (Exception e) {
							e.printStackTrace();
						}
						System.out.println("第"+taskId+"次任務的第"+i+"次執行");
					}
				}
				
			});
		}
		threadPool.shutdown(); // 任務執行完畢，關閉執行緒池 
	}
	public static void main(String args[]){
		// 建立可以容納3個執行緒的執行緒池 
		ExecutorService fixExecutorService = Executors.newFixedThreadPool(3);
		
		// 執行緒池的大小會根據執行的任務數動態分配
		ExecutorService cachedExecutorService = Executors.newCachedThreadPool();
		
		// 建立單個執行緒的執行緒池，如果當前執行緒在執行任務時突然中斷，則會建立一個新的執行緒替代它繼續執行任務
		ExecutorService singleExecutorService = Executors.newSingleThreadExecutor();
		
		// 效果類似於Timer定時器
		ExecutorService scheduleExecutorService = Executors.newScheduledThreadPool(3);
		
		run(fixExecutorService);
//		run(cachedExecutorService);
//		run(singleExecutorService);
//		run(scheduleExecutorService);
		
	}

}
 

CachedThreadPool

CachedThreadPool會建立一個快取區，將初始化的執行緒快取起來。會終止並且從快取中移除已有60秒未被使用的執行緒。

如果執行緒有可用的，就使用之前建立好的執行緒，

如果執行緒沒有可用的，就新建立執行緒。

• 重用：快取型池子，先檢視池中有沒有以前建立的執行緒，如果有，就reuse；如果沒有，就建一個新的執行緒加入池中
• 使用場景：快取型池子通常用於執行一些生存期很短的非同步型任務，因此在一些面向連線的daemon型SERVER中用得不多。
• 超時：能reuse的執行緒，必須是timeout IDLE內的池中執行緒，預設timeout是60s，超過這個IDLE時長，執行緒例項將被終止及移出池。
• 結束：注意，放入CachedThreadPool的執行緒不必擔心其結束，超過TIMEOUT不活動，其會自動被終止。
  

1. // 執行緒池的大小會根據執行的任務數動態分配
2. ExecutorService cachedThreadPool = Executors.newCachedThreadPool();  
3. publicstatic ExecutorService newCachedThreadPool() {  
4.     returnnew ThreadPoolExecutor(0,                 //core pool size
5.                                   Integer.MAX_VALUE, //maximum pool size
6.                                   60L,               //keep alive time
7.                                   TimeUnit.SECONDS,  
8.                                   new SynchronousQueue<Runnable>());  
9. }  

1. 第1次任務的第1次執行  
2. 第4次任務的第1次執行  
3. 第3次任務的第1次執行  
4. 第2次任務的第1次執行  
5. 第3次任務的第2次執行  
6. 第4次任務的第2次執行  
7. 第2次任務的第2次執行  
8. 第1次任務的第2次執行  
9. 第2次任務的第3次執行  
10. 第4次任務的第3次執行  
11. 第3次任務的第3次執行  
12. 第1次任務的第3次執行  
13. 第2次任務的第4次執行  
14. 第1次任務的第4次執行  
15. 第3次任務的第4次執行  
16. 第4次任務的第4次執行  

FixedThreadPool

在FixedThreadPool中，有一個固定大小的池。

如果當前需要執行的任務超過池大小，那麼多出的任務處於等待狀態，直到有空閒下來的執行緒執行任務，

如果當前需要執行的任務小於池大小，空閒的執行緒也不會去銷燬。

• 重用：fixedThreadPool與cacheThreadPool差不多，也是能reuse就用，但不能隨時建新的執行緒
• 固定數目：其獨特之處在於，任意時間點，最多隻能有固定數目的活動執行緒存在，此時如果有新的執行緒要建立，只能放在另外的佇列中等待，直到當前的執行緒中某個執行緒終止直接被移出池子
• 超時：和cacheThreadPool不同，FixedThreadPool沒有IDLE機制（可能也有，但既然文件沒提，肯定非常長，類似依賴上層的TCP或UDP IDLE機制之類的），
• 使用場景：所以FixedThreadPool多數針對一些很穩定很固定的正規併發執行緒，多用於伺服器
• 原始碼分析：從方法的原始碼看，cache池和fixed 池呼叫的是同一個底層池，只不過引數不同：
  fixed池執行緒數固定，並且是0秒IDLE（無IDLE）
  cache池執行緒數支援0-Integer.MAX_VALUE(顯然完全沒考慮主機的資源承受能力），60秒IDLE

1. // 建立可以容納3個執行緒的執行緒池
2. ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);  
3. publicstatic ExecutorService newFixedThreadPool(int nThreads) {  
4.         returnnew ThreadPoolExecutor(nThreads, //core pool size
5.                                       nThreads, //maximum pool size
6.                                       0L,       //keep alive time
7.                                       TimeUnit.MILLISECONDS,  
8.                                       new LinkedBlockingQueue<Runnable>());  
9. }  

1. 第1次任務的第1次執行  
2. 第3次任務的第1次執行  
3. 第2次任務的第1次執行  
4. 第3次任務的第2次執行  
5. 第2次任務的第2次執行  
6. 第1次任務的第2次執行  
7. 第3次任務的第3次執行  
8. 第1次任務的第3次執行  
9. 第2次任務的第3次執行  
10. 第3次任務的第4次執行  
11. 第1次任務的第4次執行  
12. 第2次任務的第4次執行  
13. 第4次任務的第1次執行  
14. 第4次任務的第2次執行  
15. 第4次任務的第3次執行  
16. 第4次任務的第4次執行  

SingleThreadExecutor 

SingleThreadExecutor得到的是一個單個的執行緒，這個執行緒會保證你的任務執行完成。

如果當前執行緒意外終止，會建立一個新執行緒繼續執行任務，這和我們直接建立執行緒不同，也和newFixedThreadPool(1)不同。

1. // 建立單個執行緒的執行緒池，如果當前執行緒在執行任務時突然中斷，則會建立一個新的執行緒替代它繼續執行任務  
2. ExecutorService singleThreadPool = Executors.newSingleThreadExecutor();  
3. publicstatic ExecutorService newSingleThreadExecutor() {  
4.         returnnew FinalizableDelegatedExecutorService  
5.             (new ThreadPoolExecutor(1,  //core pool size
6.                                     1,  //maximum pool size
7.                                     0L, //keep alive time
8.                                     TimeUnit.MILLISECONDS,  
9.                                     new LinkedBlockingQueue<Runnable>()));  
10. }  

執行結果：

1. 第1次任務的第1次執行  
2. 第1次任務的第2次執行  
3. 第1次任務的第3次執行  
4. 第1次任務的第4次執行  
5. 第2次任務的第1次執行  
6. 第2次任務的第2次執行  
7. 第2次任務的第3次執行  
8. 第2次任務的第4次執行  
9. 第3次任務的第1次執行  
10. 第3次任務的第2次執行  
11. 第3次任務的第3次執行  
12. 第3次任務的第4次執行  
13. 第4次任務的第1次執行  
14. 第4次任務的第2次執行  
15. 第4次任務的第3次執行  
16. 第4次任務的第4次執行  

ScheduledThreadPool

ScheduledThreadPool是一個固定大小的執行緒池，與FixedThreadPool類似，執行的任務是定時執行。

1. // 效果類似於Timer定時器
2. ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(3);  
3. public ScheduledThreadPoolExecutor(int corePoolSize) {  
4.         super(corePoolSize,      //core pool size
5.               Integer.MAX_VALUE, //maximum pool size
6.               0,                 //keep alive time
7.               TimeUnit.NANOSECONDS,  
8.               new DelayedWorkQueue());  
9. }  

1. 第1次任務的第1次執行  
2. 第2次任務的第1次執行  
3. 第3次任務的第1次執行  
4. 第2次任務的第2次執行  
5. 第1次任務的第2次執行  
6. 第3次任務的第2次執行  
7. 第2次任務的第3次執行  
8. 第1次任務的第3次執行  
9. 第3次任務的第3次執行  
10. 第2次任務的第4次執行  
11. 第1次任務的第4次執行  
12. 第3次任務的第4次執行  
13. 第4次任務的第1次執行  
14. 第4次任務的第2次執行  
15. 第4次任務的第3次執行  
16. 第4次任務的第4次執行