Java通過Executors提供四種執行緒池，分別為：
newCachedThreadPool建立一個可快取執行緒池，如果執行緒池長度超過處理需要，可靈活回收空閒執行緒，若無可回收，則新建執行緒。
newFixedThreadPool 建立一個定長執行緒池，可控制執行緒最大併發數，超出的執行緒會在佇列中等待。
newScheduledThreadPool 建立一個定長執行緒池，支援定時及週期性任務執行。
newSingleThreadExecutor 建立一個單執行緒化的執行緒池，它只會用唯一的工作執行緒來執行任務，保證所有任務按照指定順序(FIFO, LIFO, 優先順序)執行。

(1) newCachedThreadPool

1. package test;  
2. import java.util.concurrent.ExecutorService;  
3. import java.util.concurrent.Executors;  
4. public class ThreadPoolExecutorTest {  
5.  public static void main(String[] args) {  
6.   ExecutorService cachedThreadPool = Executors.newCachedThreadPool();  
7.   for (int i = 0; i < 10; i++) {  
8.    final int index = i;  
9.    try {  
10.     Thread.sleep(index * 1000);  
11.    } catch (InterruptedException e) {  
12.     e.printStackTrace();  
13.    }  
14.    cachedThreadPool.execute(new Runnable() {  
15.     public void run() {  
16.      System.out.println(index);  
17.     }  
18.    });  
19.   }  
20.  }  
21. }  

執行緒池為無限大，當執行第二個任務時第一個任務已經完成，會複用執行第一個任務的執行緒，而不用每次新建執行緒。
 
(2) newFixedThreadPool（專案用過）
建立一個定長執行緒池，可控制執行緒最大併發數，超出的執行緒會在佇列中等待。示例程式碼如下：

1. package test;  
2. import java.util.concurrent.ExecutorService;  
3. import java.util.concurrent.Executors;  
4. public class ThreadPoolExecutorTest {  
5.  public static void main(String[] args) {  
6.   ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);  
7.   for (int i = 0; i < 10; i++) {  
8.    final int index = i;  
9.    fixedThreadPool.execute(new Runnable() {  
10.     public void run() {  
11.      try {  
12.       System.out.println(index);  
13.       Thread.sleep(2000);  
14.      } catch (InterruptedException e) {  
15.       e.printStackTrace();  
16.      }  
17.     }  
18.    });  
19.   }  
20.  }  
21. }  

 
因為執行緒池大小為3，每個任務輸出index後sleep 2秒，所以每兩秒列印3個數字。
定長執行緒池的大小最好根據系統資源進行設定。如Runtime.getRuntime().availableProcessors()

(3)  newScheduledThreadPool
建立一個定長執行緒池，支援定時及週期性任務執行。延遲執行示例程式碼如下：

1. package test;  
2. import java.util.concurrent.Executors;  
3. import java.util.concurrent.ScheduledExecutorService;  
4. import java.util.concurrent.TimeUnit;  
5. public class ThreadPoolExecutorTest {  
6.  public static void main(String[] args) {  
7.   ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);  
8.   scheduledThreadPool.schedule(new Runnable() {  
9.    public void run() {  
10.     System.out.println("delay 3 seconds");  
11.    }  
12.   }, 3, TimeUnit.SECONDS);  
13.  }  
14. }  

 
表示延遲3秒執行。

定期執行示例程式碼如下：

1. package test;  
2. import java.util.concurrent.Executors;  
3. import java.util.concurrent.ScheduledExecutorService;  
4. import java.util.concurrent.TimeUnit;  
5. public class ThreadPoolExecutorTest {  
6.  public static void main(String[] args) {  
7.   ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);  
8.   scheduledThreadPool.scheduleAtFixedRate(new Runnable() {  
9.    public void run() {  
10.     System.out.println("delay 1 seconds, and excute every 3 seconds");  
11.    }  
12.   }, 1, 3, TimeUnit.SECONDS);  
13.  }  
14. }  

 
表示延遲1秒後每3秒執行一次。

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

1. package test;  
2. import java.util.concurrent.ExecutorService;  
3. import java.util.concurrent.Executors;  
4. public class ThreadPoolExecutorTest {  
5.  public static void main(String[] args) {  
6.   ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();  
7.   for (int i = 0; i < 10; i++) {  
8.    final int index = i;  
9.    singleThreadExecutor.execute(new Runnable() {  
10.     public void run() {  
11.      try {  
12.       System.out.println(index);  
13.       Thread.sleep(2000);  
14.      } catch (InterruptedException e) {  
15.       e.printStackTrace();  
16.      }  
17.     }  
18.    });  
19.   }  
20.  }  
21. }  

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

你可以使用JDK自帶的監控工具來監控我們建立的執行緒數量，執行一個不終止的執行緒，建立指定量的執行緒，來觀察：
工具目錄：C:\Program Files\Java\jdk1.6.0_06\bin\jconsole.exe
執行程式做稍微修改：

1. package test;  
2. import java.util.concurrent.ExecutorService;  
3. import java.util.concurrent.Executors;  
4. public class ThreadPoolExecutorTest {  
5.  public static void main(String[] args) {  
6.   ExecutorService singleThreadExecutor = Executors.newCachedThreadPool();  
7.   for (int i = 0; i < 100; i++) {  
8.    final int index = i;  
9.    singleThreadExecutor.execute(new Runnable() {  
10.     public void run() {  
11.      try {  
12.       while(true) {  
13.        System.out.println(index);  
14.        Thread.sleep(10 * 1000);  
15.       }  
16.      } catch (InterruptedException e) {  
17.       e.printStackTrace();  
18.      }  
19.     }  
20.    });  
21.    try {  
22.     Thread.sleep(500);  
23.    } catch (InterruptedException e) {  
24.     e.printStackTrace();  
25.    }  
26.   }  
27.  }  
28. }  

 轉載自：https://blog.csdn.net/mack415858775/article/details/51508831