前言:在上一篇文章中我們講到了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() {
@Override
public 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() {
@Override
public void run() {
Log.d( Thread.currentThread().getName() );
}
});
try {
//如果任務結束執行則傳回 null
Log.d( ""+ future.get() );
} catch (Exception e) {
e.printStackTrace();
}
//關閉線程池
executorService.shutdown();
}
}
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>() {
@Override
public 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<>() ;
//建立第一個 Callable
Callable<String> callable1 = new Callable<String>() {
@Override
public String call() throws Exception {
Log.d( "callable 1 線程是: "+ Thread.currentThread().getName() );
return "執行完了 callable 1" ;
}
};
//建立第二個 Callable
Callable<String> callable2 = new Callable<String>() {
@Override
public 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<>() ;
//建立第一個 Callable
Callable<String> callable1 = new Callable<String>() {
@Override
public String call() throws Exception {
Log.d( "callable 1 線程是: "+ Thread.currentThread().getName() );
return "執行完了 callable 1" ;
}
};
//建立第二個 Callable
Callable<String> callable2 = new Callable<String>() {
@Override
public 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
注意: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() 方法。這個方法會嘗試馬上關閉所有正在執行的任務,并且跳過所有已經送出但是還沒有運作的任務。但是對于正在執行的任務,是否能夠成功關閉它是無法保證 的,有可能他們真的被關閉掉了,也有可能它會一直執行到任務結束。這是一個最好的嘗試。