Android(線程二) 線程池詳解

我們在ListView中需要下載資源時，贊不考慮緩存機制，那麼每一個Item可能都需要開啟一個線程去下載資源（如果沒有線程池），如果Item很多，那麼我們可能就會無限制的一直創建新的線程去執行下載任務，最終結果可能導致，應用卡頓、手機反應遲鈍！最壞的結果是，用戶直接卸載掉該App。所以，我們在實際開發中需要考慮多線程，多線程就離不開線程池。
使用線程池的優點：
(1).重用線程，避免線程的創建和銷毀帶來的性能開銷；
(2).能有效控制線程池的最大並發數，避免大量的線程之間因互相搶占系統資源而導致的阻塞現象；
(3).能夠對線程進行簡單的管理，並提供定時執行以及指定間隔循環執行等功能。
Android中的線程池是來自Java。那麼就需要看看Java中的線程池。Java中的線程池有四種：
(1).SingleThreadExecutor，創建一個單線程化的線程池，它只會用唯一的工作線程來執行任務，保證所有任務按照指定順序(FIFO, LIFO, 優先級)執行；
(2).CachedThreadPool，創建一個可緩存線程池，如果線程池長度超過處理需要，可靈活回收空閒線程，若無可回收，則新建線程；
(3).FixedThreadPool，創建一個定長線程池，可控制線程最大並發數，超出的線程會在隊列中等待；
(4).ScheduledThreadPool，創建一個定長線程池，支持定時及周期性任務執行。
PS：創建線程池，使用Executors類。通過這個類能夠獲得多種線程池的實例。Executors的核心構造方法ThreadPoolExecutor(),接下來，我們看看該方法說明，

ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime, TimeUnit unit, BlockingQueue workQueue, ThreadFactory threadFactory,RejectedExecutionHandler handler)

參數說明：
corePoolSize 線程池維護線程的最少數量（核心線程數量），默認情況下，核心線程會在線程池中一直存活，即使它們處於閒置狀態。如果將ThreadPoolExecutor的allowCoreThreadTimeOut屬性設置為true，那麼閒置的核心線程在等待新任務到來時會有超市策略，這個時間間隔由keepAliveTime所指定，當等待時間超過keepAliveTime所指定的時長後，核心線程就會被終止。
maximumPoolSize 線程池維護線程的最大數量，當活動線程達到這個數值後，後續的新人無語將會被阻塞。
keepAliveTime 線程池中超過corePoolSize數目的空閒線程最大存活時間；可以allowCoreThreadTimeOut(true)使得核心線程有效時間。

unit keepAliveTime時間單位,有7種取值，在TimeUnit類中有7種靜態屬性：

 

TimeUnit.DAYS;               //天
TimeUnit.HOURS;             //小時
TimeUnit.MINUTES;           //分鐘
TimeUnit.SECONDS;           //秒
TimeUnit.MILLISECONDS;      //毫秒
TimeUnit.MICROSECONDS;      //微妙
TimeUnit.NANOSECONDS;       //納秒

workQueue 線程池所使用的緩沖隊列，通過線程池的execute方法提交的Runnable對象會存儲在這個參數中。
threadFactory 新建線程工廠，為線程池提供創建新線程的功能，ThreadFactory是一個接口，它只有一個方法：Thread newThread(Runnable r).
handler 當提交任務數超過maxmumPoolSize+workQueue之和時，任務會交給RejectedExecutionHandler來處理；
其中corePoolSize，maximumPoolSize，workQueue之間關系，如下描述，
(1).當線程池小於corePoolSize時，新提交任務將創建一個新線程執行任務，即使此時線程池中存在空閒線程;
(2).當線程池達到corePoolSize時，新提交任務將被放入workQueue中，等待線程池中任務調度執行 ;
(3).當workQueue已滿，且maximumPoolSize>corePoolSize時，新提交任務會創建新線程執行任務 ;
(4).當提交任務數超過maximumPoolSize時，新提交任務由RejectedExecutionHandler處理 ;
(5).當線程池中超過corePoolSize線程，空閒時間達到keepAliveTime時，關閉空閒線程 ;
(6).當設置allowCoreThreadTimeOut(true)時，線程池中corePoolSize線程空閒時間達到keepAliveTime也將關閉 。
1.SingleThreadExecutor。

ExecutorService pool = Executors.newSingleThreadExecutor();

創建一個使用單個 worker 線程的 Executor，以無界隊列方式來運行該線程。（注意，如果因為在關閉前的執行期間出現失敗而終止了此單個線程，那麼如果需要，一個新線程將代替它執行後續的任務）。可保證順序地執行各個任務，並且在任意給定的時間不會有多個線程是活動的。接著看看newSingleThreadExecutor源碼實現，

 public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue()));
    }

構造一個只支持一個線程的線程池，配置corePoolSize=maximumPoolSize=1，無界阻塞隊列LinkedBlockingQueue；保證任務由一個線程串行執行 。示例代碼：

public static void singThreadExecutors() {
		ExecutorService pool = Executors.newSingleThreadExecutor();
		// 創建實現了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);
		// 關閉線程池
		pool.shutdown();
	}

