系統啟動一個新線程的成本是比較高的，因為它涉及到與操作系統的交互。在這種情況下，使用線程池可以很好的提供性能，尤其是當程序中需要創建大量生存期很短暫的線程時，更應該考慮使用線程池。

與數據庫連接池類似的是，線程池在系統啟動時即創建大量空閑的線程，程序將一個Runnable對象傳給線程池，線程池就會啟動一條線程來執行該對象的run方法，當run方法執行結束后，該線程并不會死亡，而是再次返回線程池中成為空閑狀態，等待執行下一個Runnable對象的run方法。

除此之外，使用線程池可以有效地控制系統中并發線程的數量，但系統中包含大量并發線程時，會導致系統性能劇烈下降，甚至導致JVM崩潰。而線程池的最大線程數參數可以控制系統中并發的線程不超過此數目。

在JDK1.5之前，開發者必須手動的實現自己的線程池，從JDK1.5之后，Java內建支持線程池。

與多線程并發的所有支持的類都在java.lang.concurrent包中。我們可以使用里面的類更加的控制多線程的執行。

一、Executors類

JDK1.5中提供Executors工廠類來產生連接池，該工廠類中包含如下的幾個靜態工程方法來創建連接池：

1、public static ExecutorService newFixedThreadPool(int nThreads)：創建一個可重用的、具有固定線程數的線程池。

2、public static ExecutorService newSingleThreadExecutor()：創建一個只有單線程的線程池，它相當于newFixedThreadPool方法是傳入的參數為1

3、public static ExecutorService newCachedThreadPool()：創建一個具有緩存功能的線程池，系統根據需要創建線程，這些線程將會被緩存在線程池中。

4、public static ScheduledExecutorService newSingleThreadScheduledExecutor：創建只有一條線程的線程池，他可以在指定延遲后執行線程任務

5、public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)：創建具有指定線程數的線程池，它可以再指定延遲后執行線程任務，corePoolSize指池中所保存的線程數，即使線程是空閑的也被保存在線程池內。

上面的幾個方法都有一個重載的方法，多傳入一個ThreadFactory參數的重載方法，使用的比較少。

二、ExecutorService類

可以看到上面的5個方法中，前面3個方法的返回值都是一個ExecutorService對象。該ExecutorService對象就代表著一個盡快執行線程的線程池（只要線程池中有空閑線程立即執行線程任務），程序只要將一個Runnable對象或Callable對象提交給該線程池即可，該線程就會盡快的執行該任務。

ExecutorService有幾個重要的方法：

方法摘要

booleanisShutdown()

如果此執行程序已關閉，則返回true。

booleanisTerminated()

如果關閉后所有任務都已完成，則返回true。

voidshutdown()

啟動一次順序關閉，執行以前提交的任務，但不接受新任務。

List<Runnable>shutdownNow()

試圖停止所有正在執行的活動任務，暫停處理正在等待的任務，并返回等待執行的任務列表。

Future

submit(Callable?task)

提交一個返回值的任務用于執行，返回一個表示任務的未決結果的 Future。

Futuresubmit(Runnabletask)

提交一個 Runnable 任務用于執行，并返回一個表示該任務的 Future。

Future

submit(Runnabletask, T?result)

提交一個 Runnable 任務用于執行，并返回一個表示該任務的 Future。

更詳細的參考JDK API文檔。

submit方法是對 Executor接口execute方法的更好的封裝，建議使用submit方法。

三、ScheduleExecutorService類

在上面的5個方法中，后面2個方法的返回值都是一個ScheduleExecutorService對象。ScheduleExecutorService代表可在指定延遲或周期性執行線程任務的線程池。

ScheduleExecutorService類是ExecutorService類的子類。所以，它里面也有直接提交任務的submit方法，并且新增了一些延遲任務處理的方法：

方法摘要

ScheduledFuture

schedule(Callable?callable, long?delay,TimeUnitunit)

創建并執行在給定延遲后啟用的 ScheduledFuture。

ScheduledFutureschedule(Runnablecommand, long?delay,TimeUnitunit)

創建并執行在給定延遲后啟用的一次性操作。

ScheduledFuturescheduleAtFixedRate(Runnablecommand, long?initialDelay, long?period,TimeUnitunit)

創建并執行一個在給定初始延遲后首次啟用的定期操作，后續操作具有給定的周期；也就是將在initialDelay后開始執行，然后在initialDelay+period后執行，接著在initialDelay + 2 * period后執行，依此類推。

ScheduledFuturescheduleWithFixedDelay(Runnablecommand, long?initialDelay, long?delay,TimeUnitunit)

創建并執行一個在給定初始延遲后首次啟用的定期操作，隨后，在每一次執行終止和下一次執行開始之間都存在給定的延遲。

下面看看線程池的簡單使用：

