Java多線程總結五：線程池的原理及實現

1、線程池簡介：
    多線程技術主要解決處理器單元內多個線程執行的問題，它可以顯著減少處理器單元的閒置時間，增加處理器單元的吞吐能力。   
    假設一個服務器完成一項任務所需時間為：T1 創建線程時間，T2 在線程中執行任務的時間，T3 銷毀線程時間。

    如果：T1 + T3 遠大於 T2，則可以采用線程池，以提高服務器性能。
                一個線程池包括以下四個基本組成部分：
                1、線程池管理器（ThreadPool）：用於創建並管理線程池，包括 創建線程池，銷毀線程池，添加新任務；
                2、工作線程（PoolWorker）：線程池中線程，在沒有任務時處於等待狀態，可以循環的執行任務；
                3、任務接口（Task）：每個任務必須實現的接口，以供工作線程調度任務的執行，它主要規定了任務的入口，任務執行完後的收尾工作，任務的執行狀態等；
                4、任務隊列（taskQueue）：用於存放沒有處理的任務。提供一種緩沖機制。
               
    線程池技術正是關注如何縮短或調整T1,T3時間的技術，從而提高服務器程序性能的。它把T1，T3分別安排在服務器程序的啟動和結束的時間段或者一些空閒的時間段，這樣在服務器程序處理客戶請求時，不會有T1，T3的開銷了。
    線程池不僅調整T1,T3產生的時間段，而且它還顯著減少了創建線程的數目，看一個例子：
    假設一個服務器一天要處理50000個請求，並且每個請求需要一個單獨的線程完成。在線程池中，線程數一般是固定的，所以產生線程總數不會超過線程池中線程的數目，而如果服務器不利用線程池來處理這些請求則線程總數為50000。一般線程池大小是遠小於50000。所以利用線程池的服務器程序不會為了創建50000而在處理請求時浪費時間，從而提高效率。

代碼實現中並沒有實現任務接口，而是把Runnable對象加入到線程池管理器（ThreadPool），然後剩下的事情就由線程池管理器（ThreadPool）來完成了

