深入解析AsyncTask

yangxi_001發表於2013-11-18

AsyncTask的介紹及基本使用方法

關於AsyncTask的介紹和基本使用方法可以參考官方文件和Android實戰技巧：多執行緒AsyncTask這裡就不重複。

AsyncTask引發的一個問題

上週遇到了一個極其詭異的問題，一個小功能從網路上下載一個圖片，然後放到ImageView中，是用AsyncTask來實現的，本身邏輯也很簡單，僅是在doInBackground中用HTTP請求把圖片的輸入流取出，然後用BitmapFactory去解析，然後再把得到的Bitmap放到ImageView中。這個應用是用4.0的SDK開發的，也是執行在4.0上面的。但是有時候下載這張圖片去要用很久很久，甚至要等上幾分鐘。通過除錯發現一個令人難以接受的事實：竟然是doInBackground()未及時執行，也就是它並沒有在#execute()呼叫之後馬上執行，而是等待了很久才得以執行。

神馬情況，難道AsyncTask不是執行緒，難道不是非同步，難道AsyncTask另有內幕？

AsyncTask的內幕

AsyncTask主要有二個部分：一個是與主線各的互動，另一個就是執行緒的管理排程。雖然可能多個AsyncTask的子類的例項，但是AsyncTask的內部Handler和ThreadPoolExecutor都是程式範圍內共享的，其都是static的，也即屬於類的，類的屬性的作用範圍是CLASSPATH，因為一個程式一個VM，所以是AsyncTask控制著程式範圍內所有的子類例項。

與主執行緒互動

與主執行緒互動是通過Handler來進行的，因為本文主要探討AsyncTask在任務排程方面的，所以對於這部分不做細緻介紹，感興趣的朋友可以去看AsyncTask的原始碼

執行緒任務的排程

內部會建立一個程式作用域的執行緒池來管理要執行的任務，也就就是說當你呼叫了AsyncTask#execute()後，AsyncTask會把任務交給執行緒池，由執行緒池來管理建立Thread和執行Therad。對於內部的執行緒池不同版本的Android的實現方式是不一樣的：

Android2.3以前的版本，也即SDK/API 10和以前的版本

內部的執行緒池限制是5個，也就是說同時只能有5個執行緒執行，超過的執行緒只能等待，等待前面的執行緒某個執行完了才被排程和執行。換句話說，如果一個程式中的AsyncTask例項個數超過5個，那麼假如前5個都執行很長時間的話，那麼第6個只能等待機會了。這是AsyncTask的一個限制，而且對於2.3以前的版本無法解決。如果你的應用需要大量的後臺執行緒去執行任務，那麼你只能放棄使用AsyncTask，自己建立執行緒池來管理Thread，或者乾脆不用執行緒池直接使用Thread也無妨。不得不說，雖然AsyncTask較Thread使用起來比較方便，但是它最多隻能同時執行5個執行緒，這也大大侷限了它的實力，你必須要小心的設計你的應用，錯開使用AsyncTask的時間，盡力做到分時，或者保證數量不會大於5個，否則就可能遇到上面提到的問題。要不然就只能使用JavaSE中的API了。


Android 3.0以後，也即SDK/API 11和以後的版本

