http://blog.csdn.net/liuhe688/article/details/6532519

在Android中實現非同步任務機制有兩種方式，Handler和AsyncTask。

Handler模式需要為每一個任務建立一個新的執行緒，任務完成後通過Handler例項向UI執行緒傳送訊息，完成介面的更新，這種方式對於整個過程的控制比較精細，但也是有缺點的，例如程式碼相對臃腫，在多個任務同時執行時，不易對執行緒進行精確的控制。關於Handler的相關知識，前面也有所介紹，不清楚的朋友們可以參照一下。

為了簡化操作，Android1.5提供了工具類android.os.AsyncTask，它使建立非同步任務變得更加簡單，不再需要編寫任務執行緒和Handler例項即可完成相同的任務。

先來看看AsyncTask的定義：

  1. public abstract class AsyncTask<Params, Progress, Result> {

三種泛型型別分別代表“啟動任務執行的輸入引數”、“後臺任務執行的進度”、“後臺計算結果的型別”。在特定場合下，並不是所有型別都被使用，如果沒有被使用，可以用java.lang.Void型別代替。

一個非同步任務的執行一般包括以下幾個步驟：

1.execute(Params... params)，執行一個非同步任務，需要我們在程式碼中呼叫此方法，觸發非同步任務的執行。

2.onPreExecute()，在execute(Params... params)被呼叫後立即執行，一般用來在執行後臺任務前對UI做一些標記。

3.doInBackground(Params... params)，在onPreExecute()完成後立即執行，用於執行較為費時的操作，此方法將接收輸入引數和返回計算結果。在執行過程中可以呼叫publishProgress(Progress... values)來更新進度資訊。

4.onProgressUpdate(Progress... values)，在呼叫publishProgress(Progress... values)時，此方法被執行，直接將進度資訊更新到UI元件上。

5.onPostExecute(Result result)，當後臺操作結束時，此方法將會被呼叫，計算結果將做為引數傳遞到此方法中，直接將結果顯示到UI元件上。

在使用的時候，有幾點需要格外注意：

1.非同步任務的例項必須在UI執行緒中建立。

2.execute(Params... params)方法必須在UI執行緒中呼叫。

3.不要手動呼叫onPreExecute()，doInBackground(Params... params)，onProgressUpdate(Progress... values)，onPostExecute(Result result)這幾個方法。

4.不能在doInBackground(Params... params)中更改UI元件的資訊。

5.一個任務例項只能執行一次，如果執行第二次將會丟擲異常。

接下來，我們來看看如何使用AsyncTask執行非同步任務操作，我們先建立一個專案，結構如下：

結構相對簡單一些，讓我們先看看MainActivity.java的程式碼：

  1. package com.scott.async;
  2. import java.io.ByteArrayOutputStream;
  3. import java.io.InputStream;
  4. import org.apache.http.HttpEntity;
  5. import org.apache.http.HttpResponse;
  6. import org.apache.http.HttpStatus;
  7. import org.apache.http.client.HttpClient;
  8. import org.apache.http.client.methods.HttpGet;
  9. import org.apache.http.impl.client.DefaultHttpClient;
  10. import android.app.Activity;
  11. import android.os.AsyncTask;
  12. import android.os.Bundle;
  13. import android.util.Log;
  14. import android.view.View;
  15. import android.widget.Button;
  16. import android.widget.ProgressBar;
  17. import android.widget.TextView;
  18. public class MainActivity extends Activity {
  19. private static final String TAG = "ASYNC_TASK";
  20. private Button execute;
  21. private Button cancel;
  22. private ProgressBar progressBar;
  23. private TextView textView;
  24. private MyTask mTask;
  25. @Override
  26. public void onCreate(Bundle savedInstanceState) {
  27. super.onCreate(savedInstanceState);
  28. setContentView(R.layout.main);
  29. execute = (Button) findViewById(R.id.execute);
  30. execute.setOnClickListener(new View.OnClickListener() {
  31. @Override
  32. public void onClick(View v) {
  33. //注意每次需new一個例項,新建的任務只能執行一次,否則會出現異常
  34. mTask = new MyTask();
  35. mTask.execute("http://www.baidu.com");
  36. execute.setEnabled(false);
  37. cancel.setEnabled(true);
  38. }
  39. });
  40. cancel = (Button) findViewById(R.id.cancel);
  41. cancel.setOnClickListener(new View.OnClickListener() {
  42. @Override
  43. public void onClick(View v) {
  44. //取消一個正在執行的任務,onCancelled方法將會被呼叫
  45. mTask.cancel(true);
  46. }
  47. });
  48. progressBar = (ProgressBar) findViewById(R.id.progress_bar);
  49. textView = (TextView) findViewById(R.id.text_view);
  50. }
  51. private class MyTask extends AsyncTask<String, Integer, String> {
  52. //onPreExecute方法用於在執行後臺任務前做一些UI操作
  53. @Override
  54. protected void onPreExecute() {
  55. Log.i(TAG, "onPreExecute() called");
  56. textView.setText("loading...");
  57. }
  58. //doInBackground方法內部執行後臺任務,不可在此方法內修改UI
  59. @Override
  60. protected String doInBackground(String... params) {
  61. Log.i(TAG, "doInBackground(Params... params) called");
  62. try {
  63. HttpClient client = new DefaultHttpClient();
  64. HttpGet get = new HttpGet(params[0]);
  65. HttpResponse response = client.execute(get);
  66. if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
  67. HttpEntity entity = response.getEntity();
  68. InputStream is = entity.getContent();
  69. long total = entity.getContentLength();
  70. ByteArrayOutputStream baos = new ByteArrayOutputStream();
  71. byte[] buf = new byte[1024];
  72. int count = 0;
  73. int length = -1;
  74. while ((length = is.read(buf)) != -1) {
  75. baos.write(buf, 0, length);
  76. count += length;
  77. //呼叫publishProgress公佈進度,最後onProgressUpdate方法將被執行
  78. publishProgress((int) ((count / (float) total) * 100));
  79. //為了演示進度,休眠500毫秒
  80. Thread.sleep(500);
  81. }
  82. return new String(baos.toByteArray(), "gb2312");
  83. }
  84. } catch (Exception e) {
  85. Log.e(TAG, e.getMessage());
  86. }
  87. return null;
  88. }
  89. //onProgressUpdate方法用於更新進度資訊
  90. @Override
  91. protected void onProgressUpdate(Integer... progresses) {
  92. Log.i(TAG, "onProgressUpdate(Progress... progresses) called");
  93. progressBar.setProgress(progresses[0]);
  94. textView.setText("loading..." + progresses[0] + "%");
  95. }
  96. //onPostExecute方法用於在執行完後臺任務後更新UI,顯示結果
  97. @Override
  98. protected void onPostExecute(String result) {
  99. Log.i(TAG, "onPostExecute(Result result) called");
  100. textView.setText(result);
  101. execute.setEnabled(true);
  102. cancel.setEnabled(false);
  103. }
  104. //onCancelled方法用於在取消執行中的任務時更改UI
  105. @Override
  106. protected void onCancelled() {
  107. Log.i(TAG, "onCancelled() called");
  108. textView.setText("cancelled");
  109. progressBar.setProgress(0);
  110. execute.setEnabled(true);
  111. cancel.setEnabled(false);
  112. }
  113. }
  114. }

