由于Android的特性，如果要執(zhí)行耗時操作，則必須方法子線程中執(zhí)行。除了Thread可以開啟子線程外，Android中扮演線程角色的有很多。本篇文章主要介紹AsyncTask,一個執(zhí)行異步任務(wù)的類，底層是采用線程池實現(xiàn)的。

一、Android中的線程

在操作系統(tǒng)中，線程是操作系統(tǒng)調(diào)度的最小單元，同時線程又是一種受限的系統(tǒng)資源，即線程不可能無限制地產(chǎn)生，并且線程的創(chuàng)建和銷毀都會有相應(yīng)的開銷。當(dāng)系統(tǒng)中存在大量的線程時，系統(tǒng)會通過會時間片輪轉(zhuǎn)的方式調(diào)度每個線程，因此線程不可能做到絕對的并行。

如果在一個進(jìn)程中頻繁地創(chuàng)建和銷毀線程，顯然不是高效的做法。正確的做法是采用線程池，一個線程池中會緩存一定數(shù)量的線程，通過線程池就可以避免因為頻繁創(chuàng)建和銷毀線程所帶來的系統(tǒng)開銷。

關(guān)于線程池的理解，參考Java線程池詳解，Android同樣適用。

二、AsyncTask簡介

AsyncTask是一個抽象類，它是由Android封裝的一個輕量級異步類（輕量體現(xiàn)在使用方便、代碼簡潔），它可以在線程池中執(zhí)行后臺任務(wù)，然后把執(zhí)行的進(jìn)度和最終結(jié)果傳遞給主線程并在主線程中更新UI。

AsyncTask的內(nèi)部封裝了兩個線程池(SerialExecutor和THREAD_POOL_EXECUTOR)和一個Handler(InternalHandler)。

其中SerialExecutor線程池用于任務(wù)的排隊，讓需要執(zhí)行的多個耗時任務(wù)，按順序排列，THREAD_POOL_EXECUTOR線程池才真正地執(zhí)行任務(wù)，InternalHandler用于從工作線程切換到主線程。

1.AsyncTask的泛型參數(shù)

AsyncTask的類聲明如下：

public abstract class AsyncTask<Params, Progress, Result> 

AsyncTask是一個抽象泛型類。

其中，三個泛型類型參數(shù)的含義如下：

Params：開始異步任務(wù)執(zhí)行時傳入的參數(shù)類型；

Progress：異步任務(wù)執(zhí)行過程中，返回下載進(jìn)度值的類型；

Result：異步任務(wù)執(zhí)行完成后，返回的結(jié)果類型；

如果AsyncTask確定不需要傳遞具體參數(shù)，那么這三個泛型參數(shù)可以用Void來代替。

有了這三個參數(shù)類型之后，也就控制了這個AsyncTask子類各個階段的返回類型，如果有不同業(yè)務(wù)，我們就需要再另寫一個AsyncTask的子類進(jìn)行處理。

2.AsyncTask的核心方法

** onPreExecute()**

這個方法會在后臺任務(wù)開始執(zhí)行之間調(diào)用，在主線程執(zhí)行。用于進(jìn)行一些界面上的初始化操作，比如顯示一個進(jìn)度條對話框等。

doInBackground(Params...)

這個方法中的所有代碼都會在子線程中運(yùn)行，我們應(yīng)該在這里去處理所有的耗時任務(wù)。

任務(wù)一旦完成就可以通過return語句來將任務(wù)的執(zhí)行結(jié)果進(jìn)行返回，如果AsyncTask的第三個泛型參數(shù)指定的是Void，就可以不返回任務(wù)執(zhí)行結(jié)果。注意，在這個方法中是不可以進(jìn)行UI操作的，如果需要更新UI元素，比如說反饋當(dāng)前任務(wù)的執(zhí)行進(jìn)度，可以調(diào)用publishProgress(Progress...)方法來完成。

onProgressUpdate(Progress...)

當(dāng)在后臺任務(wù)中調(diào)用了publishProgress(Progress...)方法后，這個方法就很快會被調(diào)用，方法中攜帶的參數(shù)就是在后臺任務(wù)中傳遞過來的。在這個方法中可以對UI進(jìn)行操作，在主線程中進(jìn)行，利用參數(shù)中的數(shù)值就可以對界面元素進(jìn)行相應(yīng)的更新。

onPostExecute(Result)

當(dāng)doInBackground(Params...)執(zhí)行完畢并通過return語句進(jìn)行返回時，這個方法就很快會被調(diào)用。返回的數(shù)據(jù)會作為參數(shù)傳遞到此方法中，可以利用返回的數(shù)據(jù)來進(jìn)行一些UI操作，在主線程中進(jìn)行，比如說提醒任務(wù)執(zhí)行的結(jié)果，以及關(guān)閉掉進(jìn)度條對話框等。

上面幾個方法的調(diào)用順序：
onPreExecute() --> doInBackground() --> publishProgress() --> onProgressUpdate() --> onPostExecute()

