Java通過Executors提供四種執行緒池，分別為：

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

執行緒池的作用：

執行緒池作用就是限制系統中執行執行緒的數量。
根 據系統的環境情況，可以自動或手動設定執行緒數量，達到執行的最佳效果；少了浪費了系統資源，多了造成系統擁擠效率不高。用執行緒池控制執行緒數量，其他執行緒排 隊等候。一個任務執行完畢，再從佇列的中取最前面的任務開始執行。若佇列中沒有等待程序，執行緒池的這一資源處於等待。當一個新任務需要執行時，如果執行緒池 中有等待的工作執行緒，就可以開始運行了；否則進入等待佇列。

為什麼要用執行緒池:

1.減少了建立和銷燬執行緒的次數，每個工作執行緒都可以被重複利用，可執行多個任務。

2.可以根據系統的承受能力，調整執行緒池中工作線執行緒的數目，防止因為消耗過多的記憶體，而把伺服器累趴下(每個執行緒需要大約1MB記憶體，執行緒開的越多，消耗的記憶體也就越大，最後宕機)。

Java裡面執行緒池的頂級介面是Executor，但是嚴格意義上講Executor並不是一個執行緒池，而只是一個執行執行緒的工具。真正的執行緒池介面是ExecutorService。

比較重要的幾個類：

ExecutorService： 真正的執行緒池介面。

ScheduledExecutorService： 能和Timer/TimerTask類似，解決那些需要任務重複執行的問題。

ThreadPoolExecutor： ExecutorService的預設實現。

ScheduledThreadPoolExecutor： 繼承ThreadPoolExecutor的ScheduledExecutorService介面實現，週期性任務排程的類實現。

要配置一個執行緒池是比較複雜的，尤其是對於執行緒池的原理不是很清楚的情況下，很有可能配置的執行緒池不是較優的，因此在Executors類裡面提供了一些靜態工廠，生成一些常用的執行緒池。

newCachedThreadPool

1. public static void main(String[] args) {  
2.         ExecutorService cachedThreadPool
    = Executors.newCachedThreadPool();  
3.         for (int i = 0; i <10; i++) {  
4.             final int index = i;  
5.             try {  
6.                 Thread.sleep(10);  
7.             } catch (InterruptedException e) {  
8.                 e.printStackTrace();  
9.             }  
10.             cachedThreadPool.execute(new Runnable() {  
11.                 public void run() {  
12.                     System.out.println(index);  
13.                 }  
14.             });  
15.         }  
16.     }

newFixedThreadPool

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

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

newScheduleThreadPool()

1. public static void main(String[] args) {  
2.         ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);  
3.         for (int i = 0; i <10; i++) {  
4.             scheduledThreadPool.schedule(new Runnable() {  
5.                 public void run() {  
6.                     System.out.println("delay 3 seconds");  
7.                 }  
8.             }, 3, TimeUnit.SECONDS);  
9.         }  
10.     } 

newSingleThreadExecutor

按順序執行執行緒，某個時間段只能有一個執行緒存在，一個執行緒死掉，另一個執行緒會補上

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

package thread.demo.test;


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


class MyThread extends Thread{
	public void run(){
		System.out.println(Thread.currentThread().getName()+"is running");
	}
}


//class MyThread1 implements Runnable{
//	public void run(){
//		System.out.println("====");
//	}
//}




public class ThreadPoolDemo {


	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
//		ExecutorService pool=Executors.newFixedThreadPool(3);
		Thread t1=new MyThread();
		Thread t2=new MyThread();
		Thread t3=new MyThread();
		Thread t4=new MyThread();
		Thread t5=new MyThread();
//		pool.execute(t1);
//		pool.execute(t2);
//		pool.execute(t3);
//		pool.execute(t4);
//		pool.execute(t5);
//		pool.shutdown();
		
		/*
		 * output:
		 * pool-1-thread-2is running 
		 * pool-1-thread-3is running
		 * pool-1-thread-1is running
		 * pool-1-thread-3is running
		 * pool-1-thread-2is running
		 * 
		 */
		
		
//		ExecutorService  pool1=Executors.newCachedThreadPool();
//		pool1.execute(t1);
//		pool1.execute(t2);
//		pool1.execute(t3);
//		pool1.execute(t4);
//		pool1.execute(t5);
//		pool1.shutdown();
		/*
		 * output:
		 * pool-2-thread-2is running
		 * pool-2-thread-3is running
		 * pool-2-thread-1is running
		 * pool-2-thread-4is running
		 * pool-2-thread-5is running
		 */
		
		
//		ExecutorService pool2=Executors.newSingleThreadExecutor();
//		pool2.execute(t1);
//		pool2.execute(t2);
//		pool2.execute(t3);
//		pool2.execute(t4);
//		pool2.execute(t5);
//		pool2.shutdown();
		/*
		 * OutPut:
		 * pool-3-thread-1is running
		 * pool-3-thread-1is running
		 * pool-3-thread-1is running
		 * pool-3-thread-1is running
		 * pool-3-thread-1is running
		 */
		
		ExecutorService pool3=Executors.newScheduledThreadPool(1);
		pool3.execute(new Runnable(){
			public void run(){
				System.out.println(Thread.currentThread().getName()+"====");
			}
		});
		pool3.execute(new Runnable(){
			public void run(){
				System.out.println(Thread.currentThread().getName()+"~~~~");
			}
		});
		pool3.shutdown();
		/*
		 * output:
		 * pool-3-thread-1====
		 * pool-3-thread-1~~~~
		 */
	}


}