Android 線程池來管理線程

網上講了很多的關於線程池的例子。其實在我們實際應用中，譬如說，一個應用的線程是怎樣來管理的，我們就可以說，我們可以使用線程池來管理線程。

eg:

class DianLiang1 implements Runnable {

@Override

punlic void Run{

system.println("*************111111111111111111111****************");

}

}

 

class DianLiang2 implements Runnable{

@Override

punlic void Run{

system.println("***************222222222222222222222222**************");

}

}

class DianLiang3 implements Runnable {

@Override

punlic void Run{

system.println("***************222222222222222222222222**************");

}

}

public void main(){ public static void main(String[] args) {
DianLiang1 t1 = new DianLiang1 (); DianLiang1 t1 = new DianLiang1 ();
DianLiang1 t1 = new DianLiang1 ();
t1 .start();
t2.start(); t3.start(); }
} 這樣問題就來了：

如果說：在住入口裡面：

倘若有多個線程，有100個線程這樣線程就無法進行控制了。

這個時候我們最好用線程池來管理線程。

線程池的基本思想還是一種對象池的思想，開辟一塊內存空間，裡面存放了眾多(未死亡)的線程，池中線程執行調度由池管理器來處理。當有線程任務時，從池中取一個，執行完成後線程對象歸池，這樣可以避免反復創建線程對象所帶來的性能開銷，節省了系統的資源。

比如：一個應用要和網絡打交道，有很多步驟需要訪問網絡，為了不阻塞主線程，每個步驟都創建個線程，在線程中和網絡交互，用線程池就變的簡單，線程池是對線程的一種封裝，讓線程用起來更加簡便，只需要創一個線程池，把這些步驟像任務一樣放進線程池，在程序銷毀時只要調用線程池的銷毀函數即可。

java常用的線程池有三種：

