編輯：Android開發實例
為什麼要用AsyncTask
我們寫App都有一個原則，主線程不能夠運行需要占用大量CPU時間片的任務，如大量復雜的浮點運算，較大的磁盤IO操作，網絡socket等，這些都會導致我們的主線程對用戶的響應變得遲鈍，甚至ANR，這些會使應用的用戶體驗變差，但是有時又的確需要執行這些耗時的任務，那麼我們通常可以使用AsyncTask或者new Thread
來處理，這樣把任務放入工作線程中執行，不會占用主線程的時間片，所以主線程會及時響應用戶的操作，如果使用new Thread來執行任務，那麼如果需要中途取消任務執行或者需要返回任務執行結果，就需要我們自己維護很多額外的代碼，而AsyncTask是基於concurrent架包提供的並發類實現的，上面的二個需求都已經幫我們封裝了，這也是我們選擇AsyncTask的原因。
怎麼用AsyncTask
我們還是簡單介紹下AsyncTask一些使用示例。我們先新建一個類DemoAsyncTask繼承AsyncTask，因為AsyncTask是抽象類，其中doInBackground方法必須重寫。
private class DemoAsyncTask extends AsyncTask<String, Void, Void> {
@Override
protected void onPreExecute() {
super.onPreExecute();
}
@Override
protected Void doInBackground(String... params) {
return null;
}
@Override
protected void onPostExecute(Void aVoid) {
super.onPostExecute(aVoid);
}
@Override
protected void onProgressUpdate(Void... values) {
super.onProgressUpdate(values);
}
@Override
protected void onCancelled(Void aVoid) {
super.onCancelled(aVoid);
}
@Override
protected void onCancelled() {
super.onCancelled();
}
}
DemoAsyncTask task = new DemoAsyncTask();
task.execute("demo test AsyncTask");
//task.executeOnExecutor(AsyncTask.SERIAL_EXECUTOR, "test");
//myTask.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, "test");
簡單分析下
上面就是AsyncTask最簡單的使用方法，我們上面重寫的方法中，onInBackground方法運行在工作線程，其他的方法全部運行在主線程，另外它的運行方式Android提供給我們2個方法，上面都列出了。
1.第一個方法會使用默認的Executor執行我們的任務, 其實也就是SERIAL_EXECUTOR，SERIAL_EXECUTOR我們其實也是可以通過方法去自定義的，Android幫我們的默認實現是逐個執行任務，也就是單線程的，關於AsyncTask的任務執行是單線程實現還是多線程實現還有一段很有意思的歷史，較早的版本是單線程實現，從Android2.X開始，Google又把它改為多線程實現，後來Google發現，多線程實現的話，會有很多需要保證線程安全的額外工作留給開發者，所以從Android3.0開始，又把默認實現改為單線程了，今天我們演示的是Framwork代碼版本是21(Android5.0)。
2.同時也提供了多線程實現的接口，即我們上面寫的最後一行代碼 AsyncTask.THREAD_POOL_EXECUTOR。
public final AsyncTask<Params, Progress, Result> execute(Params... params) {
return executeOnExecutor(sDefaultExecutor, params);
}
private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
其實相信大家平時工作學習中經常使用AsyncTask，我們直接去看AsyncTask類源碼（插一句題外話，平時大家也可以把自己工作學習中的心得體會總結一下，記下來~~）
public abstract class AsyncTask<Params, Progress, Result> {
....
}
AsyncTask抽象類，有三個泛型參數類型，第一個是你需要傳遞進來的參數類型，第二個是任務完成進度的類型一般是Integer，第三個是任務完成結果的返回類型，有時這些參數不是全部需要，不需要的設為Void即可，另外Result只有一個，但Params可以有多個。
我們可以看到AsyncTask的默認構造器初始化了二個對象，mWorker和mFuture。
private final WorkerRunnable<Params, Result> mWorker;
private final FutureTask<Result> mFuture;
mWorker = new WorkerRunnable<Params, Result>() {
public Result call() throws Exception {
mTaskInvoked.set(true);
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
//noinspection unchecked
return postResult(doInBackground(mParams));
}
};
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 occured while executing doInBackground()",
e.getCause());
} catch (CancellationException e) {
postResultIfNotInvoked(null);
}
}
};
mWoker實現了Callback接口，Callback接口是JDK1.5加入的高級並發架包裡面的一個接口，它可以有一個泛型返回值。
public interface Callable<V> {
/**
* Computes a result, or throws an exception if unable to do so.
*
* @return computed result
* @throws Exception if unable to compute a result
*/
V call() throws Exception;
}
FutureTask實現了RunnableFuture接口，RunnableFuture接口是JDK提供的，看名稱就知道它繼承了Runnable和Future接口，mFuture是FutureTask的一個實例，可以直接被Executor類實例execute。我們來繼續看AsyncTask的execute方法。
public final AsyncTask<Params, Progress, Result> execute(Params... params) {
return executeOnExecutor(sDefaultExecutor, params);
}
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;
}
先調用onPreExecute()方法，此時還在主線程(嚴格來說是調用AsyncTask執行的線程)，然後exec.execute(mFuture)，把任務交給exec處理，execute mFuture其實就是invoke mWoker，然後調用postResult(doInBackground(mParams))，此時已經運行在工作線程池，不會阻塞主線程。然後給mHandler發送MESSAGE_POST_RESULT消息，然後調用finish方法，如果isCancelled，回調onCancelled，否則回調onPostExecute。
private Result postResult(Result result) {
@SuppressWarnings("unchecked")
Message message = sHandler.obtainMessage(MESSAGE_POST_RESULT,
new AsyncTaskResult<Result>(this, result));
message.sendToTarget();
return result;
}
private static final InternalHandler sHandler = new InternalHandler();
private static class InternalHandler extends Handler {
@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;
}
}
}
private void finish(Result result) {
if (isCancelled()) {
onCancelled(result);
} else {
onPostExecute(result);
}
mStatus = Status.FINISHED;
}
現在其實我們已經把AsyncTask整個執行任務的過程走完了，其中暴露給我們的那幾個回調方法也都走到了。現在我們回過頭來看，AsyncTask其實只是對JDK 1.5提供的高級並發特性，concurrent架包做的一個封裝，方便開發者來處理異步任務，當然裡面還有很多細節處理的方法值得大家學習，如任務執行進度的反饋，任務執行原子性的保證等，這些留給大家自己學習了。
源碼分析
下面我們再深入一些，來看AsyncTask的源碼。下面分析這個類的實現，主要有線程池以及Handler兩部分。
線程池
當執行一個AsyncTask的時候調用的是execute()方法，就從這個開始看：
public final AsyncTask<Params, Progress, Result> execute(Params... params){
return executeOnExecutor(sDefaultExecutor, params);
}
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
onPreExecute();
mWorker.mParams = params;
exec.execute(mFuture);
return this;
}
execute方法會調用executeOnExecutor。在這個方法中先檢查任務是否已經執行或者執行結束，然後把任務標記為running。最開始執行的是onPreExecute，接著把參數賦值給mWorker對象。這個mWorker是一個Callable對象，最終被包裝為FutureTask，代碼如下：
private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {
Params[] mParams;
}
mWorker = new WorkerRunnable<Params, Result>() {
public Result call() throws Exception {
mTaskInvoked.set(true);
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
//noinspection unchecked
return postResult(doInBackground(mParams));
}
};
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 occured while executing doInBackground()",
e.getCause());
} catch (CancellationException e) {
postResultIfNotInvoked(null);
}
}
};
從上面的代碼可以看出，在mWorker對象中的call()方法會調用doInbackground，返回值交給postResult方法，這個方法通過Handler發送消息，這一點稍後再詳細分析。
在mWorker對象被封裝成FutureTask之後交由線程池執行，從execute方法可以看出，使用的是sDefaultExecutor，它的值默認為SERIAL_EXECUTOR，也就是串行執行器，實現如下：
private static class SerialExecutor implements Executor {
//線性雙向隊列，用來存儲所有的AsyncTask任務
final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
//當前正在執行的AsyncTask任務
Runnable mActive;
public synchronized void execute(final Runnable r) {
//將新的AsyncTask任務加入到雙向隊列中
mTasks.offer(new Runnable() {
public void run() {
try {
//執行AsyncTask任務
r.run();
} finally {
//當前任務執行結束後執行下一個任務
scheduleNext();
}
}
});
if (mActive == null) {
scheduleNext();
}
}
protected synchronized void scheduleNext() {
//從任務隊列中取出隊列頭部的任務，如果有就交給並發線程池去執行
if ((mActive = mTasks.poll()) != null) {
THREAD_POOL_EXECUTOR.execute(mActive);
}
}
}
public static final Executor THREAD_POOL_EXECUTOR
= new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,
TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);
在上面的代碼中，如果有任務執行，那麼SerialExecutor的execute方法會被調用，它的邏輯是把Runnable對象加入ArrayDeque隊列中，然後判斷mActivie是否為空。第一次執行時mActive當然為空，所以執行scheduleNext，其實就是取出任務隊列中的第一個任務交給線程池(THREAD_POOL_EXECUTOR)執行。加入mTask隊列的Runnable對象的run方法裡最終一定會調用scheduleNext，那麼又會從任務隊列中取出隊頭任務執行。這樣便實現了單線程順序執行任務，所以在AsyncTask中默認啟用的是單線程執行，只有上一個任務執行後才會執行下一個任務。如果想要啟用多線程執行任務，可以直接調用 executeOnExecutor(Executor exec, Params... params)，這裡的Executor參數可以使用AsyncTask自帶的THREAD_POOL_EXECUTOR，也可以自己定義。
Handler
AsyncTask內部用Handler傳遞消息，它的實現如下：
private static class InternalHandler extends Handler {
@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;
}
}
}
如果消息類型是任務執行後的返回值(MESSAGE_POST_RESULT)將調用finish()方法：
private void finish(Result result) {
if (isCancelled()) {
onCancelled(result);
} else {
onPostExecute(result);
}
mStatus = Status.FINISHED;
}
從上面可以知道，如果任務取消了，將調用onCancelled，否則調用onPostExecute，所以一個AsyncTask任務如果取消了，那麼onPostExecute將不會得到執行。
如果消息類型是執行進度(MESSAGE_POST_PROGRESS)將調用onProgressUpdate，這個方法默認是空方法，我們可以根據自己的需要重寫。
總結
AsyncTask的主要邏輯就如上面所分析的，總結幾個需要注意的地方：
Android控件系列之相冊Gallery&Adapter適配器入門&控件縮放動畫入門
學習目的： 1、掌握在Android中如何建立Gallery 2、初步理解Android適配器的原理 3、實現簡單的控件縮放動畫 簡介： 1、Gallery是An
Android圖片特效：黑白特效、圓角效果、高斯模糊
1.黑白效果 代碼如下：/** * 將彩色圖轉換為黑白圖 * &n
Android示例程序剖析之記事本（四：NoteEditor類及Content Provider機制）
Android記事本示例剖析之三中講了Activity的生命周期，並
Android控件系列之ImageView使用方法
學習目的： 1、掌握在Android中如何插入圖片 圖片的加入可以立刻讓您的程序增色不少，我們樣例選用一張Android機器人(picture.jpg)，您可以使