如果不需要執(zhí)行更新進(jìn)度則為onPreExecute() --> doInBackground() --> onPostExecute(),

除了上面四個方法，AsyncTask還提供了onCancelled()方法，它同樣在主線程中執(zhí)行，當(dāng)異步任務(wù)取消時，onCancelled()會被調(diào)用，這個時候onPostExecute()則不會被調(diào)用，但是要注意的是，AsyncTask中的cancel()方法并不是真正去取消任務(wù)，只是設(shè)置這個任務(wù)為取消狀態(tài)，我們需要在doInBackground()判斷終止任務(wù)。就好比想要終止一個線程，調(diào)用interrupt()方法，只是進(jìn)行標(biāo)記為中斷，需要在線程內(nèi)部進(jìn)行標(biāo)記判斷然后中斷線程。

3.AsyncTask的簡單使用

class DownloadTask extends AsyncTask<Void, Integer, Boolean> {  
  
    @Override  
    protected void onPreExecute() {  
        progressDialog.show();  
    }  
  
    @Override  
    protected Boolean doInBackground(Void... params) {  
        try {  
            while (true) {  
                int downloadPercent = doDownload();  
                publishProgress(downloadPercent);  
                if (downloadPercent >= 100) {  
                    break;  
                }  
            }  
        } catch (Exception e) {  
            return false;  
        }  
        return true;  
    }  
  
    @Override  
    protected void onProgressUpdate(Integer... values) {  
        progressDialog.setMessage("當(dāng)前下載進(jìn)度：" + values[0] + "%");  
    }  
  
    @Override  
    protected void onPostExecute(Boolean result) {  
        progressDialog.dismiss();  
        if (result) {  
            Toast.makeText(context, "下載成功", Toast.LENGTH_SHORT).show();  
        } else {  
            Toast.makeText(context, "下載失敗", Toast.LENGTH_SHORT).show();  
        }  
    }  
}  

這里我們模擬了一個下載任務(wù)，在doInBackground()方法中去執(zhí)行具體的下載邏輯，在onProgressUpdate()方法中顯示當(dāng)前的下載進(jìn)度，在onPostExecute()方法中來提示任務(wù)的執(zhí)行結(jié)果。如果想要啟動這個任務(wù)，只需要簡單地調(diào)用以下代碼即可：

new DownloadTask().execute();  

4.使用AsyncTask的注意事項

①異步任務(wù)的實例必須在UI線程中創(chuàng)建，即AsyncTask對象必須在UI線程中創(chuàng)建。

②execute(Params... params)方法必須在UI線程中調(diào)用。

③不要手動調(diào)用onPreExecute()，doInBackground(Params... params)，onProgressUpdate(Progress... values)，onPostExecute(Result result)這幾個方法。

④不能在doInBackground(Params... params)中更改UI組件的信息。

⑤一個任務(wù)實例只能執(zhí)行一次，如果執(zhí)行第二次將會拋出異常。

三、AsyncTask的源碼分析

先從初始化一個AsyncTask時，調(diào)用的構(gòu)造函數(shù)開始分析。

public AsyncTask() {
        mWorker = new WorkerRunnable<Params, Result>() {
            public Result call() throws Exception {
                mTaskInvoked.set(true);
                Result result = null;
                try {
                    Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
                    //noinspection unchecked
                    result = doInBackground(mParams);
                    Binder.flushPendingCommands();
                } catch (Throwable tr) {
                    mCancelled.set(true);
                    throw tr;
                } finally {
                    postResult(result);
                }
                return result;
            }
        };

        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 occurred while executing doInBackground()",
                            e.getCause());
                } catch (CancellationException e) {
                    postResultIfNotInvoked(null);
                }
            }
        };
    }

這段代碼雖然看起來有點長，但實際上并沒有任何具體的邏輯會得到執(zhí)行，只是初始化了兩個變量，mWorker和mFuture，并在初始化mFuture的時候?qū)Worker作為參數(shù)傳入。mWorker是一個Callable對象，mFuture是一個FutureTask對象，這兩個變量會暫時保存在內(nèi)存中，稍后才會用到它們。 FutureTask實現(xiàn)了Runnable接口，關(guān)于這部分內(nèi)容可以看這篇文章。

mWorker中的call()方法執(zhí)行了耗時操作，即result = doInBackground(mParams);,然后把執(zhí)行得到的結(jié)果通過postResult(result);,傳遞給內(nèi)部的Handler跳轉(zhuǎn)到主線程中。在這里這是實例化了兩個變量，并沒有開啟執(zhí)行任務(wù)。

那么mFuture對象是怎么加載到線程池中，進(jìn)行執(zhí)行的呢？

接著如果想要啟動某一個任務(wù)，就需要調(diào)用該任務(wù)的execute()方法，因此現(xiàn)在我們來看一看execute()方法的源碼，如下所示：

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