佈局檔案main.xml程式碼如下：

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
  3. android:orientation="vertical"
  4. android:layout_width="fill_parent"
  5. android:layout_height="fill_parent">
  6. <Button
  7. android:id="@+id/execute"
  8. android:layout_width="fill_parent"
  9. android:layout_height="wrap_content"
  10. android:text="execute"/>
  11. <Button
  12. android:id="@+id/cancel"
  13. android:layout_width="fill_parent"
  14. android:layout_height="wrap_content"
  15. android:enabled="false"
  16. android:text="cancel"/>
  17. <ProgressBar
  18. android:id="@+id/progress_bar"
  19. android:layout_width="fill_parent"
  20. android:layout_height="wrap_content"
  21. android:progress="0"
  22. android:max="100"
  23. style="?android:attr/progressBarStyleHorizontal"/>
  24. <ScrollView
  25. android:layout_width="fill_parent"
  26. android:layout_height="wrap_content">
  27. <TextView
  28. android:id="@+id/text_view"
  29. android:layout_width="fill_parent"
  30. android:layout_height="wrap_content"/>
  31. </ScrollView>
  32. </LinearLayout>

因為需要訪問網路，所以我們還需要在AndroidManifest.xml中加入訪問網路的許可權：

  1. <uses-permission android:name="android.permission.INTERNET"/>