• newFixedThreadPool
  創建一個可重用固定線程數的線程池，以共享的無界隊列方式來運行這些線程。在任意點，在大多數 nThreads 線程會處於處理任務的活動狀態。如果在所有線程處於活動狀態時提交附加任務，則在有可用線程之前，附加任務將在隊列中等待。如果在關閉前的執行期間由於失敗而導致任何線程終止，那麼一個新線程將代替它執行後續的任務（如果需要）。在某個線程被顯式地關閉之前，池中的線程將一直存在。
  　　ExecutorService pool = Executors.newFixedThreadPool(2);
  　　//創建實現了Runnable接口對象，Thread對象當然也實現了Runnable接口
  　　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);
  • newSingleThreadExecutor
    創建一個使用單個 worker 線程的 Executor，以無界隊列方式來運行該線程。（注意，如果因為在關閉前的執行期間出現失敗而終止了此單個線程，那麼如果需要，一個新線程將代替它執行後續的任務）。可保證順序地執行各個任務，並且在任意給定的時間不會有多個線程是活動的。與其他等效的 newFixedThreadPool(1) 不同，可保證無需重新配置此方法所返回的執行程序即可使用其他的線程。
    • newCachedThreadPool
      

      創建一個可根據需要創建新線程的線程池，但是在以前構造的線程可用時將重用它們。對於執行很多短期異步任務的程序而言，這些線程池通常可提高程序性能。調用 execute 將重用以前構造的線程（如果線程可用）。如果現有線程沒有可用的，則創建一個新線程並添加到池中。終止並從緩存中移除那些已有 60 秒鐘未被使用的線程。因此，長時間保持空閒的線程池不會使用任何資源。注意，可以使用 ThreadPoolExecutor 構造方法創建具有類似屬性但細節不同（例如超時參數）的線程池。

       

      以下是 轉載內容：

       

      ThreadPoolExecutor(int corePoolSize, int maximumPoolSize,long keepAliveTime,

      TimeUnit unit,BlockingQueueworkQueue,RejectedExecutionHandler handler)

      corePoolSize： 線程池維護線程的最少數量 maximumPoolSize：線程池維護線程的最大數量 keepAliveTime： 線程池維護線程所允許的空閒時間

      unit： 線程池維護線程所允許的空閒時間的單位 workQueue： 線程池所使用的緩沖隊列 handler： 線程池對拒絕任務的處理策略

      一個任務通過 execute(Runnable)方法被添加到線程池，任務就是一個 Runnable類型的對象，任務的執行方法就是 Runnable類型對象的run()方法。

      當一個任務通過execute(Runnable)方法欲添加到線程池時：

      l 如果此時線程池中的數量小於corePoolSize，即使線程池中的線程都處於空閒狀態，也要創建新的線程來處理被添加的任務。

      2 如果此時線程池中的數量等於 corePoolSize，但是緩沖隊列 workQueue未滿，那麼任務被放入緩沖隊列。

      3 如果此時線程池中的數量大於corePoolSize，緩沖隊列workQueue滿，並且線程池中的數量小於maximumPoolSize，建新的線程來處理被添加的任務。

      4 如果此時線程池中的數量大於corePoolSize，緩沖隊列workQueue滿，並且線程池中的數量等於maximumPoolSize，那麼通過 handler所指定的策略來處理此任務。也就是：處理任務的優先級為：核心線程corePoolSize、任務隊列workQueue、最大線程maximumPoolSize，如果三者都滿了，使用handler處理被拒絕的任務。

      5 當線程池中的線程數量大於 corePoolSize時，如果某線程空閒時間超過keepAliveTime，線程將被終止。這樣，線程池可以動態的調整池中的線程數。

       

      一個 ExecutorService，它使用可能的幾個池線程之一執行每個提交的任務，通常使用 Executors 工廠方法配置。

      線程池可以解決兩個不同問題：由於減少了每個任務調用的開銷，它們通常可以在執行大量異步任務時提供增強的性能，並且還可以提供綁定和管理資源（包括執行集合任務時使用的線程）的方法。每個 ThreadPoolExecutor 還維護著一些基本的統計數據，如完成的任務數。

      為了便於跨大量上下文使用，此類提供了很多可調整的參數和擴展掛鉤。但是，強烈建議程序員使用較為方便的 Executors 工廠方法Executors.newCachedThreadPool()（無界線程池，可以進行自動線程回收）、Executors.newFixedThreadPool(int)（固定大小線程池）和Executors.newSingleThreadExecutor()（單個後台線程），它們均為大多數使用場景預定義了設置。否則，在手動配置和調整此類時，使用以下指導：

      核心和最大池大小

      ThreadPoolExecutor 將根據 corePoolSize（參見 getCorePoolSize()）和 maximumPoolSize（參見 getMaximumPoolSize()）設置的邊界自動調整池大小。當新任務在方法execute(java.lang.Runnable) 中提交時，如果運行的線程少於 corePoolSize，則創建新線程來處理請求，即使其他輔助線程是空閒的。如果運行的線程多於 corePoolSize 而少於 maximumPoolSize，則僅當隊列滿時才創建新線程。如果設置的 corePoolSize 和 maximumPoolSize 相同，則創建了固定大小的線程池。如果將 maximumPoolSize 設置為基本的無界值（如 Integer.MAX_VALUE），則允許池適應任意數量的並發任務。在大多數情況下，核心和最大池大小僅基於構造來設置，不過也可以使用setCorePoolSize(int) 和 setMaximumPoolSize(int) 進行動態更改。

      按需構造

      默認情況下，即使核心線程最初只是在新任務需要時才創建和啟動的，也可以使用方法 prestartCoreThread() 或 prestartAllCoreThreads() 對其進行動態重寫。

      創建新線程

      使用 ThreadFactory 創建新線程。如果沒有另外說明，則在同一個 ThreadGroup 中一律使用 Executors.defaultThreadFactory() 創建線程，並且這些線程具有相同的NORM_PRIORITY 優先級和非守護進程狀態。通過提供不同的 ThreadFactory，可以改變線程的名稱、線程組、優先級、守護進程狀態，等等。如果從 newThread 返回null 時 ThreadFactory 未能創建線程，則執行程序將繼續運行，但不能執行任何任務。

      保持活動時間

      如果池中當前有多於 corePoolSize 的線程，則這些多出的線程在空閒時間超過 keepAliveTime 時將會終止（參見 getKeepAliveTime(java.util.concurrent.TimeUnit)）。這提供了當池處於非活動狀態時減少資源消耗的方法。如果池後來變得更為活動，則可以創建新的線程。也可以使用方法 setKeepAliveTime(long, java.util.concurrent.TimeUnit) 動態地更改此參數。使用 Long.MAX_VALUE TimeUnit.NANOSECONDS 的值在關閉前有效地從以前的終止狀態禁用空閒線程。

      排隊

      所有 BlockingQueue 都可用於傳輸和保持提交的任務。可以使用此隊列與池大小進行交互：

      A. 如果運行的線程少於 corePoolSize，則 Executor 始終首選添加新的線程，而不進行排隊。

      B. 如果運行的線程等於或多於 corePoolSize，則 Executor 始終首選將請求加入隊列，而不添加新的線程。

      C. 如果無法將請求加入隊列，則創建新的線程，除非創建此線程超出 maximumPoolSize，在這種情況下，任務將被拒絕。

      排隊有三種通用策略：

      直接提交。工作隊列的默認選項是 SynchronousQueue，它將任務直接提交給線程而不保持它們。在此，如果不存在可用於立即運行任務的線程，則試圖把任務加入隊列將失敗，因此會構造一個新的線程。此策略可以避免在處理可能具有內部依賴性的請求集合時出現鎖定。直接提交通常要求無界 maximumPoolSizes 以避免拒絕新提交的任務。當命令以超過隊列所能處理的平均數連續到達時，此策略允許無界線程具有增長的可能性。

      無界隊列。使用無界隊列（例如，不具有預定義容量的 LinkedBlockingQueue）將導致在所有 corePoolSize 線程都忙的情況下將新任務加入隊列。這樣，創建的線程就不會超過 corePoolSize。（因此，maximumPoolSize 的值也就無效了。）當每個任務完全獨立於其他任務，即任務執行互不影響時，適合於使用無界隊列；例如，在 Web頁服務器中。這種排隊可用於處理瞬態突發請求，當命令以超過隊列所能處理的平均數連續到達時，此策略允許無界線程具有增長的可能性。

      有界隊列。當使用有限的 maximumPoolSizes 時，有界隊列（如 ArrayBlockingQueue）有助於防止資源耗盡，但是可能較難調整和控制。隊列大小和最大池大小可能需要相互折衷：使用大型隊列和小型池可以最大限度地降低 CPU 使用率、操作系統資源和上下文切換開銷，但是可能導致人工降低吞吐量。如果任務頻繁阻塞（例如，如果它們是 I/O 邊界），則系統可能為超過您許可的更多線程安排時間。使用小型隊列通常要求較大的池大小，CPU 使用率較高，但是可能遇到不可接受的調度開銷，這樣也會降低吞吐量。

      被拒絕的任務

      當 Executor 已經關閉，並且 Executor 將有限邊界用於最大線程和工作隊列容量，且已經飽和時，在方法 execute(java.lang.Runnable) 中提交的新任務將被拒絕。在以上兩種情況下，execute 方法都將調用其 RejectedExecutionHandler 的 RejectedExecutionHandler.rejectedExecution(java.lang.Runnable, java.util.concurrent.ThreadPoolExecutor) 方法。下面提供了四種預定義的處理程序策略：

      A. 在默認的 ThreadPoolExecutor.AbortPolicy 中，處理程序遭到拒絕將拋出運行時 RejectedExecutionException。

      B. 在 ThreadPoolExecutor.CallerRunsPolicy 中，線程調用運行該任務的 execute 本身。此策略提供簡單的反饋控制機制，能夠減緩新任務的提交速度。

      C. 在 ThreadPoolExecutor.DiscardPolicy 中，不能執行的任務將被刪除。

      D. 在 ThreadPoolExecutor.DiscardOldestPolicy 中，如果執行程序尚未關閉，則位於工作隊列頭部的任務將被刪除，然後重試執行程序（如果再次失敗，則重復此過程）。

      定義和使用其他種類的 RejectedExecutionHandler 類也是可能的，但這樣做需要非常小心，尤其是當策略僅用於特定容量或排隊策略時。

      掛鉤方法

      此類提供 protected 可重寫的 beforeExecute(java.lang.Thread, java.lang.Runnable) 和 afterExecute(java.lang.Runnable, java.lang.Throwable) 方法，這兩種方法分別在執行每個任務之前和之後調用。它們可用於操縱執行環境；例如，重新初始化 ThreadLocal、搜集統計信息或添加日志條目。此外，還可以重寫方法 terminated() 來執行 Executor 完全終止後需要完成的所有特殊處理。

      如果掛鉤或回調方法拋出異常，則內部輔助線程將依次失敗並突然終止。

      隊列維護

      方法 getQueue() 允許出於監控和調試目的而訪問工作隊列。強烈反對出於其他任何目的而使用此方法。remove(java.lang.Runnable) 和 purge() 這兩種方法可用於在取消大量已排隊任務時幫助進行存儲回收。