Android進階——多執行緒系列之非同步任務AsyncTask的使用與原始碼分析
AsyncTask是什麼
AsyncTask是一種輕量級的非同步任務類,它可以線上程池中執行後臺任務,然後把執行的進度和最終結果傳遞給主執行緒並主執行緒中更新UI,通過AsyncTask可以更加方便執行後臺任務以及在主執行緒中訪問UI,但是AsyncTask並不適合進行特別耗時的後臺任務,對於特別耗時的任務來說,建議使用執行緒池
AsyncTask的使用
我們簡單的模擬下載檔案的案例來分析,我們建立自己的非同步類繼承AsyncTask
private class DownloadFilesTask extends AsyncTask<URL, Integer, Long> {
@Override
protected void onPreExecute() {
//非同步任務開啟之前回調,在主執行緒中執行
super.onPreExecute();
}
@Override
protected Long doInBackground(URL... urls) {
//執行非同步任務,線上程池中執行
long totalSize = 0;
int i = 0;
try {
while (i < 100) {
Thread.sleep(50 );
i = i + 5;
publishProgress(i);
}
} catch (InterruptedException e) {
e.printStackTrace();
}
totalSize = totalSize + i;
return totalSize;
}
@Override
protected void onProgressUpdate(Integer... progress) {
//當doInBackground中呼叫publishProgress時回撥,在主執行緒中執行
pb_progress.setProgress(progress[0]);
}
@Override
protected void onPostExecute(Long result) {
//在非同步任務執行之後回撥,在主執行緒中執行
Toast.makeText(MainActivity.this, "下載完成,結果是" + result, Toast.LENGTH_SHORT).show();
}
@Override
protected void onCancelled() {
//在非同步任務被取消時回撥
super.onCancelled();
}
}
一、引數分析
通過原始碼,可以看到AsyncTask是個抽象的泛型類
public abstract class AsyncTask<Params, Progress, Result>
- Params:表示後臺任務執行時的引數型別(對應例子中的URL),該引數會傳給AysncTask的doInBackground()方法
- Progress:表示後臺任務的執行進度的引數型別(對應例子中的Integer),該引數會作為onProgressUpdate()方法的引數
- Result:表示後臺任務的返回結果的引數型別(對應例子中的Long),該引數會作為onPostExecute()方法的引數
注意這三個引數都是代表的型別,如果AsyncTask確實不需要傳遞具體的引數,那麼這三個泛型引數可以用Void來代替
二、方法分析
常用的AsyncTask繼承的方法有
- onPreExecute():非同步任務開啟之前回調,在主執行緒中執行
- doInBackground():執行非同步任務,線上程池中執行
- onProgressUpdate():當doInBackground中呼叫publishProgress時回撥,在主執行緒中執行
- onPostExecute():在非同步任務執行之後回撥,在主執行緒中執行
- onCancelled():在非同步任務被取消時回撥
三、開啟非同步
在主Activity中通過點選按鈕執行我們建立的非同步任務,然後通過execute()方法執行非同步任務
bt_down.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
try {
URL url = new URL("http://blog.csdn.net/");
new DownloadFilesTask().execute(url);
} catch (MalformedURLException e) {
e.printStackTrace();
}
}
});
四、效果圖
AsyncTask原始碼分析
原始碼分析是基於API24的原始碼,我將會按照下面AsyncTask執行的過程來分析
一、主分支
- 首先,execute()方法,開啟非同步任務
- 接著,onPreExecute()方法,非同步任務開啟前
- 接著,doInBackground()方法,非同步任務正在執行
- 最後,onPostExecute()方法,非同步任務完成
二、次分支
- onProgressUpdate()方法,非同步任務更新UI
- onCancelled()方法,非同步任務取消
主分支部分
程式碼開始的地方,是在建立AsyncTask類之後執行的execute()方法
public final AsyncTask<Params, Progress, Result> execute(Params... params) {
return executeOnExecutor(sDefaultExecutor, params);
}
execute()方法會呼叫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;
}
AsyncTask定義了一個mStatus變數,表示非同步任務的執行狀態,分別是PENDING、RUNNING、FINISHED,當只有PENDING狀態時,AsyncTask才會執行,這樣也就保證了AsyncTask只會被執行一次
繼續往下執行,mStatus會被標記為RUNNING,接著執行,onPreExecute(),將引數賦值給mWorker,然後還有execute(mFuture)
這裡的mWorker和mFuture究竟是什麼,我們往下追蹤,來到AsyncTask的建構函式中,可以找到這兩個的初始化
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);
}
}
};
}
一、分析mWorker
mWorker是一個WorkerRunnable物件,跟蹤WorkerRunnable
private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {
Params[] mParams;
}
實際上,WorkerRunnable是AsyncTask的一個抽象內部類,實現了Callable介面
二、分析mFuture
mFuture是一個FutureTask物件,跟蹤FutureTask
public FutureTask(Callable<V> callable) {
if (callable == null)
throw new NullPointerException();
this.callable = callable;
this.state = NEW; // ensure visibility of callable
}
實際上,FutureTask是java.util.concurrent包下的一個類,引數是個callable,並且將它賦值給FutureTask類中的callable
三、回過頭來看
回到我們AsyncTask初始化mFuture,這裡的引數是mWorker也就不奇怪了,因為mWorker就是一個callable,我們在上面賦值給FutureTask類中的callable就是這個mWorker
mFuture = new FutureTask<Result>(mWorker)
而關於mWorker和mFuture的初始化早在我們Activity中初始化好了,因為建構函式是跟AsyncTask類的建立而執行的
new DownloadFilesTask()
知道了mWorker和mFuture是什麼後,我們回到原來的executeOnExecutor()方法,在這裡將mWorker的引數傳過去後,就開始用執行緒池execute這個mFuture
mWorker.mParams = params;
exec.execute(mFuture);
一、分析exec
exec是通過executeOnExecutor()引數傳進來的
public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,
Params... params)
也就是我們execute()方法傳過來的
public final AsyncTask<Params, Progress, Result> execute(Params... params) {
return executeOnExecutor(sDefaultExecutor, params);
}
這裡可以看到exec就是這個sDefaultExecutor
二、分析sDefaultExecutor
我們跟蹤這個sDefaultExecutor,擷取有關它的程式碼
public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
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可以發現,exec.execute(mFuture)就是在呼叫SerialExecutor類的execute(final Runnable r)方法,這裡的引數r就是mFuture
繼續往下走,SerialExecutor的execute()方法會將r封裝成Runnable,並新增到mTasks任務佇列中
繼續往下走,如果這時候沒有正在活動的AsyncTask任務,那麼就會呼叫SerialExecutor的scheduleNext()方法,來執行下一個AsyncTask任務
if (mActive == null) {
scheduleNext();
}
繼續往下走,通過mTasks.poll()取出,將封裝在mTask的Runnable交給mActive,最後真正執行的這個mActive的是THREAD_POOL_EXECUTOR,即執行的這個mActive,也就是包裝在Runnable裡面的mFuture
protected synchronized void scheduleNext() {
if ((mActive = mTasks.poll()) != null) {
THREAD_POOL_EXECUTOR.execute(mActive);
}
}
mFuture被執行了,也就會執行它的run()方法
public void run() {
try {
r.run();
} finally {
scheduleNext();
}
}
我們跟蹤到mFuture的run()方法中,切換到FutureTask類
public void run() {
if (state != NEW ||
!U.compareAndSwapObject(this, RUNNER, null, Thread.currentThread()))
return;
try {
Callable<V> c = callable;
if (c != null && state == NEW) {
V result;
boolean ran;
try {
result = c.call();
ran = true;
} catch (Throwable ex) {
result = null;
ran = false;
setException(ex);
}
if (ran)
set(result);
}
} finally {
// runner must be non-null until state is settled to
// prevent concurrent calls to run()
runner = null;
// state must be re-read after nulling runner to prevent
// leaked interrupts
int s = state;
if (s >= INTERRUPTING)
handlePossibleCancellationInterrupt(s);
}
}
這一段程式碼其實就是將之前在mFutrue建立物件時候傳進來的mWorker交給c
Callable<V> c = callable;
然後再呼叫c的call()方法,也就是mWorker的call()方法
result = c.call();
程式碼又重新的定位到了mWorker類的call()方法
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);
}
};
可以發現,這裡就呼叫了我們的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(),它是一個單例,返回sHandler
private static Handler getHandler() {
synchronized (AsyncTask.class) {
if (sHandler == null) {
sHandler = new InternalHandler();
}
return sHandler;
}
}
也就是說postResult方法會通過sHandler傳送一個MESSAGE_POST_RESULT的訊息,這個時候我們追蹤到sHandler
private static InternalHandler sHandler;
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;
}
}
}
可以發現,sHandler收到MESSAGE_POST_PROGRESS訊息後會呼叫result.mTask.finish(result.mData[0]),那麼我們還必須知道result是個什麼東西
AsyncTaskResult<?> result = (AsyncTaskResult<?>) msg.obj;
result是AsyncTask的內部類,實際上就是個實體類,用來儲存變數的
private static class AsyncTaskResult<Data> {
final AsyncTask mTask;
final Data[] mData;
AsyncTaskResult(AsyncTask task, Data... data) {
mTask = task;
mData = data;
}
}
result.mTask也就是AsyncTask,最後呼叫result.mTask.finish(result.mData[0]),即AsyncTask的finish()方法,我們跟蹤到finish()方法
private void finish(Result result) {
if (isCancelled()) {
onCancelled(result);
} else {
onPostExecute(result);
}
mStatus = Status.FINISHED;
}
這裡判斷AsyncTask是否已經取消,如果不取消就執行我們的onPostExecute(),最後將狀態設定為FINISHED,整一個AsyncTask的方法都執行完了,我們只需要繼承AsyncTask實現其中的方法就可以按分析的順序往下執行了
次分支部分
在AsyncTask中的finish()方法,我們可以看到onCancelled()方法跟onPostExecute()一起的,只要isCancelled()的值為true,就執行onCancelled()方法
private void finish(Result result) {
if (isCancelled()) {
onCancelled(result);
} else {
onPostExecute(result);
}
mStatus = Status.FINISHED;
}
我們程式碼跟蹤isCancelled()方法
public final boolean isCancelled() {
return mCancelled.get();
}
發現是在mCancelled中獲取的,那我們就必須知道這個mCancelled是什麼,程式碼跟蹤到mCancelled
private final AtomicBoolean mCancelled = new AtomicBoolean();
mCancelled實際上就是個Boolean物件,那我們搜尋它是在哪個時候設定的
public final boolean cancel(boolean mayInterruptIfRunning) {
mCancelled.set(true);
return mFuture.cancel(mayInterruptIfRunning);
}
可以發現,只要我們在AsyncTask類中呼叫這個方法即可停止非同步任務
而onProgressUpdate()方法,是在sHandler中執行,sHandler收到MESSAGE_POST_PROGRESS訊息後,執行,我們搜尋MESSAGE_POST_PROGRESS在什麼時候傳送的
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;
}
}
}
可以發現,只要我們在AsyncTask類中呼叫publishProgress()方法即可執行onProgressUpdate()方法
protected final void publishProgress(Progress... values) {
if (!isCancelled()) {
getHandler().obtainMessage(MESSAGE_POST_PROGRESS,
new AsyncTaskResult<Progress>(this, values)).sendToTarget();
}
}
結語
AsyncTask使用與原始碼分析就到這裡結束了,如果是初學者,這可能會是比較難的分析,如果是想往中高階進階的朋友,瞭解AsyncTask的原理是必須的。隨著時代的發展,流行的非同步框架RxJava的出現已經可以說是替代了這個AsyncTask,為了跟進時代的發展,我也得抽取時間來學習了,廢話就不說了,還是節省點時間來學習吧