1、固定大小的線程池：

[java]view plaincopy

packagecom.tao.test;

importjava.util.concurrent.ExecutorService;

importjava.util.concurrent.Executors;

publicclassPoolTest?{

publicstaticvoidmain(String[]?args)?{

ExecutorService?pool=Executors.newFixedThreadPool(5);//創建一個固定大小為5的線程池

for(inti=0;i<7;i++){

pool.submit(newMyThread());

}

pool.shutdown();

}

}

classMyThreadextendsThread{

@Override

publicvoidrun()?{

System.out.println(Thread.currentThread().getName()+"正在執行。。。");

}

}

輸出結果：

[java]view plaincopy

pool-1-thread-1正在執行。。。

pool-1-thread-3正在執行。。。

pool-1-thread-2正在執行。。。

pool-1-thread-4正在執行。。。

pool-1-thread-4正在執行。。。

pool-1-thread-5正在執行。。。

pool-1-thread-1正在執行。。。

可以看到雖然我們呢創建了7個MyThread線程對象，但是由于受線程池的大小限制，只是開啟了5個線程，這樣就減少了并發線程的數量。

2、單任務線程池：

[java]view plaincopy

publicclassPoolTest?{

publicstaticvoidmain(String[]?args)?{

ExecutorService?pool=Executors.newSingleThreadExecutor();//創建一個單線程池

for(inti=0;i<7;i++){

pool.submit(newMyThread());

}

pool.shutdown();

}

}

輸出結果：

[java]view plaincopy

pool-1-thread-1正在執行。。。

pool-1-thread-1正在執行。。。

pool-1-thread-1正在執行。。。

pool-1-thread-1正在執行。。。

pool-1-thread-1正在執行。。。

pool-1-thread-1正在執行。。。

pool-1-thread-1正在執行。。。

可以看到，線程池只開啟了一個線程。

3、創建可變尺寸的線程池

[java]view plaincopy

publicclassPoolTest?{

publicstaticvoidmain(String[]?args)?{

ExecutorService?pool=Executors.newCachedThreadPool();

for(inti=0;i<5;i++){

pool.submit(newMyThread());

}

pool.shutdown();

}

}

看輸出結果：

[java]view plaincopy

pool-1-thread-1正在執行。。。

pool-1-thread-3正在執行。。。

pool-1-thread-2正在執行。。。

pool-1-thread-4正在執行。。。

pool-1-thread-5正在執行。。。

可以看到，我們沒有限制線程池的大小，但是它會根據需求而創建線程。

4、延遲線程池

[java]view plaincopy

publicclassPoolTest?{

publicstaticvoidmain(String[]?args)?{

ScheduledExecutorService?pool=Executors.newScheduledThreadPool(6);

for(inti=0;i<4;i++){

pool.submit(newMyThread());

}

pool.schedule(newMyThread(),1000,?TimeUnit.MILLISECONDS);

pool.schedule(newMyThread(),1000,?TimeUnit.MILLISECONDS);

pool.shutdown();

}

}

輸出結果：

[java]view plaincopy

pool-1-thread-1正在執行。。。

pool-1-thread-3正在執行。。。

pool-1-thread-2正在執行。。。

pool-1-thread-4正在執行。。。

pool-1-thread-6正在執行。。。

pool-1-thread-1正在執行。。。

可以明顯看到，最后兩個線程不是立即執行，而是延遲了1秒在執行的。

5、單任務延遲線程池

[java]view plaincopy

publicclassPoolTest?{

publicstaticvoidmain(String[]?args)?{

ScheduledExecutorService?pool=Executors.newSingleThreadScheduledExecutor();

for(inti=0;i<4;i++){

pool.submit(newMyThread());

}

pool.schedule(newMyThread(),1000,?TimeUnit.MILLISECONDS);

pool.schedule(newMyThread(),1000,?TimeUnit.MILLISECONDS);

pool.shutdown();

}

}

上面我們使用的是JDK幫我封裝好的線程池，我們也可以自己定義線程池，查看源碼，我們發現，Excutors里面的獲得線程的靜態方法，內部都是調用ThreadPoolExecutor的構造方法。比如：

[java]view plaincopy

publicstaticExecutorService?newFixedThreadPool(intnThreads,?ThreadFactory?threadFactory)?{

returnnewThreadPoolExecutor(nThreads,?nThreads,

0L,?TimeUnit.MILLISECONDS,

newLinkedBlockingQueue(),

threadFactory);

}

可以看到，它是通過調用ThreadPoolExecutor的構造方法來返回一個線程池的。所以，我們也可以自己手動的調用ThreadPoolExecutor的各種構造方法，來定義自己的線程池規則，不過一般情況下，使用自帶的線程池就夠了，不需要自己來實現。

轉自：http://blog.csdn.net/lonelyroamer/article/details/7993637