Android(執行緒二) 執行緒池詳解

阿新 • • 發佈：2018-12-23

我們在ListView中需要下載資源時，贊不考慮快取機制，那麼每一個Item可能都需要開啟一個執行緒去下載資源（如果沒有執行緒池），如果Item很多，那麼我們可能就會無限制的一直建立新的執行緒去執行下載任務，最終結果可能導致，應用卡頓、手機反應遲鈍！最壞的結果是，使用者直接解除安裝掉該App。所以，我們在實際開發中需要考慮多執行緒，多執行緒就離不開執行緒池。如果你對執行緒還不瞭解，可以看看這篇文章，Android(執行緒一) 執行緒。
使用執行緒池的優點：
(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<Runnable> 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也將關閉。

PS:在ThreadPoolExecutor類中有幾個非常重要的方法：
1.execute()
實際上是Executor中宣告的方法，在ThreadPoolExecutor進行了具體的實現，這個方法是ThreadPoolExecutor的核心方法，通過這個方法可以向執行緒池提交一個任務，交由執行緒池去執行。
2.submit()
在ExecutorService中宣告的方法，在AbstractExecutorService就已經有了具體的實現，在ThreadPoolExecutor中並沒有對其進行重寫，這個方法也是用來向執行緒池提交任務的，但是它和execute()方法不同，它能夠返回任務執行的結果，去看submit()方法的實現，會發現它實際上還是呼叫的execute()方法，只不過它利用了Future來獲取任務執行結果。
3.shutdown()
執行緒池處於SHUTDOWN狀態，此時執行緒池不能夠接受新的任務，它會等待所有任務執行完畢；
4.shutdownNow()
執行緒池處於STOP狀態，此時執行緒池不能接受新的任務，並且會去嘗試終止正在執行的任務；

Future是對於具體的Runnable或者Callable任務的執行結果進行取消、查詢是否完成、獲取結果。必要時可以通過get方法獲取執行結果，該方法會阻塞直到任務返回結果。
在Future介面中聲明瞭5個方法，下面依次解釋每個方法的作用：
cancel方法用來取消任務，如果取消任務成功則返回true，如果取消任務失敗則返回false。引數mayInterruptIfRunning表示是否允許取消正在執行卻沒有執行完畢的任務，如果設定true，則表示可以取消正在執行過程中的任務。如果任務已經完成，則無論mayInterruptIfRunning為true還是false，此方法肯定返回false，即如果取消已經完成的任務會返回false；如果任務正在執行，若mayInterruptIfRunning設定為true，則返回true，若mayInterruptIfRunning設定為false，則返回false；如果任務還沒有執行，則無論mayInterruptIfRunning為true還是false，肯定返回true。
isCancelled方法表示任務是否被取消成功，如果在任務正常完成前被取消成功，則返回 true。
isDone方法表示任務是否已經完成，若任務完成，則返回true；
get()方法用來獲取執行結果，這個方法會產生阻塞，會一直等到任務執行完畢才返回；
get(long timeout, TimeUnit unit)用來獲取執行結果，如果在指定時間內，還沒獲取到結果，就直接返回null。
　　也就是說Future提供了三種功能：
　　1）判斷任務是否完成；
　　2）能夠中斷任務；
　　3）能夠獲取任務執行結果。

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<Runnable>()));
    }

構造一個只支援一個執行緒的執行緒池，配置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<Runnable>());
    }

核心執行緒為0，最大執行緒數為2³¹-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個執行緒分別執行不同的任務，執行截圖：

它是一種執行緒數量不定的執行緒池，它只有非核心執行緒，並且最大執行緒數為2³¹-1。由於2³¹-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<Runnable>());
    }

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());
    }

super(corePoolSize, Integer.MAX_VALUE,DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS, new DelayedWorkQueue())的原始碼如下，依然是呼叫ThreadPoolExecutor去建立執行緒池，

   public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), defaultHandler);
    }

每一個被排程的任務都會由執行緒池中一個執行緒去執行，因此任務是併發執行的，相互之間不會受到干擾。需要注意的是，只有當任務的執行時間到來時，ScheduedExecutor 才會真正啟動一個執行緒，其餘時間 ScheduledExecutor 都是在輪詢任務的狀態。

示例程式碼：

 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 ，交替使用，目的是提高效率

有關併發和並行更加詳細的描述，請看這篇文章，併發和並行淺談。

參考資料：《Android開發藝術探索》。

Android(執行緒二) 執行緒池詳解

Android(執行緒二) 執行緒池詳解

Android執行緒池詳解

ExecutorService執行緒池詳解

Java 執行緒池詳解

Java執行緒池詳解及例項

執行緒池詳解

ThreadPoolExecutor機制&執行緒池詳解

雜談——Java執行緒池詳解

四大執行緒池詳解

Tomcat 連線數與執行緒池詳解 | BIO/NIO有何不同 | 簡談Kafka中的NIO網路通訊模型

【搞定Java併發程式設計】第28篇：Java中的執行緒池詳解

android RXJava2.0(二)--執行緒控制

Java併發：執行緒池詳解（ThreadPoolExecutor）

Java執行緒池詳解，看這篇就夠了！

【本人禿頂程式設計師】Java執行緒池詳解，看這篇就夠了！

Java多執行緒-----執行緒池詳解

java 執行緒池詳解及四種執行緒池用法介紹

java四種執行緒池詳解與使用

各種Map和執行緒池詳解

JAVA四種執行緒池詳解

Android(執行緒二) 執行緒池詳解

相關推薦