【Android】線程池原理及Java簡單實現

線程池簡介

　　多線程技術主要解決處理器單元內多個線程執行的問題，它能夠顯著減小處理器單元的閒置時間，增長處理器單元的吞吐能力。    

　　假設一個服務器完成一項任務所需時間爲：

1. T1 建立線程時間
2. T2 在線程中執行任務的時間
3. 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）來完成。

用Java實現簡單的線程池　　

　　線程池實現

  1 import java.util.List;
  2 import java.util.Vector;
  3 
  4 /**
  5  * 
  6  * @description：線程池
  7  * @author liuchengwei（wwwlllll@126.com）
  8  * @date Sep 19, 2014 10:15:32 PM
  9  */
 10 public class ThreadPool {
 11     private static ThreadPool instance_ = null;
 12     //定義優先級別常數，空閒的線程按照優先級不一樣分別存放在三個vector中
 13     public static final int LOW_PRIORITY = 0;
 14     public static final int NORMAL_PRIORITY = 1;
 15     public static final int HIGH_PRIORITY = 2;
 16     //保存空閒線程的List，或者說它是"池"
 17     private List<PooledThread>[] idleThreads_;
 18     private boolean shutDown_ = false;
 19     private int threadCreationCounter_; //以建立的線程的個數
 20     private boolean debug_ = false; //是否輸出調試信息
 21 
 22     //構造函數，由於這個類視做爲singleton實現的，所以構造函數爲私有
 23     private ThreadPool() {
 24         // 產生空閒線程.三個vector分別存放分別處在三個優先級的線程的引用
 25         List[] idleThreads = { new Vector(5), new Vector(5), new Vector(5) };
 26         idleThreads_ = idleThreads;
 27         threadCreationCounter_ = 0;
 28     }
 29 
 30     public int getCreatedThreadsCount() {
 31         return threadCreationCounter_;
 32     }
 33 
 34     //經過這個函數獲得線程池類的實例
 35     public static ThreadPool instance() {
 36         if (instance_ == null)
 37             instance_ = new ThreadPool();
 38         return instance_;
 39     }
 40 
 41     public boolean isDebug() {
 42         return debug_;
 43     }
 44 
 45     /**
 46      * 
 47      * @description：
 48      * 將線程repoolingThread重新放回到池中，這個方式是同步方法。
 49      * 這個方法會在多線程的環境中調用，設計這個方法的目的是讓工做者線程
 50      * 在執行完target中的任務後，調用池類的repool()方法，
 51      * 將線程自身重新放回到池中。只因此這麼作是由於線程池並不能預見到
 52      * 工做者線程什麼時候會完成任務。
 53      * @author liuchengwei（wwwlllll@126.com）
 54      * @date Sep 19, 2014 10:15:59 PM
 55      */
 56     protected synchronized void repool(PooledThread repoolingThread) {
 57         if (!shutDown_) {
 58             if (debug_) {
 59                 System.out.println("ThreadPool.repool() : repooling ");
 60             }
 61             switch (repoolingThread.getPriority()) {
 62                 case Thread.MIN_PRIORITY: {
 63                     idleThreads_[LOW_PRIORITY].add(repoolingThread);
 64                     break;
 65                 }
 66                 case Thread.NORM_PRIORITY: {
 67                     idleThreads_[NORMAL_PRIORITY].add(repoolingThread);
 68                     break;
 69                 }
 70                 case Thread.MAX_PRIORITY: {
 71                     idleThreads_[HIGH_PRIORITY].add(repoolingThread);
 72                     break;
 73                 }
 74                 default:
 75                     throw new IllegalStateException("Illegal priority found while repooling a Thread!");
 76             }
 77             notifyAll();//通知全部的線程
 78         }
 79         else {
 80             if (debug_) {
 81                 System.out.println("ThreadPool.repool() : Destroying incoming thread.");
 82             }
 83             repoolingThread.shutDown();//關閉線程
 84         }
 85         if (debug_) {
 86             System.out.println("ThreadPool.recycle() : done.");
 87         }
 88     }
 89 
 90     public void setDebug(boolean newDebug) {
 91         debug_ = newDebug;
 92     }
 93 
 94     //中止池中全部線程
 95     public synchronized void shutdown() {
 96         shutDown_ = true;
 97         if (debug_) {
 98             System.out.println("ThreadPool : shutting down ");
 99         }
100         for (int prioIndex = 0; prioIndex <= HIGH_PRIORITY; prioIndex++) {
101             List prioThreads = idleThreads_[prioIndex];
102             for (int threadIndex = 0; threadIndex < prioThreads.size(); threadIndex++) {
103                 PooledThread idleThread = (PooledThread) prioThreads.get(threadIndex);
104                 idleThread.shutDown();
105             }
106         }
107         notifyAll();
108         if (debug_) {
109             System.out.println("ThreadPool : shutdown done.");
110         }
111     }
112 
113     //以Runnable爲target，從池中選擇一個優先級爲priority的線程建立線程並讓線程運行。
114     public synchronized void start(Runnable target, int priority) {
115         PooledThread thread = null; //被選出來執行target的線程
116         List idleList = idleThreads_[priority];
117         if (idleList.size() > 0) {
118             /**
119              * 若是池中相應優先級的線程有空閒的，那麼從中取出一個
120              * 設置它的target，並喚醒它
121              * 從空閒的線程隊列中獲取
122              * 
123              * @author liuchengwei（wwwlllll@126.com）
124              */
125             int lastIndex = idleList.size() - 1;
126             thread = (PooledThread) idleList.get(lastIndex);
127             idleList.remove(lastIndex);
128             thread.setTarget(target);
129         }
130         //池中沒有相應優先級的線程
131         else {
132             threadCreationCounter_++;
133             // 建立新線程，
134             thread = new PooledThread(target, "PooledThread #" + threadCreationCounter_, this);
135             // 新線程放入池中
136             switch (priority) {
137                 case LOW_PRIORITY: {
138                     thread.setPriority(Thread.MIN_PRIORITY);
139                     break;
140                 }
141                 case NORMAL_PRIORITY: {
142                     thread.setPriority(Thread.NORM_PRIORITY);
143                     break;
144                 }
145                 case HIGH_PRIORITY: {
146                     thread.setPriority(Thread.MAX_PRIORITY);
147                     break;
148                 }
149                 default: {
150                     thread.setPriority(Thread.NORM_PRIORITY);
151                     break;
152                 }
153             }
154             //啓動這個線程
155             thread.start();
156         }
157     }
158 }