我們來看一下執行時的介面：

以上幾個截圖分別是初始介面、執行非同步任務時介面、執行成功後介面、取消任務後介面。執行成功後，整個過程日誌列印如下：

如果我們在執行任務時按下了“cancel”按鈕，日誌列印如下：

可以看到onCancelled()方法將會被呼叫，onPostExecute(Result result)方法將不再被呼叫。

上面介紹了AsyncTask的基本應用，有些朋友也許會有疑惑，AsyncTask內部是怎麼執行的呢，它執行的過程跟我們使用Handler又有什麼區別呢？答案是：AsyncTask是對Thread+Handler良好的封裝，在android.os.AsyncTask程式碼裡仍然可以看到Thread和Handler的蹤跡。下面就向大家詳細介紹一下AsyncTask的執行原理。

我們先看一下AsyncTask的大綱檢視：

我們可以看到關鍵幾個步驟的方法都在其中，doInBackground(Params... params)是一個抽象方法，我們繼承AsyncTask時必須覆寫此方法；onPreExecute()、onProgressUpdate(Progress... values)、onPostExecute(Result result)、onCancelled()這幾個方法體都是空的，我們需要的時候可以選擇性的覆寫它們；publishProgress(Progress... values)是final修飾的，不能覆寫，只能去呼叫，我們一般會在doInBackground(Params... params)中呼叫此方法；另外，我們可以看到有一個Status的列舉類和getStatus()方法，Status列舉類程式碼段如下：

  1. //初始狀態
  2. private volatile Status mStatus = Status.PENDING;
  3. public enum Status {
  4. /**
  5. * Indicates that the task has not been executed yet.
  6. */
  7. PENDING,
  8. /**
  9. * Indicates that the task is running.
  10. */
  11. RUNNING,
  12. /**
  13. * Indicates that {@link AsyncTask#onPostExecute} has finished.
  14. */
  15. FINISHED,
  16. }
  17. /**
  18. * Returns the current status of this task.
  19. *
  20. * @return The current status.
  21. */
  22. public final Status getStatus() {
  23. return mStatus;
  24. }

可以看到，AsyncTask的初始狀態為PENDING，代表待定狀態，RUNNING代表執行狀態，FINISHED代表結束狀態，這幾種狀態在AsyncTask一次生命週期內的很多地方被使用，非常重要。

介紹完大綱檢視相關內容之後，接下來，我們會從execute(Params... params)作為入口，重點分析一下AsyncTask的執行流程，我們來看一下execute(Params... params)方法的程式碼段：

  1. public final AsyncTask<Params, Progress, Result> execute(Params... params) {
  2. if (mStatus != Status.PENDING) {
  3. switch (mStatus) {
  4. case RUNNING:
  5. //如果該任務正在被執行則丟擲異常
  6. //值得一提的是,在呼叫cancel取消任務後,狀態仍未RUNNING
  7. throw new IllegalStateException("Cannot execute task:"
  8. + " the task is already running.");
  9. case FINISHED:
  10. //如果該任務已經執行完成則丟擲異常
  11. throw new IllegalStateException("Cannot execute task:"
  12. + " the task has already been executed "
  13. + "(a task can be executed only once)");
  14. }
  15. }
  16. //改變狀態為RUNNING
  17. mStatus = Status.RUNNING;
  18. //呼叫onPreExecute方法
  19. onPreExecute();
  20. mWorker.mParams = params;
  21. sExecutor.execute(mFuture);
  22. return this;
  23. }

程式碼中涉及到三個陌生的變數：mWorker、sExecutor、mFuture，我們也會看一下他們的廬山真面目：

