Android 自訂線程池的實戰

標籤：

前言：在上一篇文章中我們講到了AsyncTask的基本使用、AsyncTask的封裝、AsyncTask 的串列/並行線程隊列、自訂線程池、線程池的快速建立方式。

對線程池不瞭解的同學可以先看 Android AsyncTask 深度理解、簡單封裝、任務隊列分析、自訂線程池 

 

-------------------------------------------------------------------------------------------------------

1、Executor 簡介

     在Java 5之後，並發編程引入了一堆新的啟動、調度和管理線程的API。Executor架構便是Java 5中引入的，其內部使用了線程池機制，它在java.util.cocurrent 包下，通過該架構來控制線程的啟動、執行和關閉，可以簡化並發編程的操作。因此，在Java 5之後，通過Executor來啟動線程比使用Thread的start方法更好，除了更易管理，效率更好（用線程池實現，節約開銷）外，還有關鍵的一點：有助於避免this逃逸問題——如果我們在構造器中啟動一個線程，因為另一個任務可能會在構造器結束之前開始執行，此時可能會訪問到初始化了一半的對象用Executor在構造器中。

   Executor架構套件括：線程池，Executor，Executors，ExecutorService，CompletionService，Future，Callable等。

   在java代碼中 Executor是一個介面，只有一個方法。

public interface Executor {    /**     * Executes the given command at some time in the future.  The command     * may execute in a new thread, in a pooled thread, or in the calling     * thread, at the discretion of the {@code Executor} implementation.     *     * @param command the runnable task     * @throws RejectedExecutionException if this task cannot be     * accepted for execution     * @throws NullPointerException if command is null     */    void execute(Runnable command);}

　　

2、ExecutorService 

     ExecutorService 是一個介面，繼承 Executor ，除了有execute( Runnable command) 方法外，還拓展其他的方法：    

public interface ExecutorService extends Executor {}

• void shutdown();

• List<Runnable> shutdownNow();

• boolean isShutdown();

• boolean isTerminated();

• boolean awaitTermination(long timeout, TimeUnit unit)
      throws InterruptedException;

• <T> Future<T> submit(Callable<T> task);             //提交一個任務

• <T> Future<T> submit(Runnable task, T result);      //提交一個任務

• Future<?> submit(Runnable task);                    //提交一個任務

• <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
      throws InterruptedException;

• <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
                                long timeout, TimeUnit unit)
      throws InterruptedException;

• <T> T invokeAny(Collection<? extends Callable<T>> tasks)
      throws InterruptedException, ExecutionException;

• <T> T invokeAny(Collection<? extends Callable<T>> tasks,
                  long timeout, TimeUnit unit)
      throws InterruptedException, ExecutionException, TimeoutException;

   2.1 execute(Runnable)

        接收一個 java.lang.Runnable 對象作為參數，並且以非同步的方式執行它。如下是一個使用 ExecutorService 執行 Runnable 的例子

