AsyncTask能夠適當簡單的使用在UI線程,在沒有任務線程和handler的情況下,這個類也允許執行後臺操作並將結果顯示在UI線程上。
AsyncTask的引入,我們在執行完耗時的後臺任務後可以很方便的更新UI元素。相信大多數同學對AsyncTask的用法都已經很熟悉,那這裏不在敘述他的基本用法了。
AsyncTask的實現原理是封裝線程池和消息機制,我已經在自己的博客寫過了線程池和消息機制的。感興趣的同學可以去閱讀下。
那麼直接進入AsyncTask的源碼分析,一起從源碼的角度徹底理解。
先從AsyncTask的構造方法看起
/**
* Creates a new asynchronous task. This constructor must be invoked on the UI thread.
*/
public AsyncTask() {
mWorker = new WorkerRunnable<Params, Result>() {
public Result call() throws Exception {
mTaskInvoked.set(true);
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
//noinspection unchecked
Result result = doInBackground(mParams);
Binder.flushPendingCommands();
return postResult(result);
}
};
mFuture = new FutureTask<Result>(mWorker) {
@Override
protected void done() {
try {
postResultIfNotInvoked(get());
} catch (InterruptedException e) {
android.util.Log.w(LOG_TAG, e);
} catch (ExecutionException e) {
throw new RuntimeException("An error occurred while executing doInBackground()",
e.getCause());
} catch (CancellationException e) {
postResultIfNotInvoked(null);
}
}
};
}
從方法的註釋我們知道,創建一個異步任務,這個構造方法必須要在UI線程中調用。
AsyncTask的構造方法中,首先創建了一個WorkerRunnable對象並賦值給mWorker,那麼這個WorkerRunnable是什麼呢?
private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {
Params[] mParams;
}
從上面的代碼中可知道WorkerRunnable其實就是Callable。接着又創建了一個FutureTask對象,並將mWorker傳進。AsyncTask的構造方法只是做了初始化的工作。
關於Callable和FutureTask我已經在線程池系列的博客中介紹過了。簡單說就是FutureTask是Runnable的實現類,其中封裝了Callable,當FutureTask的run方法被調用時,內部實際調用的是Callable的call方法。那麼我們等下就尋找FutureTask的run方法在哪裏被調用了, doInBackground方法也就是在那裏開始被調用的。
那麼接下來就是跟蹤AsyncTask的 execute方法了,源碼如下:
public final AsyncTask<Params, Progress, Result> execute(Params... params) {
return executeOnExecutor(sDefaultExecutor, params);
}
內部調用了executeOnExecutor方法,這個方法顧名思義就是在線程池中執行,傳入sDefaultExecutor和在參數params。
那麼sDefaultExecutor又是什麼呢?先不管。
我覺的剛開始分析execute方法不要一直在研究從四面八方出現的變量。因爲讓我們感到莫名其妙出現的變量實在太多了,我們一直去跟蹤思路很容易會散了。稍後會分析sDefaultExecutor。
那麼繼續跟進executeOnExecutor方法看看:
public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,
Params... params) {
if (mStatus != Status.PENDING) {
switch (mStatus) {
case RUNNING:
throw new IllegalStateException("Cannot execute task:"
+ " the task is already running.");
case FINISHED:
throw new IllegalStateException("Cannot execute task:"
+ " the task has already been executed "
+ "(a task can be executed only once)");
}
}
mStatus = Status.RUNNING;
onPreExecute();
mWorker.mParams = params;
exec.execute(mFuture);
return this;
}
關於Status是一個枚舉類型,他有三種狀態:PENDING,RUNNING, FINISHED,分別標明瞭當前AsyncTask的狀態。當然初始化的時候是PENDING準備就緒狀態,從
private volatile Status mStatus = Status.PENDING;
這行代碼也可以看出。那麼繼續往下看這個executeOnExecutor方法,之後會將Status的狀態設置爲RUNNING正在運行狀態。AsyncTask如果在RUNNING, FINISHED狀態執行executeOnExecutor方法就會拋出異常了,也表明一個AsyncTask實例只能執行一次任務。接着就會回調onPreExecute方法,所以我們可以重寫onPreExecute這個方法做一些準備工作。
好,重頭戲要開始了。
exec.execute(mFuture);
exec調用了execute方法並將mFuture(FutureTask對象)傳入,之前我們已經在構造方法中初始化了FutureTask對象並賦值給mFuture。不過還需要知道exec,回到最初,我們是在AsyncTask的execute方法裏,將sDefaultExecutor傳了進來executeOnExecutor方法,所以exec就是sDefaultExecutor。
那麼就需要知道sDefaultExecutor的execute方法裏的內部實現是怎麼樣的,才能解開我們心中的疑惑了。
現在纔是搞明白sDefaultExecutor是什麼的正確時機,那我們就先來瞧瞧sDefaultExecutor是什麼先?
/**
* An {@link Executor} that executes tasks one at a time in serial
* order. This serialization is global to a particular process.
*/
public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
由此可知道,sDefaultExecutor是SerialExecutor的實例,從名字可以看出SerialExecutor是一個串行執行任務的線程池。我在Android中的線程池(二)那篇博客中也詳細講了各種線程池。
那就來看看SerialExecutor的源碼:
private static class SerialExecutor implements Executor {
final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
Runnable mActive;
public synchronized void execute(final Runnable r) {
mTasks.offer(new Runnable() {
public void run() {
try {
r.run();
} finally {
scheduleNext();
}
}
});
if (mActive == null) {
scheduleNext();
}
}
protected synchronized void scheduleNext() {
if ((mActive = mTasks.poll()) != null) {
THREAD_POOL_EXECUTOR.execute(mActive);
}
}
}
SerialExecutor確實是一個線程池,很重要。這段代碼也是我覺得最不好理解的。裏面實現了Executor 接口的execute方法。
SerialExecutor的execute方法內部,首先向ArrayDeque隊列中提交一個Runnable對象,在其run方法裏調用r的run方法,r就是mFuture。
public void run() {
try {
r.run();//等價於mFuture.run()
} finally {
scheduleNext();
}
}
有點繞,但容易理解的。其實就是這個run方法運行時,就調用FutureTask的run方法嘛。
當第一次執行execute方法,mActive一定是爲空的,那麼就會通過if (mActive == null)的判斷調用到scheduleNext方法。
可以看到scheduleNext這個方法從隊列的頭部取出一個元素並賦值給mActive,如果mActive不爲空,即隊列裏有任務。就調用THREAD_POOL_EXECUTOR的execute方法將mActive傳進去執行任務。mActive經過第一次賦值之後就不爲空了。之後就會進入finally塊。也就是說scheduleNext還是會被調用。這樣後續的任務又得到了處理。
總結一下:可以這樣理解,假設我有10個AsyncTask任務,全部進入隊列,肯定會有其中一個AsyncTask任務是第一個執行的吧,當第一個AsyncTask任務執行完畢,就會進入finally塊,調用scheduleNext方法繼續取出隊列中的任務,這樣下一個任務又得到了處理。
只有當一個任務執行完畢了,下一個任務纔會執行。所以爲什麼說這種線程池是串行執行任務。
AsyncTask有兩個線程池的,SerialExecutor和THREAD_POOL_EXECUTOR。前者負責任務的排隊,後者用於任務的執行。THREAD_POOL_EXECUTOR的配置如下:
/**
* An {@link Executor} that can be used to execute tasks in parallel.
*/
public static final Executor THREAD_POOL_EXECUTOR
= new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,
TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);
這些核心線程數,最大線程數,任務隊列等參數如下:
private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
private static final int CORE_POOL_SIZE = CPU_COUNT + 1;
private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;
private static final int KEEP_ALIVE = 1;
private static final BlockingQueue<Runnable> sPoolWorkQueue =
new LinkedBlockingQueue<Runnable>(128);
那我們跟進THREAD_POOL_EXECUTOR的execute方法,看看是怎樣執行任務的。
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
int c = ctl.get();
if (workerCountOf(c) < corePoolSize) {
if (addWorker(command, true))
return;
c = ctl.get();
}
if (isRunning(c) && workQueue.offer(command)) {
int recheck = ctl.get();
if (! isRunning(recheck) && remove(command))
reject(command);
else if (workerCountOf(recheck) == 0)
addWorker(null, false);
}
else if (!addWorker(command, false))
reject(command);
}
這裏的流程,我也在之前的博客分析過了,不過這裏爲了更好閱讀,我還是在分析一遍吧。這個execute方法裏的邏輯不簡單,所以我們要結合AsyncTask使用到的線程池的參數配置,抓主要信息閱讀。
那主要是將mFuture加入將要執行的隊列中,我們只需要跟進addWorker方法即可。
private boolean addWorker(Runnable firstTask, boolean core) {
retry:
//代碼省略
Worker w = null;
try {
w = new Worker(firstTask);
final Thread t = w.thread;
if (t != null) {
//代碼省略
workers.add(w);
int s = workers.size();
if (s > largestPoolSize)
largestPoolSize = s;
workerAdded = true;
}
} finally {
mainLock.unlock();
}
if (workerAdded) {
t.start();
workerStarted = true;
}
}
} finally {
if (! workerStarted)
addWorkerFailed(w);
}
return workerStarted;
}
創建一個Worker對象並對傳進的FutureTask進行包裝,從Worker對象中取出線程並賦值給t,然後將Worker對象添加進工作線程隊列等待執行,最後線程t調用start方法。即調用Worker裏的run方法,在Worker裏的run方法裏又調用了runWorker方法,如下:
final void runWorker(Worker w) {
Thread wt = Thread.currentThread();
Runnable task = w.firstTask;
w.firstTask = null;
w.unlock(); // allow interrupts
boolean completedAbruptly = true;
try {
//代碼省略
try {
task.run();
} catch (RuntimeException x) {
thrown = x; throw x;
}
//代碼省略
} finally {
processWorkerExit(w, completedAbruptly);
}
}
取出剛纔在Worker對象中封裝的FutureTask對象,並賦值給task,最後task調用run方法。這樣mFuture的run方法就得到了調用。
在FutureTask對象run方法裏會調用Callable的call方法,FutureTask對象run方法如下:
public void run() {
//代碼省略
try {
Callable<V> c = callable;
if (c != null && state == NEW) {
V result;
boolean ran;
try {
result = c.call();
ran = true;
}
//代碼省略
}
這個Callable也就是我們最初在AsyncTask構造方法中創建的WorkerRunnable對象mWorker。現在我們可以看到mWorker的call方法了
public Result call() throws Exception {
mTaskInvoked.set(true);
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
//noinspection unchecked
Result result = doInBackground(mParams);
Binder.flushPendingCommands();
return postResult(result);
}
饒了地球一圈,終於執行到了doInBackground方法了。這裏也可以證實,onPreExecute方法是第一個被調用的,而第二個回調的是doInBackground方法。
那繼續前進吧,將doInBackground返回的結果傳進了postResult方法,postResult方法源碼如下:
private Result postResult(Result result) {
@SuppressWarnings("unchecked")
Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
new AsyncTaskResult<Result>(this, result));
message.sendToTarget();
return result;
}
終於看到消息機制了,getHandler方法獲取到InternalHandler對象,並將MESSAGE_POST_RESULT字段和一個包裝了result的AsyncTaskResult對象發送給handleMessage方法接收。
private static class AsyncTaskResult<Data> {
final AsyncTask mTask;
final Data[] mData;
AsyncTaskResult(AsyncTask task, Data... data) {
mTask = task;
mData = data;
}
}
AsyncTaskResult是一個用於封裝AsyncTask實例和結果集的內部類。
那麼我們現在直接到handleMessage方法一看究竟。
private static class InternalHandler extends Handler {
public InternalHandler() {
super(Looper.getMainLooper());
}
@SuppressWarnings({"unchecked", "RawUseOfParameterizedType"})
@Override
public void handleMessage(Message msg) {
AsyncTaskResult<?> result = (AsyncTaskResult<?>) msg.obj;
switch (msg.what) {
case MESSAGE_POST_RESULT:
// There is only one result
result.mTask.finish(result.mData[0]);
break;
case MESSAGE_POST_PROGRESS:
result.mTask.onProgressUpdate(result.mData);
break;
}
}
}
在InternalHandler的構造方法中,獲取到UI線程的Looper對象,這就是爲什麼AsyncTask要在主線程創建,因爲我要關聯主線程的Looper,消息隊列。
剛纔發的消息是MESSAGE_POST_RESULT,那我們看到這個分支即可,這裏調用了AsyncTask的finish方法並傳進result。
private void finish(Result result) {
if (isCancelled()) {
onCancelled(result);
} else {
onPostExecute(result);
}
mStatus = Status.FINISHED;
}
在一路順暢不拋異常的正常情況下,AsyncTask沒有被取消,會將result傳入onPostExecute方法,執行完onPostExecute後,整個AsyncTask的生命週期也就結束了。
還有一個知識點沒講到的是,在doInBackground方法中調用publishProgress方法,可以在onProgressUpdate方法中更新UI,比如更新進度條的進度。
protected final void publishProgress(Progress... values) {
if (!isCancelled()) {
getHandler().obtainMessage(MESSAGE_POST_PROGRESS,
new AsyncTaskResult<Progress>(this, values)).sendToTarget();
}
}
其實這個publishProgress方法也很簡單,就是將當前的進度值values發送到主線程。
如果我們想要並行執行任務,可以調用AsyncTask的executeOnExecutor方法。如下:
new AsyncTask<Void,Void,Void>(){
@Override
protected Void doInBackground(Void... params) {
return null;
}
}.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR,null);
其實很好理解的。直接執行executeOnExecutor方法,傳入AsyncTask.THREAD_POOL_EXECUTOR線程池。這樣就繞過了SerialExecutor任務排隊的過程。
以上就是根據源碼的角度分析的AsyncTask的工作原理。