class MyThread extends Thread {
	@Override
	public void run() {
		try {
			System.out.println(Thread.currentThread().getName()
					+ " is running...");
			Thread.sleep(2000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

每隔2秒打印一次。結果依次輸出，相當於順序執行各個任務，運行截圖：

現行大多數GUI程序都是單線程的。Android中單線程可用於數據庫操作，文件操作，應用批量安裝，應用批量刪除等不適合並發但可能IO阻塞性及影響UI線程響應的操作。

這類線程池內部只有一個核心線程，它確保所有的任務都在同一個線程中順序執行。SingleThreadExecutor的意義在於統一所有的外界任務到一個線程中，這使得在這些任務之間不需要處理線程同步的問題。

2.CachedThreadPool。

ExecutorService pool = Executors.newCachedThreadPool();

創建一個可緩存的線程池。如果線程池的大小超過了處理任務所需要的線程，那麼就會回收部分空閒（60秒不執行任務）的線程，當任務數增加時，此線程池又可以智能的添加新線程來處理任務。此線程池不會對線程池大小做限制，線程池大小完全依賴於操作系統（或者說JVM）能夠創建的最大線程大小。接著看看newCachedThreadPool源碼實現，

 public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue());
    }

核心線程為0，最大線程數為231-1，線程keepAliveTime為60，單位為秒，緩存隊列為SynchronousQueue的線程池，因為多個線程共用一個SynchronousQueue，所以必須保證各個線程對SynchronousQueue的訪問是串行的，也就是前一個線程沒有使用完，後一個線程就必須等待，以保證SynchronousQueue內部數據的完整性。示例代碼：

public static void cachedThreadPool() {
		ExecutorService pool = Executors.newCachedThreadPool();
		// 創建實現了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);
		// 關閉線程池
		pool.shutdown();
	}

創建了5個線程分別執行不同的任務，運行截圖：

它是一種線程數量不定的線程池，它只有非核心線程，並且最大線程數為231-1。由於是一個很大的書，實際上就相當於最大線程數可以任意大。當線程池中的線程都處於活動狀態時，線程池會創建新的線程來處理新任務，否則就會利用空閒的線程來處理新任務。線程池中的空閒線程都有超時機制，這個超時時長為60秒，超過60秒閒置的線程就會被回收。和FixedThreadPool不同的是，CachedThreadPool的任務隊列其實相當於一個空集合，這將導致任何任務都會被立即執行，因為在這種場景下SynchronousQueue是無法插入任務的。這類線程池比較適合執行大量的耗時較少的任務。當整個線程池都處於閒置狀態時，線程池中的線程都會超時而被終止，這個時候CachedThreadPool之中實際上是沒有任何線程的，它幾乎是不占用任何系統資源的。

3.FixedThreadPool。

ExecutorService pool = Executors.newFixedThreadPool(int nThreads);

創建一個可重用固定線程數的線程池，nThreads=3表示創建了3個線程的線程池（定長線程池的大小最好根據系統資源進行設置），接著看看newFixedThreadPool源碼實現，

public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue());
    }

corePoolSize和maximumPoolSize的大小是一樣的,都是根據傳遞的參數設置的，keepAliveTime為0，表示不想keep alive。示例代碼：

public static void fixedThreadPool() {
		ExecutorService pool = Executors.newFixedThreadPool(3);
		// 創建實現了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);
		// 關閉線程池
		pool.shutdown();
	}

線程池的線程數量固定為3，首先創建3個線程去執行，執行完後變為空閒狀態，接著再執行其他等待任務，運行截圖：

它是一種線程數量固定的線程池，當線程處於空閒狀態時，他們並不會被回收，除非線程池被關閉了。當所有的線程都處於活動狀態時，新任務都處於等待狀態，直到有線程空閒出來。由於FixedThreadPool 只有核心線程並且這些核心線程不會被回收，這意味著它能夠更加快速地響應外界的請求。

4.ScheduledThreadPool。

ScheduledExecutorService pool = Executors.newScheduledThreadPool(int corePoolSize)

接著看看newScheduledThreadPool的源碼，

 public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
        return new ScheduledThreadPoolExecutor(corePoolSize);
    }

public ScheduledThreadPoolExecutor(int corePoolSize) {
        super(corePoolSize, Integer.MAX_VALUE,
              DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,
              new DelayedWorkQueue());
    }

示例代碼：

 

 ScheduledExecutorService scheduledExecutorService=Executors.newScheduledThreadPool(4);
 //2000ms 後執行command
 scheduledExecutorService.schedule(command,2000,TimeUnit.MILLISECONDS);
 //延遲10ms後，每隔 1000ms執行一次command
 scheduledExecutorService.scheduleAtFixedRate(command,10,1000,TimeUnit.MILLISECONDS);

 

它的核心線程數據是固定的，而非核心線程數是沒有限制的，並且當非核心線程限制時會被立即回收。ScheduledThreadPool這類線程池主要用於執行定時任務和具有固定周期的重復任務。

總結：

(1).最大線程數一般設為2N+1最好，N是CPU核數；

(2).看過AsyncTask源碼的同學就會知道，其實它的內部也是一個線程池；

(3).當創建線程池後，初始時，線程池處於RUNNING狀態；
(4).如果調用了shutdown()方法，則線程池處於SHUTDOWN狀態，此時線程池不能夠接受新的任務，它會等待所有任務執行完畢；
(5).如果調用了shutdownNow()方法，則線程池處於STOP狀態，此時線程池不能接受新的任務，並且會去嘗試終止正在執行的任務；
(6).當線程池處於SHUTDOWN或STOP狀態，並且所有工作線程已經銷毀，任務緩存隊列已經清空或執行結束後，線程池被設置為TERMINATED狀態。

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

PS:

並行和並發區別

1、並行是指兩者同時執行一件事，比如賽跑，兩個人都在不停的往前跑；
2、並發是指資源有限的情況下，兩者交替輪流使用資源，比如一段路(單核CPU資源)同時只能過一個人，A走一段後，讓給B，B用完繼續給A ，交替使用，目的是提高效率