關於sExecutor，它是java.util.concurrent.ThreadPoolExecutor的例項，用於管理執行緒的執行。程式碼如下：

  1. private static final int CORE_POOL_SIZE = 5;
  2. private static final int MAXIMUM_POOL_SIZE = 128;
  3. private static final int KEEP_ALIVE = 10;
  4. //新建一個佇列用來存放執行緒
  5. private static final BlockingQueue<Runnable> sWorkQueue =
  6. new LinkedBlockingQueue<Runnable>(10);
  7. //新建一個執行緒工廠
  8. private static final ThreadFactory sThreadFactory = new ThreadFactory() {
  9. private final AtomicInteger mCount = new AtomicInteger(1);
  10. //新建一個執行緒
  11. public Thread newThread(Runnable r) {
  12. return new Thread(r, "AsyncTask #" + mCount.getAndIncrement());
  13. }
  14. };
  15. //新建一個執行緒池執行器,用於管理執行緒的執行
  16. private static final ThreadPoolExecutor sExecutor = new ThreadPoolExecutor(CORE_POOL_SIZE,
  17. MAXIMUM_POOL_SIZE, KEEP_ALIVE, TimeUnit.SECONDS, sWorkQueue, sThreadFactory);

mWorker實際上是AsyncTask的一個的抽象內部類的實現物件例項，它實現了Callable<Result>介面中的call()方法，程式碼如下：

  1. private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {
  2. Params[] mParams;
  3. }