View Code

　　工做者線程實現

  1 /**
  2  * 
  3  * @description：線程
  4  * @author liuchengwei（wwwlllll@126.com）
  5  * @date Sep 19, 2014 9:39:34 PM
  6  */
  7 public class PooledThread extends Thread {
  8     private ThreadPool pool_; // 池中線程須要知道本身所在的池
  9     private Runnable target_; // 線程的任務
 10     private boolean shutDown_ = false;
 11     private boolean idle_ = false;//設置是否讓線程處於等待狀態
 12 
 13     private PooledThread() {
 14         super();
 15     }
 16 
 17     private PooledThread(Runnable target) {
 18         super(target); //初始化父類
 19     }
 20 
 21     private PooledThread(Runnable target, String name) {
 22         super(target, name);
 23     }
 24 
 25     public PooledThread(Runnable target, String name, ThreadPool pool) {
 26         super(name);
 27         pool_ = pool;
 28         target_ = target;
 29     }
 30 
 31     private PooledThread(String name) {
 32         super(name);//初始化父類
 33     }
 34 
 35     private PooledThread(ThreadGroup group, Runnable target) {
 36         super(group, target);
 37     }
 38 
 39     private PooledThread(ThreadGroup group, Runnable target, String name) {
 40         super(group, target, name);
 41     }
 42 
 43     private PooledThread(ThreadGroup group, String name) {
 44         super(group, name);
 45     }
 46 
 47     public java.lang.Runnable getTarget() {
 48         return target_;
 49     }
 50 
 51     public boolean isIdle() {
 52         return idle_;//返回當前的狀態
 53     }
 54 
 55     /**
 56      * 工做者線程與一般線程不一樣之處在於run()方法的不一樣。一般的線程，
 57      * 完成線程應該執行的代碼後，天然退出，線程結束。
 58      * 虛擬機在線程結束後收回分配給線程的資源，線程對象被垃圾回收。
 59      * 而這在池化的工做者線程中是應該避免的，不然線程池就失去了意義。
 60      * 做爲能夠被放入池中並從新利用的工做者線程，它的run()方法不該該結束，
 61      * 隨意，在隨後能夠看到的實現中，run()方法執行完target對象的代碼後，
 62      * 就將自身repool()，而後調用wait()方法，使本身睡眠而不是退出循環和run()。
 63      * 這就使線程池實現的要點。
 64      * 
 65      * @author liuchengwei（wwwlllll@126.com）
 66      */
 67     public void run() {
 68         // 這個循環不能結束，除非池類要求線程結束
 69         // 每一次循環都會執行一次池類分配給的任務target
 70         while (!shutDown_) {
 71             idle_ = false;
 72             if (target_ != null) {
 73                 target_.run(); // 運行target中的代碼
 74             }
 75             idle_ = true;
 76             try {
 77                 //線程通知池從新將本身放回到池中
 78                 pool_.repool(this); // 
 79                 //進入池中後睡眠，等待被喚醒執行新的任務，
 80                 //這裏是線程池中線程於普通線程的run()不一樣的地方。
 81                 synchronized (this) {
 82                     wait();
 83                 }
 84             }
 85             catch (InterruptedException ie) {
 86             }
 87             idle_ = false;
 88         }
 89         //循環這裏不能結束，不然線程結束，資源被VM收回，
 90         //就沒法起到線程池的做用了
 91     }
 92 
 93     public synchronized void setTarget(java.lang.Runnable newTarget) {//設置新的target，並喚醒睡眠中的線程
 94         target_ = newTarget; // 新任務
 95         notifyAll(); // 喚醒睡眠的線程
 96     }
 97 
 98     public synchronized void shutDown() {
 99         shutDown_ = true;
100         notifyAll();
101     }
102 }

View Code

　　測試代碼

 1 public class Test {
 2     public static void main(String[] args) {
 3         System.out.println("Testing ThreadPool ");
 4         System.out.println("Creating ThreadPool ");
 5         ThreadPool pool = ThreadPool.instance();
 6         pool.setDebug(true);
 7         class TestRunner implements Runnable {
 8             public int count = 0;
 9 
10             public void run() {
11                 System.out.println("Testrunner sleeping 5 seconds ");
12                 //此方法使本線程睡眠5秒
13                 synchronized (this) {
14                     try {
15                         wait(5000);//等待5秒時間
16                     }
17                     catch (InterruptedException ioe) {
18                     }
19                 }
20                 System.out.println("Testrunner leaving  ");
21                 count++;
22             }
23         }
24         System.out.println("Starting a new thread ");
25         TestRunner runner = new TestRunner();
26         pool.start(runner, pool.HIGH_PRIORITY);
27         System.out.println("count : " + runner.count);
28         System.out.println("Thread count : " + pool.getCreatedThreadsCount());
29         pool.shutdown();
30     }
31 
32 }

View Code