可能是Google意識到了AsyncTask的侷限性了，從Android 3.0開始對AsyncTask的API做出了一些調整：

  1. #execute()提交的任務，按先後順序每次只執行一個

    也就是說它是按提交的次序，每次只啟動一個執行緒執行一個任務，完成之後再執行第二個任務，也就是相當於只有一個後臺執行緒在執行所提交的任務(Executors.newSingleThreadPool())。


  2. 新增了介面#executeOnExecutor()

    這個介面允許開發者提供自定義的執行緒池來執行和排程Thread，如果你想讓所有的任務都能併發同時執行，那就建立一個沒有限制的執行緒池(Executors.newCachedThreadPool())，並提供給AsyncTask。這樣這個AsyncTask例項就有了自己的執行緒池而不必使用AsyncTask預設的。

  3. 新增了二個預定義的執行緒池SERIAL_EXECUTOR和THREAD_POOL_EXECUTOR

    其實THREAD_POOL_EXECUTOR並不是新增的，之前的就有，只不過之前(Android 2.3)它是AsyncTask私有的，未公開而已。THREAD_POOL_EXECUTOR是一個corePoolSize為5的執行緒池，也就是說最多隻有5個執行緒同時執行，超過5個的就要等待。所以如果使用executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR)就跟2.3版本的AsyncTask.execute()效果是一樣的。


    而SERIAL_EXECUTOR是新增的，它的作用是保證任務執行的順序，也就是它可以保證提交的任務確實是按照先後順序執行的。它的內部有一個佇列用來儲存所提交的任務，保證當前只執行一個，這樣就可以保證任務是完全按照順序執行的，預設的execute()使用的就是這個，也就是executeOnExecutor(AsyncTask.SERIAL_EXECUTOR)與execute()是一樣的。

前面問題的解法

瞭解了AsyncTask的內幕就知道了前面問題的原因：因為是4.0平臺，所以所有的AsyncTask並不都會執行在單獨的執行緒中，而是被SERIAL_EXECUTOR順序的使用執行緒執行。因為應用中可能還有其他地方使用AsyncTask，所以到網路取圖片的AsyncTask也許會等待到其他任務都完成時才得以執行而不是呼叫executor()之後馬上執行。

那麼解決方法其實很簡單，要麼直接使用Thread，要麼建立一個單獨的執行緒池(Executors.newCachedThreadPool())。或者最簡單的解法就是使用executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR)，這樣起碼不用等到前面的都結束了再執行。

AsyncTask的使用注意事項

前面的文章曾建議使用AsyncTask而不是使用Thread，但是AsyncTask似乎又有它的限制，這就要根據具體的需求情況而選擇合適的工具，No Silver Bullet。下面是一些建議：

  • 改善你的設計，少用非同步處理

    執行緒的開銷是非常大的，同時非同步處理也容易出錯，難除錯，難維護，所以改善你的設計，儘可能的少用非同步。對於一般性的資料庫查詢，少量的I/O操作是沒有必要啟動執行緒的。

  • 與主執行緒有互動時用AsyncTask，否則就用Thread

    AsyncTask被設計出來的目的就是為了滿足Android的特殊需求：非主執行緒不能操作(UI)元件，所以AsyncTask擴充套件Thread增強了與主執行緒的互動的能力。如果你的應用沒有與主執行緒互動，那麼就直接使用Thread就好了。

  • 當有需要大量執行緒執行任務時，一定要建立執行緒池

    執行緒的開銷是非常大的，特別是建立一個新執行緒，否則就不必設計執行緒池之類的工具了。當需要大量執行緒執行任務時，一定要建立執行緒池，無論是使用AsyncTask還是Thread，因為使用AsyncTask它內部的執行緒池有數量限制，可能無法滿足需求；使用Thread更是要執行緒池來管理，避免虛擬機器建立大量的執行緒。比如從網路上批量下載圖片，你不想一個一個的下，或者5個5個的下載，那麼就建立一個CorePoolSize為10或者20的執行緒池，每次10個或者20個這樣的下載，即滿足了速度，又不至於耗費無用的效能開銷去無限制的建立執行緒。

  • 對於想要立即開始執行的非同步任務，要麼直接使用Thread，要麼單獨建立執行緒池提供給AsyncTask

    預設的AsyncTask不一定會立即執行你的任務，除非你提供給他一個單獨的執行緒池。如果不與主執行緒互動，直接建立一個Thread就可以了，雖然建立執行緒開銷比較大，但如果這不是批量操作就沒有問題。

  • Android的開發沒有想像中那樣簡單，要多花心思和時間在程式碼上和測試上面，以確信程式是優質的

附上相關資源：

使用自定義的CorePoolSize為7的Executor(Executors.newFixedThreadPool(7))：