而mFuture實際上是java.util.concurrent.FutureTask的例項，下面是它的FutureTask類的相關資訊：

  1. /**
  2. * A cancellable asynchronous computation.
  3. * ...
  4. */
  5. public class FutureTask<V> implements RunnableFuture<V> {
  1. public interface RunnableFuture<V> extends Runnable, Future<V> {
  2. /**
  3. * Sets this Future to the result of its computation
  4. * unless it has been cancelled.
  5. */
  6. void run();
  7. }

可以看到FutureTask是一個可以中途取消的用於非同步計算的類。

下面是mWorker和mFuture例項在AsyncTask中的體現：

  1. private final WorkerRunnable<Params, Result> mWorker;
  2. private final FutureTask<Result> mFuture;
  3. public AsyncTask() {
  4. mWorker = new WorkerRunnable<Params, Result>() {
  5. //call方法被呼叫後,將設定優先順序為後臺級別,然後呼叫AsyncTask的doInBackground方法
  6. public Result call() throws Exception {
  7. Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
  8. return doInBackground(mParams);
  9. }
  10. };
  11. //在mFuture例項中,將會呼叫mWorker做後臺任務,完成後會呼叫done方法
  12. mFuture = new FutureTask<Result>(mWorker) {
  13. @Override
  14. protected void done() {
  15. Message message;
  16. Result result = null;
  17. try {
  18. result = get();
  19. } catch (InterruptedException e) {
  20. android.util.Log.w(LOG_TAG, e);
  21. } catch (ExecutionException e) {
  22. throw new RuntimeException("An error occured while executing doInBackground()",
  23. e.getCause());
  24. } catch (CancellationException e) {
  25. //傳送取消任務的訊息
  26. message = sHandler.obtainMessage(MESSAGE_POST_CANCEL,
  27. new AsyncTaskResult<Result>(AsyncTask.this, (Result[]) null));
  28. message.sendToTarget();
  29. return;
  30. } catch (Throwable t) {
  31. throw new RuntimeException("An error occured while executing "
  32. + "doInBackground()", t);
  33. }
  34. //傳送顯示結果的訊息
  35. message = sHandler.obtainMessage(MESSAGE_POST_RESULT,
  36. new AsyncTaskResult<Result>(AsyncTask.this, result));
  37. message.sendToTarget();
  38. }
  39. };
  40. }

我們看到上面的程式碼中，mFuture例項物件的done()方法中，如果捕捉到了CancellationException型別的異常，則傳送一條“MESSAGE_POST_CANCEL”的訊息；如果順利執行，則傳送一條“MESSAGE_POST_RESULT”的訊息，而訊息都與一個sHandler物件關聯。這個sHandler例項實際上是AsyncTask內部類InternalHandler的例項，而InternalHandler正是繼承了Handler，下面我們來分析一下它的程式碼：

  1. private static final int MESSAGE_POST_RESULT = 0x1; //顯示結果
  2. private static final int MESSAGE_POST_PROGRESS = 0x2;    //更新進度
  3. private static final int MESSAGE_POST_CANCEL = 0x3;  //取消任務
  4. private static final InternalHandler sHandler = new InternalHandler();
  5. private static class InternalHandler extends Handler {
  6. @SuppressWarnings({"unchecked", "RawUseOfParameterizedType"})
  7. @Override
  8. public void handleMessage(Message msg) {
  9. AsyncTaskResult result = (AsyncTaskResult) msg.obj;
  10. switch (msg.what) {
  11. case MESSAGE_POST_RESULT:
  12. // There is only one result
  13. //呼叫AsyncTask.finish方法
  14. result.mTask.finish(result.mData[0]);
  15. break;
  16. case MESSAGE_POST_PROGRESS:
  17. //呼叫AsyncTask.onProgressUpdate方法
  18. result.mTask.onProgressUpdate(result.mData);
  19. break;
  20. case MESSAGE_POST_CANCEL:
  21. //呼叫AsyncTask.onCancelled方法
  22. result.mTask.onCancelled();
  23. break;
  24. }
  25. }
  26. }

我們看到，在處理訊息時，遇到“MESSAGE_POST_RESULT”時，它會呼叫AsyncTask中的finish()方法，我們來看一下finish()方法的定義：

  1. private void finish(Result result) {
  2. if (isCancelled()) result = null;
  3. onPostExecute(result);  //呼叫onPostExecute顯示結果
  4. mStatus = Status.FINISHED;  //改變狀態為FINISHED
  5. }

原來finish()方法是負責呼叫onPostExecute(Result result)方法顯示結果並改變任務狀態的啊。

另外，在mFuture物件的done()方法裡，構建一個訊息時，這個訊息包含了一個AsyncTaskResult型別的物件，然後在sHandler例項物件的handleMessage(Message msg)方法裡，使用下面這種方式取得訊息中附帶的物件：

  1. AsyncTaskResult result = (AsyncTaskResult) msg.obj;

這個AsyncTaskResult究竟是什麼呢，它又包含什麼內容呢？其實它也是AsyncTask的一個內部類，是用來包裝執行結果的一個類，讓我們來看一下它的程式碼結構：

  1. @SuppressWarnings({"RawUseOfParameterizedType"})
  2. private static class AsyncTaskResult<Data> {
  3. final AsyncTask mTask;
  4. final Data[] mData;
  5. AsyncTaskResult(AsyncTask task, Data... data) {
  6. mTask = task;
  7. mData = data;
  8. }
  9. }

看以看到這個AsyncTaskResult封裝了一個AsyncTask的例項和某種型別的資料集，我們再來看一下構建訊息時的程式碼：

  1. //傳送取消任務的訊息
  2. message = sHandler.obtainMessage(MESSAGE_POST_CANCEL,
  3. new AsyncTaskResult<Result>(AsyncTask.this, (Result[]) null));
  4. message.sendToTarget();
  1. //傳送顯示結果的訊息
  2. message = sHandler.obtainMessage(MESSAGE_POST_RESULT,
  3. new AsyncTaskResult<Result>(AsyncTask.this, result));
  4. message.sendToTarget();

在處理訊息時是如何使用這個物件呢，我們再來看一下：

  1. result.mTask.finish(result.mData[0]);
  1. result.mTask.onProgressUpdate(result.mData);

概括來說，當我們呼叫execute(Params... params)方法後，execute方法會呼叫onPreExecute()方法，然後由ThreadPoolExecutor例項sExecutor執行一個FutureTask任務，這個過程中doInBackground(Params... params)將被呼叫，如果被開發者覆寫的doInBackground(Params... params)方法中呼叫了publishProgress(Progress... values)方法，則通過InternalHandler例項sHandler傳送一條MESSAGE_POST_PROGRESS訊息，更新進度，sHandler處理訊息時onProgressUpdate(Progress... values)方法將被呼叫；如果遇到異常，則傳送一條MESSAGE_POST_CANCEL的訊息，取消任務，sHandler處理訊息時onCancelled()方法將被呼叫；如果執行成功，則傳送一條MESSAGE_POST_RESULT的訊息，顯示結果，sHandler處理訊息時onPostExecute(Result result)方法被呼叫。

經過上面的介紹，相信朋友們都已經認識到AsyncTask的本質了，它對Thread+Handler的良好封裝，減少了開發者處理問題的複雜度，提高了開發效率，希望朋友們能多多體會一下。