package com.app;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;public class ExecutorTest {public static void main(String[] args) {//建立一個線程數固定大小為10的線程池ExecutorService executorService = Executors.newFixedThreadPool( 10 ) ;//執行一個任務  該任務是 new Runnable() 對象executorService.execute( new Runnable() {@Overridepublic void run() {              Log.d( Thread.currentThread().getName() );}});//關閉線程池executorService.shutdown();}}

　　結果：

pool-1-thread-1

     使用這種方式沒有辦法擷取執行 Runnable 之後的結果，如果你希望擷取運行之後的傳回值，就必須使用 接收 Callable 參數的 execute() 方法，後者將會在下文中提到。

 

     2.2、 submit(Runnable)

        方法 submit(Runnable) 同樣接收一個 Runnable 的實現作為參數，但是會返回一個 Future 對象。這個 Future 對象可以用於判斷 Runnable 是否結束執行。如下是一個 ExecutorService 的 submit() 方法的例子：

package com.app;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.Future;public class ExecutorTest {public static void main(String[] args) {//建立一個線程數固定大小為10的線程池ExecutorService executorService = Executors.newFixedThreadPool( 10 ) ;//執行一個任務  該任務是 new Runnable() 對象Future future = executorService.submit( new Runnable() {@Overridepublic void run() {Log.d( Thread.currentThread().getName() );}});try {//如果任務結束執行則返回 nullLog.d( ""+ future.get() );} catch (Exception e) {e.printStackTrace();} //關閉線程池executorService.shutdown();}}

　　結果：

pool-1-thread-1
null

         2.3 submit(Callable)

       方法 submit(Callable) 和方法 submit(Runnable) 比較類似，但是區別則在於它們接收不同的參數類型。Callable 的執行個體與 Runnable 的執行個體很類似，但是 Callable 的 call() 方法可以返回壹個結果。方法 Runnable.run() 則不能返回結果。

      Callable 的傳回值可以從方法 submit(Callable) 返回的 Future 對象中擷取。如下是一個 ExecutorService Callable 的例子：

package com.app;import java.util.concurrent.Callable;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.Future;public class ExecutorTest {public static void main(String[] args) {//建立一個線程數固定大小為10的線程池ExecutorService executorService = Executors.newFixedThreadPool( 10 ) ;//執行一個任務  該任務是 new Callable() 對象Future future  = executorService.submit( new Callable<String>() {@Overridepublic String call() throws Exception {return "執行完了" ;}}) ;try {//如果任務結束執行則返回 Log.d( "結果是： "+ future.get() );} catch (Exception e) {e.printStackTrace();} //關閉線程池executorService.shutdown();}}

　　結果：

結果是： 執行完了

 

   2.4、inVokeAny()

       方法 invokeAny() 接收一個包含 Callable 對象的集合作為參數。調用該方法不會返回 Future 對象，而是返回集合中某一個 Callable 對象的結果，而且無法保證調用之後返回的結果是哪一個 Callable，只知道它是這些 Callable 中一個執行結束的 Callable 對象。如果一個任務運行完畢或者拋出異常，方法會取消其它的 Callable 的執行。

package com.app;import java.util.ArrayList;import java.util.List;import java.util.concurrent.Callable;import java.util.concurrent.ExecutionException;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;public class ExecutorTest {public static void main(String[] args) {//建立一個線程數固定大小為10的線程池ExecutorService executorService = Executors.newFixedThreadPool( 10 ) ;List<Callable<String>> list = new ArrayList<>() ;//建立第一個 CallableCallable<String> callable1 = new Callable<String>() {@Overridepublic String call() throws Exception {Log.d( "callable 1 線程是： "+ Thread.currentThread().getName()  );return "執行完了 callable 1" ;}};//建立第二個 CallableCallable<String> callable2 = new Callable<String>() {@Overridepublic String call() throws Exception {Log.d( "callable 2 線程是： "+ Thread.currentThread().getName()  );return "執行完了 callable 2" ;}};list.add( callable1 ) ;list.add( callable2 ) ;try { String result = executorService.invokeAny( list ) ; Log.d( "結果是： "+ result  );} catch (InterruptedException e1) {e1.printStackTrace();} catch (ExecutionException e1) {e1.printStackTrace();}//關閉線程池executorService.shutdown();}}

　　結果：

callable 1 線程是： pool-1-thread-1

callable 2 線程是： pool-1-thread-2
結果是： 執行完了 callable 2

     總結：

       1、可以看到 Callable 裡面的call方法，都是在子線程中啟動並執行，

         2、 executorService.invokeAny( list ) ;傳回值是任意一個 Callable 的傳回值 。具體是哪一個，每個都有可能。

 

    2.5、invokeAll()

 方法 invokeAll() 會調用存在於參數集合中的所有 Callable 對象，並且返回一個包含 Future 對象的集合，你可以通過這個返回的集合來管理每個 Callable 的執行結果。需要注意的是，任務有可能因為異常而導致運行結束，所以它可能並不是真的成功運行了。但是我們沒有辦法通過 Future 對象來瞭解到這個差異。

package com.app;import java.util.ArrayList;import java.util.List;import java.util.concurrent.Callable;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.Future;public class ExecutorTest {public static void main(String[] args) {//建立一個線程數固定大小為10的線程池ExecutorService executorService = Executors.newFixedThreadPool( 10 ) ;List<Callable<String>> list = new ArrayList<>() ;//建立第一個 CallableCallable<String> callable1 = new Callable<String>() {@Overridepublic String call() throws Exception {Log.d( "callable 1 線程是： "+ Thread.currentThread().getName()  );return "執行完了 callable 1" ;}};//建立第二個 CallableCallable<String> callable2 = new Callable<String>() {@Overridepublic String call() throws Exception {Log.d( "callable 2 線程是： "+ Thread.currentThread().getName()  );return "執行完了 callable 2" ;}};list.add( callable1 ) ;list.add( callable2 ) ;List<Future<String>> result;try {result = executorService.invokeAll( list );for (Future<String> future : result) {Log.d( "結果是： "+ future.get()  );}} catch (Exception e) {e.printStackTrace();}//關閉線程池executorService.shutdown();}}

　　結果

callable 1 線程是： pool-1-thread-1
callable 2 線程是： pool-1-thread-2
結果是： 執行完了 callable 1
結果是： 執行完了 callable 2

    注意：1：Callable 的call方法都是執行在子線程中的

            2： executorService.invokeAll( list ) 是傳回值。 但是必須是所有的 Callable對象執行完了，才會返回，傳回值是一個list, 順序和 List<Callable>一樣 。在執行的過程中，如果任何一個Callable發生異常，程式會崩潰，沒有傳回值。

       

     2.6 如何關閉 ExecuteService 服務 ？

當使用 ExecutorService 完畢之後，我們應該關閉它，這樣才能保證線程不會繼續保持運行狀態。 舉例來說，如果你的程式通過 main() 方法啟動，並且主線程退出了你的程式，如果你還有一個活動的 ExecutorService 存在於你的程式中，那麼程式將會繼續保持運行狀態。存在於 ExecutorService 中的活動線程會阻Java虛擬機器關閉。 

為了關閉在 ExecutorService 中的線程，你需要調用 shutdown() 方法。ExecutorService 並不會馬上關閉，而是不再接收新的任務，一旦所有的線程結束執行當前任務，ExecutorServie 才會真的關閉。所有在調用 shutdown() 方法之前提交到 ExecutorService 的任務都會執行。 
如果你希望立即關閉 ExecutorService，你可以調用 shutdownNow() 方法。這個方法會嘗試馬上關閉所有正在執行的任務，並且跳過所有已經提交但是還沒有啟動並執行任務。但是對於正在執行的任務，是否能夠成功關閉它是無法保證 的，有可能他們真的被關閉掉了，也有可能它會一直執行到任務結束。這是一個最好的嘗試。 

 

Android 自訂線程池的實戰