1.Asynctask究竟是什麼？我們為什麼要使用它？

   我們知道，Android應用的主執行緒（UI 執行緒）肩負著繪製使用者介面和及時響應使用者操作的重任，為了避免“使用者點選按鈕後沒反應”這樣的糟糕使用者體驗，我們就要確保主執行緒時刻保持著較高的響應性。為了做到這一點，我們就要把耗時的任務移出主執行緒，那麼耗時的任務交給誰來完成呢？答案就是工作者執行緒。Android開發中我們通常讓主執行緒負責前臺使用者介面的繪製以及響應使用者的操作，讓工作者執行緒在後臺執行一些比較耗時的任務。Android中的工作者執行緒主要有AsyncTask、IntentService、HandlerThread，它們本質上都是對執行緒或執行緒池的封裝。
  Android之所以提供AsyncTask這個類，就是為了方便我們在後臺執行緒中執行操作，然後將結果傳送給主執行緒，從而在主執行緒中進行UI更新等操作。       
 

2.Asynctask有什麼優缺點？
使用的優點: 簡單快捷，過程可控
使用的缺點: 在使用多個非同步操作和並需要進行Ui變更時,就變得複雜起來.

3.Asynctask的基本用法
在使用AsyncTask時，我們無需關注Thread和Handler，AsyncTask內部會對其進行管理，這樣我們就只需要關注於我們的業務邏輯即可。

AsyncTask有四個重要的回撥方法，分別是：onPreExecute、doInBackground, onProgressUpdate 和 onPostExecute。這四個方法會在AsyncTask的不同時期進行自動呼叫，我們只需要實現這幾個方法的內部邏輯即可。這四個方法的一些引數和返回值都是基於泛型的，而且泛型的型別還不一樣，所以在AsyncTask的使用中會遇到三種泛型引數：Params, Progress 和 Result，如下圖所示：

我們通過呼叫AsyncTask的execute()方法傳入引數並執行任務，然後AsyncTask會依次呼叫以下四個方法：

onPreExecute
該方法的簽名如下所示：

該方法有MainThread註解，表示該方法是執行在主執行緒中的。在AsyncTask執行了execute()方法後就會在UI執行緒上執行onPreExecute()方法，該方法在task真正執行前執行，我們通常可以在該方法中顯示一個進度條，從而告知使用者後臺任務即將開始。

doInBackground
該方法的簽名如下所示：

  該方法有WorkerThread註解，表示該方法是執行在單獨的工作執行緒中的，而不是執行在主執行緒中。doInBackground會在onPreExecute()方法執行完成後立即執行，該方法用於在工作執行緒中執行耗時任務，我們可以在該方法中編寫我們需要在後臺執行緒中執行的邏輯程式碼，由於是執行在工作執行緒中，所以該方法不會阻塞UI執行緒。該方法接收Params泛型引數，引數params是Params型別的不定長陣列，該方法的返回值是Result泛型，由於doInBackgroud是抽象方法，我們在使用AsyncTask時必須重寫該方法。在doInBackground中執行的任務可能要分解為好多步驟，每完成一步我們就可以通過呼叫AsyncTask的publishProgress(Progress…)將階段性的處理結果釋出出去，階段性處理結果是Progress泛型型別。當呼叫了publishProgress方法後，處理結果會被傳遞到UI執行緒中，並在UI執行緒中回撥onProgressUpdate方法，下面會詳細介紹。根據我們的具體需要，我們可以在doInBackground中不呼叫publishProgress方法，當然也可以在該方法中多次呼叫publishProgress方法。doInBackgroud方法的返回值表示後臺執行緒完成任務之後的結果。

onProgressUpdate
上面我們知道，當我們在doInBackground中呼叫publishProgress(Progress…)方法後，就會在UI執行緒上回調onProgressUpdate方法，該方法的方法簽名如下所示：

該方法也具有MainThread註解，表示該方法是在主執行緒上被呼叫的，且傳入的引數是Progress泛型定義的不定長陣列。如果在doInBackground中多次呼叫了publishProgress方法，那麼主執行緒就會多次回撥onProgressUpdate方法。

onPostExecute
該方法的簽名如下所示：

該方法也具有MainThread註解，表示該方法是在主執行緒中被呼叫的。當doInBackgroud方法執行完畢後，就表示任務完成了，doInBackgroud方法的返回值就會作為引數在主執行緒中傳入到onPostExecute方法中，這樣就可以在主執行緒中根據任務的執行結果更新UI。