使用未設限制的Executor(Executors.newCachedThreadPool())：


這些例子所用的程式碼：

[java] view plaincopyprint?
  1. public class AsyncTaskDemoActivity extends Activity {  
  2.     private static int ID = 0;  
  3.     private static final int TASK_COUNT = 9;  
  4.     private static ExecutorService SINGLE_TASK_EXECUTOR;  
  5.     private static ExecutorService LIMITED_TASK_EXECUTOR;  
  6.     private static ExecutorService FULL_TASK_EXECUTOR;  
  7.       
  8.     static {  
  9.         SINGLE_TASK_EXECUTOR = (ExecutorService) Executors.newSingleThreadExecutor();  
  10.         LIMITED_TASK_EXECUTOR = (ExecutorService) Executors.newFixedThreadPool(7);  
  11.         FULL_TASK_EXECUTOR = (ExecutorService) Executors.newCachedThreadPool();  
  12.     };  
  13.       
  14.     @Override  
  15.     public void onCreate(Bundle icicle) {  
  16.         super.onCreate(icicle);  
  17.         setContentView(R.layout.asynctask_demo_activity);  
  18.         String title = "AsyncTask of API " + VERSION.SDK_INT;  
  19.         setTitle(title);  
  20.         final ListView taskList = (ListView) findViewById(R.id.task_list);  
  21.         taskList.setAdapter(new AsyncTaskAdapter(getApplication(), TASK_COUNT));  
  22.     }  
  23.       
  24.     private class AsyncTaskAdapter extends BaseAdapter {  
  25.         private Context mContext;  
  26.         private LayoutInflater mFactory;  
  27.         private int mTaskCount;  
  28.         List<SimpleAsyncTask> mTaskList;  
  29.           
  30.         public AsyncTaskAdapter(Context context, int taskCount) {  
  31.             mContext = context;  
  32.             mFactory = LayoutInflater.from(mContext);  
  33.             mTaskCount = taskCount;  
  34.             mTaskList = new ArrayList<SimpleAsyncTask>(taskCount);  
  35.         }  
  36.           
  37.         @Override  
  38.         public int getCount() {  
  39.             return mTaskCount;  
  40.         }  
  41.   
  42.         @Override  
  43.         public Object getItem(int position) {  
  44.             return mTaskList.get(position);  
  45.         }  
  46.   
  47.         @Override  
  48.         public long getItemId(int position) {  
  49.             return position;  
  50.         }  
  51.   
  52.         @Override  
  53.         public View getView(int position, View convertView, ViewGroup parent) {  
  54.             if (convertView == null) {  
  55.                 convertView = mFactory.inflate(R.layout.asynctask_demo_item, null);  
  56.                 SimpleAsyncTask task = new SimpleAsyncTask((TaskItem) convertView);  
  57.                 /* 
  58.                  * It only supports five tasks at most. More tasks will be scheduled only after 
  59.                  * first five finish. In all, the pool size of AsyncTask is 5, at any time it only 
  60.                  * has 5 threads running. 
  61.                  */  
  62. //                task.execute();  
  63.                 // use AsyncTask#SERIAL_EXECUTOR is the same to #execute();  
  64. //                task.executeOnExecutor(AsyncTask.SERIAL_EXECUTOR);  
  65.                 // use AsyncTask#THREAD_POOL_EXECUTOR is the same to older version #execute() (less than API 11)  
  66.                 // but different from newer version of #execute()  
  67. //                task.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);  
  68.                 // one by one, same to newer version of #execute()  
  69. //                task.executeOnExecutor(SINGLE_TASK_EXECUTOR);  
  70.                 // execute tasks at some limit which can be customized  
  71. //                task.executeOnExecutor(LIMITED_TASK_EXECUTOR);  
  72.                 // no limit to thread pool size, all tasks run simultaneously  
  73.                 task.executeOnExecutor(FULL_TASK_EXECUTOR);  
  74.                   
  75.                 mTaskList.add(task);  
  76.             }  
  77.             return convertView;  
  78.         }  
  79.     }  
  80.       
  81.     private class SimpleAsyncTask extends AsyncTask<Void, Integer, Void> {  
  82.         private TaskItem mTaskItem;  
  83.         private String mName;  
  84.           
  85.         public SimpleAsyncTask(TaskItem item) {  
  86.             mTaskItem = item;  
  87.             mName = "Task #" + String.valueOf(++ID);  
  88.         }  
  89.           
  90.         @Override  
  91.         protected Void doInBackground(Void... params) {  
  92.             int prog = 1;  
  93.             while (prog < 101) {  
  94.                 SystemClock.sleep(100);  
  95.                 publishProgress(prog);  
  96.                 prog++;  
  97.             }  
  98.             return null;  
  99.         }  
  100.           
  101.         @Override  
  102.         protected void onPostExecute(Void result) {  
  103.         }  
  104.           
  105.         @Override  
  106.         protected void onPreExecute() {  
  107.             mTaskItem.setTitle(mName);  
  108.         }  
  109.           
  110.         @Override  
  111.         protected void onProgressUpdate(Integer... values) {  
  112.             mTaskItem.setProgress(values[0]);  
  113.         }  
  114.     }  
  115. }  
  116.   
  117. class TaskItem extends LinearLayout {  
  118.     private TextView mTitle;  
  119.     private ProgressBar mProgress;  
  120.       
  121.     public TaskItem(Context context, AttributeSet attrs) {  
  122.         super(context, attrs);  
  123.     }  
  124.   
  125.     public TaskItem(Context context) {  
  126.         super(context);  
  127.     }  
  128.       
  129.     public void setTitle(String title) {  
  130.         if (mTitle == null) {  
  131.             mTitle = (TextView) findViewById(R.id.task_name);  
  132.         }  
  133.         mTitle.setText(title);  
  134.     }  
  135.       
  136.     public void setProgress(int prog) {  
  137.         if (mProgress == null) {  
  138.             mProgress = (ProgressBar) findViewById(R.id.task_progress);  
  139.         }  
  140.         mProgress.setProgress(prog);  
  141.     }  
  142. }  