1. package mine.util.thread;  
2.   
3. import java.util.LinkedList;  
4. import java.util.List;  
5.   
6. /** 
7.  * 線程池類，線程管理器：創建線程，執行任務，銷毀線程，獲取線程基本信息 
8.  */  
9. public final class ThreadPool {  
10.     // 線程池中默認線程的個數為5   
11.     private static int worker_num = 5;  
12.     // 工作線程   
13.     private WorkThread[] workThrads;  
14.     // 未處理的任務   
15.     private static volatile int finished_task = 0;  
16.     // 任務隊列，作為一個緩沖,List線程不安全   
17.     private List<Runnable> taskQueue = new LinkedList<Runnable>();  
18.     private static ThreadPool threadPool;  
19.   
20.     // 創建具有默認線程個數的線程池   
21.     private ThreadPool() {  
22.         this(5);  
23.     }  
24.   
25.     // 創建線程池,worker_num為線程池中工作線程的個數   
26.     private ThreadPool(int worker_num) {  
27.         ThreadPool.worker_num = worker_num;  
28.         workThrads = new WorkThread[worker_num];  
29.         for (int i = 0; i < worker_num; i++) {  
30.             workThrads[i] = new WorkThread();  
31.             workThrads[i].start();// 開啟線程池中的線程   
32.         }  
33.     }  
34.   
35.     // 單態模式，獲得一個默認線程個數的線程池   
36.     public static ThreadPool getThreadPool() {  
37.         return getThreadPool(ThreadPool.worker_num);  
38.     }  
39.   
40.     // 單態模式，獲得一個指定線程個數的線程池,worker_num(>0)為線程池中工作線程的個數   
41.     // worker_num<=0創建默認的工作線程個數   
42.     public static ThreadPool getThreadPool(int worker_num1) {  
43.         if (worker_num1 <= 0)  
44.             worker_num1 = ThreadPool.worker_num;  
45.         if (threadPool == null)  
46.             threadPool = new ThreadPool(worker_num1);  
47.         return threadPool;  
48.     }  
49.   
50.     // 執行任務,其實只是把任務加入任務隊列，什麼時候執行有線程池管理器覺定   
51.     public void execute(Runnable task) {  
52.         synchronized (taskQueue) {  
53.             taskQueue.add(task);  
54.             taskQueue.notify();  
55.         }  
56.     }  
57.   
58.     // 批量執行任務,其實只是把任務加入任務隊列，什麼時候執行有線程池管理器覺定   
59.     public void execute(Runnable[] task) {  
60.         synchronized (taskQueue) {  
61.             for (Runnable t : task)  
62.                 taskQueue.add(t);  
63.             taskQueue.notify();  
64.         }  
65.     }  
66.   
67.     // 批量執行任務,其實只是把任務加入任務隊列，什麼時候執行有線程池管理器覺定   
68.     public void execute(List<Runnable> task) {  
69.         synchronized (taskQueue) {  
70.             for (Runnable t : task)  
71.                 taskQueue.add(t);  
72.             taskQueue.notify();  
73.         }  
74.     }  
75.   
76.     // 銷毀線程池,該方法保證在所有任務都完成的情況下才銷毀所有線程，否則等待任務完成才銷毀   
77.     public void destroy() {  
78.         while (!taskQueue.isEmpty()) {// 如果還有任務沒執行完成，就先睡會吧   
79.             try {  
80.                 Thread.sleep(10);  
81.             } catch (InterruptedException e) {  
82.                 e.printStackTrace();  
83.             }  
84.         }  
85.         // 工作線程停止工作，且置為null   
86.         for (int i = 0; i < worker_num; i++) {  
87.             workThrads[i].stopWorker();  
88.             workThrads[i] = null;  
89.         }  
90.         threadPool=null;  
91.         taskQueue.clear();// 清空任務隊列   
92.     }  
93.   
94.     // 返回工作線程的個數   
95.     public int getWorkThreadNumber() {  
96.         return worker_num;  
97.     }  
98.   
99.     // 返回已完成任務的個數,這裡的已完成是只出了任務隊列的任務個數，可能該任務並沒有實際執行完成   
100.     public int getFinishedTasknumber() {  
101.         return finished_task;  
102.     }  
103.   
104.     // 返回任務隊列的長度，即還沒處理的任務個數   
105.     public int getWaitTasknumber() {  
106.         return taskQueue.size();  
107.     }  
108.   
109.     // 覆蓋toString方法，返回線程池信息：工作線程個數和已完成任務個數   
110.     @Override  
111.     public String toString() {  
112.         return "WorkThread number:" + worker_num + "  finished task number:"  
113.                 + finished_task + "  wait task number:" + getWaitTasknumber();  
114.     }  
115.   
116.     /** 
117.      * 內部類，工作線程 
118.      */  
119.     private class WorkThread extends Thread {  
120.         // 該工作線程是否有效，用於結束該工作線程   
121.         private boolean isRunning = true;  
122.   
123.         /* 
124.          * 關鍵所在啊，如果任務隊列不空，則取出任務執行，若任務隊列空，則等待 
125.          */  
126.         @Override  
127.         public void run() {  
128.             Runnable r = null;  
129.             while (isRunning) {// 注意，若線程無效則自然結束run方法，該線程就沒用了   
130.                 synchronized (taskQueue) {  
131.                     while (isRunning && taskQueue.isEmpty()) {// 隊列為空   
132.                         try {  
133.                             taskQueue.wait(20);  
134.                         } catch (InterruptedException e) {  
135.                             e.printStackTrace();  
136.                         }  
137.                     }  
138.                     if (!taskQueue.isEmpty())  
139.                         r = taskQueue.remove(0);// 取出任務   
140.                 }  
141.                 if (r != null) {  
142.                     r.run();// 執行任務   
143.                 }  
144.                 finished_task++;  
145.                 r = null;  
146.             }  
147.         }  
148.   
149.         // 停止工作，讓該線程自然執行完run方法，自然結束   
150.         public void stopWorker() {  
151.             isRunning = false;  
152.         }  
153.     }  
154. }