下面我們就以下載多個檔案的示例演示AsyncTask的使用過程。
佈局檔案如下所示：

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:paddingLeft="@dimen/activity_horizontal_margin"
    android:paddingRight="@dimen/activity_horizontal_margin"
    android:paddingTop="@dimen/activity_vertical_margin"
    android:paddingBottom="@dimen/activity_vertical_margin"
    tools:context=".MainActivity">

    <Button android:id="@+id/btnDownload"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:onClick="onClick"
        android:text="開始下載" />

    <TextView android:id="@+id/textView"
        android:layout_below="@id/btnDownload"
        android:layout_width="match_parent"
        android:layout_height="wrap_content" />

</RelativeLayout>

介面上有一個“開始下載”的按鈕，點選該按鈕即可通過AsyncTask下載多個檔案，對應的Java程式碼如下所示：

import android.app.Activity;
import android.os.AsyncTask;
import android.os.Build;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;

public class MainActivity extends Activity implements Button.OnClickListener {

    TextView textView = null;
    Button btnDownload = null;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        textView = (TextView)findViewById(R.id.textView);
        btnDownload = (Button)findViewById(R.id.btnDownload);
        Log.i("ljz", "MainActivity -> onCreate, Thread name: " + Thread.currentThread().getName());
    }

    @Override
    public void onClick(View v) {
        //要下載的檔案地址
        String[] urls = {
                "http://blog.csdn.net/lijizhi19950123/article/details/77922527",
                "http://blog.csdn.net/lijizhi19950123/article/details/77920054",
                "http://blog.csdn.net/lijizhi19950123/article/details/77914601",
                "http://blog.csdn.net/lijizhi19950123/article/details/77914187",
                "http://blog.csdn.net/lijizhi19950123/article/details/77913957"
        };

        DownloadTask downloadTask = new DownloadTask();
        downloadTask.execute(urls);
    }

    //public abstract class AsyncTask<Params, Progress, Result>
    //在此例中，Params泛型是String型別，Progress泛型是Object型別，Result泛型是Long型別
    private class DownloadTask extends AsyncTask<String, Object, Long> {
        @Override
        protected void onPreExecute() {
            Log.i("iSpring", "DownloadTask -> onPreExecute, Thread name: " + Thread.currentThread().getName());
            super.onPreExecute();
            btnDownload.setEnabled(false);
            textView.setText("開始下載...");
        }

        @Override
        protected Long doInBackground(String... params) {
            Log.i("iSpring", "DownloadTask -> doInBackground, Thread name: " + Thread.currentThread().getName());
            //totalByte表示所有下載的檔案的總位元組數
            long totalByte = 0;
            //params是一個String陣列
            for(String url: params){
                //遍歷Url陣列，依次下載對應的檔案
                Object[] result = downloadSingleFile(url);
                int byteCount = (int)result[0];
                totalByte += byteCount;
                //在下載完一個檔案之後，我們就把階段性的處理結果釋出出去
                publishProgress(result);
                //如果AsyncTask被呼叫了cancel()方法，那麼任務取消，跳出for迴圈
                if(isCancelled()){
                    break;
                }
            }
            //將總共下載的位元組數作為結果返回
            return totalByte;
        }

        //下載檔案後返回一個Object陣列：下載檔案的位元組數以及下載的部落格的名字
        private Object[] downloadSingleFile(String str){
            Object[] result = new Object[2];
            int byteCount = 0;
            String blogName = "";
            HttpURLConnection conn = null;
            try{
                URL url = new URL(str);
                conn = (HttpURLConnection)url.openConnection();
                InputStream is = conn.getInputStream();
                ByteArrayOutputStream baos = new ByteArrayOutputStream();
                byte[] buf = new byte[1024];
                int length = -1;
                while ((length = is.read(buf)) != -1) {
                    baos.write(buf, 0, length);
                    byteCount += length;
                }
                String respone = new String(baos.toByteArray(), "utf-8");
                int startIndex = respone.indexOf("<title>");
                if(startIndex > 0){
                    startIndex += 7;
                    int endIndex = respone.indexOf("</title>");
                    if(endIndex > startIndex){
                        //解析出部落格中的標題
                        blogName = respone.substring(startIndex, endIndex);
                    }
                }
            }catch(MalformedURLException e){
                e.printStackTrace();
            }catch(IOException e){
                e.printStackTrace();
            }finally {
                if(conn != null){
                    conn.disconnect();
                }
            }
            result[0] = byteCount;
            result[1] = blogName;
            return result;
        }

        @Override
        protected void onProgressUpdate(Object... values) {
            Log.i("iSpring", "DownloadTask -> onProgressUpdate, Thread name: " + Thread.currentThread().getName());
            super.onProgressUpdate(values);
            int byteCount = (int)values[0];
            String blogName = (String)values[1];
            String text = textView.getText().toString();
            text += "\n部落格《" + blogName + "》下載完成，共" + byteCount + "位元組";
            textView.setText(text);
        }

        @Override
        protected void onPostExecute(Long aLong) {
            Log.i("iSpring", "DownloadTask -> onPostExecute, Thread name: " + Thread.currentThread().getName());
            super.onPostExecute(aLong);
            String text = textView.getText().toString();
            text += "\n全部下載完成，總共下載了" + aLong + "個位元組";
            textView.setText(text);
            btnDownload.setEnabled(true);
        }

        @Override
        protected void onCancelled() {
            Log.i("iSpring", "DownloadTask -> onCancelled, Thread name: " + Thread.currentThread().getName());
            super.onCancelled();
            textView.setText("取消下載");
            btnDownload.setEnabled(true);
        }
    }
}