[html] view plaincopyprint?
  1. <?xml version="1.0" encoding="utf-8"?>  
  2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"  
  3.     android:layout_width="match_parent"  
  4.     android:layout_height="match_parent"  
  5.     android:paddingLeft="10dip"  
  6.     android:paddingRight="10dip"  
  7.     android:orientation="vertical" >  
  8.     <ListView android:id="@+id/task_list"  
  9.         android:layout_width="fill_parent"  
  10.         android:layout_height="wrap_content"  
  11.         android:divider="#cccccc"  
  12.         android:dividerHeight="0.6dip"  
  13.         android:footerDividersEnabled="true"  
  14.         android:headerDividersEnabled="true" />  
  15. </LinearLayout>  

[html] view plaincopyprint?
  1. <?xml version="1.0" encoding="utf-8"?>  
  2. <com.hilton.effectiveandroid.os.TaskItem xmlns:android="http://schemas.android.com/apk/res/android"  
  3.     android:layout_width="match_parent"  
  4.     android:layout_height="50dip"  
  5.     android:gravity="center_vertical"  
  6.     android:layout_gravity="center_vertical"  
  7.     android:orientation="horizontal" >  
  8.     <TextView android:id="@+id/task_name"  
  9.         android:layout_width="wrap_content"  
  10.         android:layout_height="wrap_content"  
  11.         android:textColor="#ffff00"  
  12.         android:textSize="26sp" />  
  13.     <ProgressBar android:id="@+id/task_progress"  
  14.         android:layout_width="fill_parent"  
  15.         android:layout_height="15dip"  
  16.         android:max="100"  
  17.         style="@android:style/Widget.ProgressBar.Horizontal" />  
  18. </com.hilton.effectiveandroid.os.TaskItem >  

相關文章