非同步任務----AsyncTask解析
一.前言
AsyncTask 非同步任務，是 Android 中用於非同步執行耗時任務的類，封裝了 Hanlder ，Message 和 執行緒池。AsyncTask 的封裝使得開發者在開發過程中不用再自己編寫相應的 Handler 或者執行緒執行的方法。
二.簡介
public abstract class AsyncTask<Params, Progress, Result> { ... @WorkerThread protected abstract Result doInBackground(Params... params); ... }
AsyncTask 是一個抽象類,使用的時候需要實現 doInBackground 這個方法，同時需要指三個泛型引數，從名字就基本可以看出這三個引數的作用：
- Params，用於指定傳遞給 AsyncTask 的引數型別 。
- Progress ，用於在任務進行中返回的任務進度的型別 。
- Result，用於指定任務執行完成後返回的型別。
AsyncTask 的執行從開始到結束主要有下面的幾個方法：
- execute，傳遞這個 Params 引數並開始執行任務，注意每一個 AsyncTask 物件只能執行一次，如果需要重複的任務就需要重複的建立這個物件。
@MainThread public final AsyncTask<Params, Progress, Result> execute(Params... params) { return executeOnExecutor(sDefaultExecutor, params); }
- onPreExecute，在任務執行之前呼叫（Pre 之前），執行在 主執行緒，可以對 UI 做一些任務前的處理比如提示載入框等。
@MainThread
protected void onPreExecute() {
}
- doInBackground，在工作執行緒執行，也就是在子執行緒執行，接收引數 Params 執行完成後就將 Result 型別的結果返回。
@WorkerThread
protected abstract Result doInBackground(Params... params);
- publishProgress,在工作執行緒執行，可以在 doInBackground 方法中呼叫，用於在任務進行的過程中不斷更新 UI ,傳入的引數就是之前指定的 Progress 型別。
@WorkerThread
protected final void publishProgress(Progress... values) {
if (!isCancelled()) {
....
}
}
- onProgressUpdate 工作在主執行緒，在 publishProgress 調後，具體的 UI 的更新操作就是在 onProgressUpdate 這裡執行，接收從 publishProgress 傳過來的 引數並執行相應的更新操作。
@MainThread
protected void onProgressUpdate(Progress... values) {
}
- onPostExecute，執行在主執行緒，在任務執行完成後（Post 之後），任務完成後會返回一個 Result 型別的值，可以在這裡獲取並執行 Ui 操作。
@MainThread
protected void onPostExecute(Result result) {
}
- onCancelled，取消任務的時候會執行，執行在住執行緒，對 UI 做一些狀態的恢復工作。
@MainThread
protected void onCancelled(Result result) {
onCancelled();
}
@MainThread
protected void onCancelled() {
}
三.原理
AsyncTask 暴露出來的方法的生命期就是上面所介紹的，下面就具體看看 AsyncTask 是如何處理非同步操作的。
1.建立
public AsyncTask() {
this((Looper) null);
}
public AsyncTask(@Nullable Handler handler) {
this(handler != null ? handler.getLooper() : null);
}
public AsyncTask(@Nullable Looper callbackLooper) {
mHandler = callbackLooper == null || callbackLooper == Looper.getMainLooper()
? getMainHandler()
: new Handler(callbackLooper);
可以看到剛開始 new AsyncTask 的時候如果沒有指定 Looper 或者指定的 Looper 是主執行緒的 Looper 就是使用 AsyncTask 封裝的 Hanlder ( InternalHandler ) ，否則就根據 指定的 Looper 建立一個 Hander.
public AsyncTask(@Nullable Looper callbackLooper) {
mHandler = callbackLooper == null || callbackLooper == Looper.getMainLooper()
? getMainHandler()
: new Handler(callbackLooper);
mWorker = new WorkerRunnable<Params, Result>() {
public Result call() throws Exception {
mTaskInvoked.set(true);
Result result = null;
try {
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
//noinspection unchecked
result = doInBackground(mParams);
Binder.flushPendingCommands();
} catch (Throwable tr) {
mCancelled.set(true);
throw tr;
} finally {
postResult(result);
}
return result;
}
};
mFuture = new FutureTask<Result>(mWorker) {
@Override
protected void done() {
try {
postResultIfNotInvoked(get());
...
}
}
};
}
在建立的過程中會初始化一個 WorkerRunnable ，這是一個封裝的 Runnable 物件，在這個物件中首先會所處的執行緒的優先順序設定為 Process.THREAD_PRIORITY_BACKGROUND 後臺執行緒，然後就是將 doInBackground 方法封裝在這個 workerRunnable ，然後再將這個 Runable 封裝到一個 FutureTask 這是一個可以有返回值的執行緒任務，相對於的 Runable 就是一個 沒有返回值的執行緒任務。
2.execute 開始執行
這裡首先先介紹幾個重要的物件
- sPoolWorkQueue,阻塞佇列，使用的是 LinkedBlockingQueue 的阻塞佇列。
- THREAD_POOL_EXECUTOR ，執行任務的執行緒池，與執行緒池配套的是 上面的阻塞佇列。
- SERIAL_EXECUTOR，任務排隊的執行緒池
- sDefaultExecutor，預設的執行緒池，預設為 SERIAL_EXECUTOR
- sHandler，封裝的 InternalHandler ，也就是 Hanlder .
private static final BlockingQueue<Runnable> sPoolWorkQueue =
new LinkedBlockingQueue<Runnable>(128);
public static final Executor THREAD_POOL_EXECUTOR;
static {
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE_SECONDS, TimeUnit.SECONDS,
sPoolWorkQueue, sThreadFactory);
threadPoolExecutor.allowCoreThreadTimeOut(true);
THREAD_POOL_EXECUTOR = threadPoolExecutor;
}
public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
private static InternalHandler sHandler;
這裡看一下 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);
}
}
}
可以看到這裡使用的 ArrayDeque ，這是一種先進先出的佇列，所以在 AsyncTask 任務執行就是一個接一個的執行。在任務執行的執行緒池中不會產生併發執行的過程。
回到 execute 方法
@MainThread
public final AsyncTask<Params, Progress, Result> execute(Params... params) {
return executeOnExecutor(sDefaultExecutor, params);
}
@MainThread
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;
}
可以看到 execute 方法執行後會呼叫 executeOnExecutor，在裡面就會先進行一個些判斷，如果當前任務是 RUNNING 即執行狀態或者 FINISHED 即終止狀態就丟擲異常，否則就將狀態設定為 RUNNING 並開始執行 onPreExecute 方法，最一些任務執行前的操作，最後就將任務提交的 SerialExecutor 執行緒池。在 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);
}
}
}
前面也說過 提交的任務在這裡會新增的 ArrayDeque 的 mTasks 佇列中，然後再去 THREAD_POOL_EXECUTOR 中做真正的執行。保證了 任務的執行是序列的過程。
在 THREAD_POOL_EXECUTOR 執行完成後 WorkerRunnable 的 方法後最後就會呼叫 postResult
mWorker = new WorkerRunnable<Params, Result>() {
...
result = doInBackground(mParams);
...
postResult(result);
};
跳轉到 postResult
private Result postResult(Result result) {
@SuppressWarnings("unchecked")
Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
new AsyncTaskResult<Result>(this, result));
message.sendToTarget();
return result;
}
這裡就使用 message 和 getHandler 傳送訊息，直接看 InternalHandler
private static class InternalHandler extends Handler {
public InternalHandler(Looper looper) {
super(looper);
}
@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;
}
}
}
可以看到最後呼叫的就是 result.mTask.finish(result.mData[0]); ，這個 result.mTask 就是一個封裝了最後的結果和 AsyncTask 的物件，也就是將執行的結果 傳遞給了finish 方法，而且也從工作執行緒回到了 主執行緒。
private void finish(Result result) {
if (isCancelled()) {
onCancelled(result);
} else {
onPostExecute(result);
}
mStatus = Status.FINISHED;
}
在finish 就會呼叫 onPostExecute 方法執行最後的顯示操作，並將 狀態設定為 FINISHED ，一旦設定為 FINISHED 就說明這個 AsyncTask 物件不能再執行 任務。
對於任務的更新操作也是類是的過程，首先通過 getHandler 傳送 Message.
@WorkerThread
protected final void publishProgress(Progress... values) {
if (!isCancelled()) {
getHandler().obtainMessage(MESSAGE_POST_PROGRESS,
new AsyncTaskResult<Progress>(this, values)).sendToTarget();
}
}
最後就是在 Handler 裡面進行處理呼叫 result.mTask.onProgressUpdate(result.mData); 方法。 同樣從工作執行緒回到了主執行緒 ，然後就是進度的更新方法 onProgressUpdate 。 就這樣 AsyncTask 的原理就介紹到此。