下面對以上程式碼進行一下說明。

1.我們在MainActivity中定義了內部類DownloadTask，DownloadTask繼承自AsyncTask，在該例中，Params泛型是String型別，Progress泛型是Object型別，Result泛型是Long型別。

2.我們定義了一個Url字串陣列，將該陣列傳遞給AsyncTask的execute方法，用於非同步執行task。

3.在執行了downloadTask.execute(urls)之後，AsyncTask會自動回撥onPreExecute方法，在該方法中我們將textView設定為“開始下載…”幾個字，告知使用者即將執行下載操作。通過控制檯輸出我們也可以看出該方法是在主執行緒中執行的。

4.在執行了onPreExecute方法之後，AsyncTask會回撥doInBackground方法，該方法中的輸入引數是String型別的不定長陣列，此處的String就對應著Params泛型型別，我們在該方法中遍歷Url陣列，依次下載對應的檔案，當我們下載完一個檔案，就相當於我們階段性地完成了一部分任務，我們就通過呼叫publishProgress方法將階段性處理結果釋出出去。在此例中我們將階段性的處理結果定義為Object型別，即Progress泛型型別。通過控制檯輸出我們可以看出doInBackground方法是執行在新的工作執行緒”AsyncTask #1”中的，AsyncTask的工作執行緒都是以”AsyncTask #”然後加上數字作為名字。當所有檔案下載完成後，我們就可以通過totalSize返回所有下載的位元組數，返回值型別為Long，對應著AsyncTask中的Result泛型型別。

5.在doInBackground方法中，每當下載完一個檔案，我們就會呼叫publishProgress方法釋出階段性結果，之後AsyncTask會回撥onProgressUpdate方法，在此例中，onProgressUpdate的引數為Object型別，對應著AsyncTask中的Progress泛型型別。通過控制檯輸出我們可以發現，該方法是在主執行緒中呼叫的，在該方法中我們會通過textView更新UI，告知使用者哪個檔案下載完成了，這樣使用者體驗相對友好。

6.在整個doInBackground方法執行完畢後，AsyncTask就會回撥onPostExecute方法，在該方法中我們再次通過textView更新UI告知使用者全部下載任務完成了。

7.在通過execute方法執行了非同步任務之後，可以通過AsyncTask的cancel方法取消任務，取消任務後AsyncTask會回撥onCancelled方法，這樣不會再呼叫onPostExecute方法。

8.在使用Android的過程中，有以下幾點需要注意：

AsyncTask的例項必須在主執行緒中建立。

AsyncTask的execute方法必須在主執行緒中呼叫。

onPreExecute() onPostExecute(Result), doInBackground(Params…) 和 onProgressUpdate(Progress…)這四個方法都是回撥方法，Android會自動呼叫，我們不應自己呼叫。

對於一個AsyncTack的例項，只能執行一次execute方法，在該例項上第二次執行execute方法時就會丟擲異常。