調(diào)用了executeOnExecutor()方法,具體執(zhí)行邏輯在這個方法里面：

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

可以 看出，先執(zhí)行了onPreExecute()方法，然后具體執(zhí)行耗時任務(wù)是在exec.execute(mFuture)，把構(gòu)造函數(shù)中實例化的mFuture傳遞進(jìn)去了。

exec具體是什么？

從上面可以看出具體是sDefaultExecutor，再追溯看到是SerialExecutor類，具體源碼如下：

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

終于追溯到了調(diào)用了SerialExecutor 類的execute方法。SerialExecutor 是個靜態(tài)內(nèi)部類，是所有實例化的AsyncTask對象公有的，SerialExecutor 內(nèi)部維持了一個隊列，通過鎖使得該隊列保證AsyncTask中的任務(wù)是串行執(zhí)行的，即多個任務(wù)需要一個個加到該隊列中，然后執(zhí)行完隊列頭部的再執(zhí)行下一個，以此類推。

在這個方法中，有兩個主要步驟。
①向隊列中加入一個新的任務(wù)，即之前實例化后的mFuture對象。

②調(diào)用 scheduleNext()方法，調(diào)用THREAD_POOL_EXECUTOR執(zhí)行隊列頭部的任務(wù)。

由此可見SerialExecutor 類僅僅為了保持任務(wù)執(zhí)行是串行的，實際執(zhí)行交給了THREAD_POOL_EXECUTOR。

THREAD_POOL_EXECUTOR又是什么？

 ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE_SECONDS, TimeUnit.SECONDS,
                sPoolWorkQueue, sThreadFactory);
        threadPoolExecutor.allowCoreThreadTimeOut(true);
        THREAD_POOL_EXECUTOR = threadPoolExecutor;

實際是個線程池，開啟了一定數(shù)量的核心線程和工作線程。然后調(diào)用線程池的execute()方法。執(zhí)行具體的耗時任務(wù)，即開頭構(gòu)造函數(shù)中mWorker中call()方法的內(nèi)容。先執(zhí)行完doInBackground()方法，又執(zhí)行postResult()方法，下面看該方法的具體內(nèi)容：

 private Result postResult(Result result) {
        @SuppressWarnings("unchecked")
        Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
                new AsyncTaskResult<Result>(this, result));
        message.sendToTarget();
        return result;
    }

該方法向Handler對象發(fā)送了一個消息，下面具體看AsyncTask中實例化的Hanlder對象的源碼：

private static class InternalHandler extends Handler {
        public InternalHandler() {
            super(Looper.getMainLooper());
        }

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

在InternalHandler 中，如果收到的消息是MESSAGE_POST_RESULT，即執(zhí)行完了doInBackground()方法并傳遞結(jié)果，那么就調(diào)用finish()方法。

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

如果任務(wù)已經(jīng)取消了，回調(diào)onCancelled()方法，否則回調(diào) onPostExecute()方法。

如果收到的消息是MESSAGE_POST_PROGRESS，回調(diào)onProgressUpdate()方法，更新進(jìn)度。

InternalHandler是一個靜態(tài)類，為了能夠?qū)?zhí)行環(huán)境切換到主線程，因此這個類必須在主線程中進(jìn)行加載。所以變相要求AsyncTask的類必須在主線程中進(jìn)行加載。

到此為止，從任務(wù)執(zhí)行的開始到結(jié)束都從源碼分析完了。

AsyncTask的串行和并行

從上述源碼分析中分析得到，默認(rèn)情況下AsyncTask的執(zhí)行效果是串行的，因為有了SerialExecutor類來維持保證隊列的串行。如果想使用并行執(zhí)行任務(wù)，那么可以直接跳過SerialExecutor類，使用executeOnExecutor()來執(zhí)行任務(wù)。

四、AsyncTask使用不當(dāng)?shù)暮蠊?/h3>

1.）生命周期

AsyncTask不與任何組件綁定生命周期，所以在Activity/或者Fragment中創(chuàng)建執(zhí)行AsyncTask時，最好在Activity/Fragment的onDestory()調(diào)用 cancel(boolean)；

2.)內(nèi)存泄漏

如果AsyncTask被聲明為Activity的非靜態(tài)的內(nèi)部類，那么AsyncTask會保留一個對創(chuàng)建了AsyncTask的Activity的引用。如果Activity已經(jīng)被銷毀，AsyncTask的后臺線程還在執(zhí)行，它將繼續(xù)在內(nèi)存里保留這個引用，導(dǎo)致Activity無法被回收，引起內(nèi)存泄露。

3.) 結(jié)果丟失

屏幕旋轉(zhuǎn)或Activity在后臺被系統(tǒng)殺掉等情況會導(dǎo)致Activity的重新創(chuàng)建，之前運(yùn)行的AsyncTask（非靜態(tài)的內(nèi)部類）會持有一個之前Activity的引用，這個引用已經(jīng)無效，這時調(diào)用onPostExecute()再去更新界面將不再生效。