android多線程之AsyncTask源碼分析

在有關線程的操作中一定要記住兩點：

1、不能在UI線程中執行耗時的操作

2、不能在非主線程中更新UI界面

一、AsyncTask簡介

    AsyncTask封裝了線程池和Handler，是Android的一個輕量級的異步類，它可以在線程池中執行後臺操作，然後把執行的進度和結果通過Handler傳遞給主線程並在主線程裏面更新UI。可以方便開發者實現異步操作。

二、AsyncTask用法和示例

1、用法

AsyncTask是一個抽象的泛型類，提供了Params、Progress、Result三個泛型參數

public abstract class AsyncTask<Params, Progress, Result>(){}

    Params:需要傳入參數的類型
    Progress：後臺任務的執行進度的類型
    Result：後臺任務返回結果的類型

AsyncTask提供了4個核心的方法，分別是：
　　1. OnPreExecute(), 在主線程中執行，在異步任務之前，此方法被調用一般做一些準備性的工作；

　　2. doInBackground(Params…params),在線程池中執行，用於執行異步任務，params表示異步任務的傳入參數，此方法會調用publshProgress()來更新任務進度，publshProgress()會調用onProgressupdate()，會返回計算結果給onPostExecute().

　　3. onProgressUpdate(Progress…value)，在主線程中執行，後臺執行任務的進度有變化時被調用。

　　4. onPostExecute(Result result), 在主線程中執行，在異步任務執行之後，此方法會被調用，result爲後臺任務的返回值，即doInBackground()的返回值。

2、示例

public class DownloadFilesTask extends AsyncTask<URL, Integer, Long>{
    protected Long doInBackground(URL...url){
        int count = url.length;
        long totalSize = 0;
        for(int i = 0; i< count; i++){
            totalSize += DownloadFile(url[i]);
            publishProgress((int) (i/(float)count)*1000);
            if(isCancelled){
                break;
            }
        }
    }

    protected void onProgressUpdate(Integer...progress){
        setProgressPercent(progress[0]);
    }

    protected void onPostExecute(Long result){
        showDialog("bytes"+result);
    }
}

在DownloadFileTask中，doInBackground()執行下載任務並通過publishProgress()來更新進度，同時還會調用isCancelled()判斷下載任務是否被取消。下載任務完成後doInBackground()會返回結果。publishProgress()被執行了調用onProgressUpdate()方法更新進度。當下載任務完成後onPostExecute()就會被調用，在主線程中做一些改變。

三、AsyncTask的限制

1. AsyncTask的類必須在主線程里加載；

   　　2. AsyncTask的對象必須在主線程中調用；

   　　3. execute方法必須在UI線程調用；

   　　 4. 不要在程序中直接調用onPreExecute()、onPostExecute()、doInBackground()、和onProgressUpdate()；

   　　5. 一個AsyncTask對象只能執行一次，即只能調用一次execute(),否則會報運行時異常；

四、AsyncTask工作原理

列表內容分析AsyncTask原理，先從execute()開始，execute()調用了executor(),源碼實現如下：

public final AsyncTask<Params, Progress, Result> execute(Params...params){
    return executeOnExecutor(sDefaultExecutor params);
}

public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executorexec, 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 is already finishing.")
        }
    }
    mStatus = Status.RUNNING;
    onPreExecute();
    mWorker.mParams = params;
    exec.execute(mFuture);
    return this;
}

sDefaultExecutor實際上是一個串行的線程池，一個進程的所有的線程都在這個串行的線程池裏面排隊，在executor()方法中， AsyncTask的onProExecute() 最先執行，然後線程池開始執行。

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);
        }
    }
}

系統把AsyncTask的Params參數封裝爲FutureTask對象，Future是一個併發類，充當Runnable的作用，接着這個FutureTask會交給SerialExecutor的execute方法去處理，SerialExecutor的execute方法會把FutureTask插入到mTask任務隊列中，如果沒有正在執行的任務，那麼就會調用SerialExecutor的scheduleNext方法來執行下一個AsyncTask任務，同時當一個任務執行完後，AsyncTask會繼續調用其他任務直到所有任務都被執行完。

AsyncTask有兩個線程池，SerialExecutor 和THREAD_POOL_EXECUTOR和一個Handler(InternalHandler)，SerialExecutor用於任務的排隊，而THREAD_POOL_EXECUTOR用於真正的執行任務，而InternalHandler用於將執行環境從線程池切換到主線程。

mWorker = new WorkerRunnable<Params, Result>(){
    public Result call() throws Exception{
        mTaskInvoked.set(true);
        Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
        return postResult(donInBackground(mParams));
    }
};

在mWorker的call方法中將mTaskInvoked設爲true，表示當前任務已經被調用了，然後執行doInBackground方法，接着返回值傳遞給postResult方法。

private Result postResult (Result result){
    Message message = sHandler.obtainMessage(MESSAGE_POST_RESULT, new AsyncTaskResult<Result>(this, result));
    message.sendToTarget();
    return result;
}

postResult方法會通過sHandler發送一個MESSAGE_POST_RESULT的消息，這個sHandler的定義如下：

private static final InternalHandler sHandler = new InternalHandler();

private static class InternalHandler extends Handler{
    public void handleMessage(Message msg){
        AsyncTaskResult result = (AsyncTaskResult)msg.obj;
        switch(msg.what){
            case MESSAGE_POST_RESULT:
                result.mTask.finish(result.mData[0]);
                break;
            case MESSAGE_POST_PROGRESS:
                result.mTask.onProgressUpdate(result.mData);
                break;
        }
    }
}

sHandler是一個靜態的Handler對象，爲了能夠將執行環境切換到主線程，這就要求sHandler必須是在主線程中創建。由於靜態成員在加載類的時候進行初始化，這就要求AsyncTask的類必須在主線程中加載。sHandler收到MESSAGE_POST_RESULT這個消息後會調用AsyncTask的finish方法。

private void finish(Result result){
    if(isCancelled()){
        onCancelled(result);
    } else {
        onPostExecute(result);
    }
    mStatus = Status.FINISHED;
}

如果AsyncTask被取消執行了，那麼就會調用onCanedlled方法，否則就會調用onPostExecute方法，doInBackground的返回結果傳遞給onPostExecute方法。到這裏AsyncTask的整個工作過程就分析完畢了。