AsyncTask是Android SDK為我們所提供的一個封裝好的可以在子線程中完成耗時任務(wù)并能與主線程進(jìn)行交互的一個異步操作工具類。
下面先介紹AsyncTask的基本用法，再從使用過程中所涉及到的幾個關(guān)鍵步驟深入源碼進(jìn)行解析。

AsyncTask基本使用

AsyncTask是一個抽象類，通常需要我們自己實現(xiàn)一個類來繼承AsyncTask，并在對應(yīng)的回調(diào)函數(shù)中編寫響應(yīng)的操作。

AsyncTask工作流程圖.png

泛型類

使用AsyncTask需指定三個泛型類
public abstract class AsyncTask<Params, Progress, Result>

1. Params
   指代啟動該任務(wù)所需參數(shù)的類型，如String類可用于描述下載地址的url。
2. Progress
   指代任務(wù)執(zhí)行進(jìn)度的數(shù)值類型，主要用于進(jìn)度更新。
3. Result
   指代任務(wù)執(zhí)行完后返回的結(jié)果的類型。

回調(diào)方法

AsyncTask常用的回調(diào)函數(shù)有以下五個：

public class MyAsyncTask extends AsyncTask<String,Integer,Boolean> {

    // 運行在UI線程，非必須方法
    // 通常在任務(wù)正式開始前做一些準(zhǔn)備工作
    @Override
    protected void onPreExecute() {
        
    }

    // 運行在工作線程中，必須實現(xiàn)的方法
    // 用來執(zhí)行耗時操作，如網(wǎng)絡(luò)傳輸?shù)?    @Override
    protected Boolean doInBackground(String... strings) {
        //內(nèi)置方法：發(fā)布進(jìn)度
        publishProgress(進(jìn)度值);
        //內(nèi)置方法：取消任務(wù)
        cancel(布爾值)
        if (isCancelled()){
                //編寫任務(wù)取消后的業(yè)務(wù)代碼
            }
        return true or false;
    }

    // 運行在UI線程，非必須方法
    // 處于Running狀態(tài)的任務(wù)，回調(diào)此方法執(zhí)行顯示進(jìn)度等操作
    @Override
    protected void onProgressUpdate(Integer... values) {
        
    }

    // 運行在UI線程，非必須方法
    // 任務(wù)正常結(jié)束后回調(diào)此方法
    @Override
    protected void onPostExecute(Boolean aBoolean) {
        
    }

    // 運行在UI線程，非必須方法
    // 任務(wù)在執(zhí)行過程中調(diào)用了cancel方法，則在結(jié)束后會回調(diào)此方法
    @Override
    protected void onCancelled(Boolean aBoolean) {

    }

}

以上五個回調(diào)方法，只有doInBackground方法是在工作線程中執(zhí)行的，其余四個全部工作在主線程中，即代表我們可以在這四個回調(diào)方法內(nèi)對UI進(jìn)行操作。

控制方法

上述偽代碼中，在doInBackground方法內(nèi)我們還調(diào)用到了兩個方法publishProgress和cancel。這倆方法都是AsyncTask內(nèi)置的final方法，用來輔助我們對正在執(zhí)行的任務(wù)進(jìn)行控制管理。

1. publishProgress：主動調(diào)用此方法能引起onProgressUpdate方法被回調(diào)，以實現(xiàn)進(jìn)度更新的效果。傳入的參數(shù)類型為AsyncTask指定的第二種泛型類<Progress>。

2. cancel：主動調(diào)用此方法能使得正在被執(zhí)行的任務(wù)被標(biāo)識為“取消”，以使得
   onProgressUpdate和onPostExecute方法在后續(xù)過程中無法被回調(diào)，轉(zhuǎn)而使得任務(wù)結(jié)束后會回調(diào)onCancelled方法。該方法接收一個boolean類型的參數(shù)，表示是否對工作線程進(jìn)行一次中斷。

需要注意的是，主動調(diào)用cancel方法并不會使得工作線程的任務(wù)立刻結(jié)束，它只會使得用來描述任務(wù)是否被取消的標(biāo)識位被標(biāo)識為true。
若想實現(xiàn)調(diào)用完cancel方法就能立刻結(jié)束任務(wù)，那么需要開發(fā)者在任務(wù)執(zhí)行的邏輯中主動調(diào)用內(nèi)置方法isCancelled來判斷該任務(wù)是否被標(biāo)識為“取消”，并添加對應(yīng)的任務(wù)被取消后的相關(guān)處置代碼才行。

使用

MyAsyncTask myAsyncTask = new MyAsyncTask()
myAsyncTask.execute("url");

AsyncTask的使用很簡單，只需要實例化對象后調(diào)用execute方法傳入指定的第一個泛型類<Params>參數(shù)即可。
有一點需要注意，一個AsyncTask對象只能執(zhí)行一次execute方法，多次執(zhí)行會拋出異常。至于原因，請繼續(xù)看下一部分的源碼解析。

AsyncTask源碼解析

下面以 AsyncTask的構(gòu)造函數(shù)為起點，逐步分析AsyncTask內(nèi)部的工作原理。

    //我們常用的無參構(gòu)造函數(shù)
    public AsyncTask() {
        this((Looper) null);
    }

    public AsyncTask(@Nullable Looper callbackLooper) {
    //由于傳入的Looper為null，所以此處會調(diào)用getMainHandler()方法來構(gòu)造一個Handler
        mHandler = callbackLooper == null || callbackLooper == Looper.getMainLooper()
            ? getMainHandler()
            : new Handler(callbackLooper);

        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
                    //關(guān)鍵！?。。。?！
                    //在worker中調(diào)用doInBackground(mParams)開始執(zhí)行任務(wù)
                    result = doInBackground(mParams);
                    Binder.flushPendingCommands();
                } catch (Throwable tr) {
                    mCancelled.set(true);
                    throw tr;
                } finally {
                    //任務(wù)結(jié)束，發(fā)送結(jié)果
                    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);
                }
            }
        };
    }

    private static Handler getMainHandler() {
        //單例模式
        synchronized (AsyncTask.class) {
            if (sHandler == null) {
                //關(guān)鍵?。。。。。?！
                //該Handler傳入的是主線程的Looper
                sHandler = new InternalHandler(Looper.getMainLooper());
            }
            return sHandler;
        }
    }

    //通過Handler來發(fā)送結(jié)果
    private Result postResult(Result result) {
        @SuppressWarnings("unchecked")
        Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
                new AsyncTaskResult<Result>(this, result));
        message.sendToTarget();
        return result;

    private Handler getHandler() {
        return mHandler;
    }

大部分注釋已添加到代碼中，這里還是簡要描述一下：
①調(diào)用AsyncTask無參的構(gòu)造函數(shù)，會導(dǎo)致傳遞至有參構(gòu)造函數(shù)的Looper為null，程序便會執(zhí)行g(shù)etMainHandler()方法，該方法用于實例化一個工作于主線程上的Handler。
②隨后構(gòu)造一個worker，該worker即是我們要在子線程中所執(zhí)行的任務(wù)，在該worker中可以看到我們繼承AsyncTask時所覆寫的doInBackground(mParams)方法被調(diào)用。構(gòu)造好的worker被封裝到FutureTask中，以待后面交由線程池執(zhí)行。
③當(dāng)worker中的任務(wù)執(zhí)行完畢后會執(zhí)行finally{}中的postResult(result)方法，該方法通過第一步中所構(gòu)造的Handler來傳遞任務(wù)執(zhí)行完后的結(jié)果。

上面分析了AsyncTask構(gòu)造函數(shù)所執(zhí)行的一系列操作，無非就是對任務(wù)的封裝以及相關(guān)輔助工具(如Handler)初始化的工作。下面開始走進(jìn)execute()的源碼來分析任務(wù)具體執(zhí)行的原理。

    public static final Executor SERIAL_EXECUTOR = new SerialExecutor();

    private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;

    //任務(wù)初始狀態(tài)就是PENDING
    private volatile Status mStatus = Status.PENDING;

    //任務(wù)執(zhí)行所用到的線程池
    public static final Executor THREAD_POOL_EXECUTOR;

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

    //AsyncTask的execute方法從這里開始
    public final AsyncTask<Params, Progress, Result> execute(Params... params) {
        //此處傳入的默認(rèn)的線程池即是SERIAL_EXECUTOR
        return executeOnExecutor(sDefaultExecutor, params);
    }

    public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,
            Params... params) {
        if (mStatus != Status.PENDING) {
            //關(guān)鍵?。。。。?！
            //此處對當(dāng)前AsyncTask所處狀態(tài)進(jìn)行判斷，不管是RUNNING還是FINISHED都會拋出異常
            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)");
            }
        }

        //將任務(wù)狀態(tài)由PENDING改為RUNNING
        mStatus = Status.RUNNING;
        //執(zhí)行預(yù)備操作
        onPreExecute();

        mWorker.mParams = params;
        //線程池執(zhí)行該FutureTask
        exec.execute(mFuture);

        return this;
    }

    private static class SerialExecutor implements Executor {
        final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
        Runnable mActive;

        //該SerialExecutor不具體執(zhí)行任務(wù)的能力，
        //它的excute方法主要是為了將FutureTask放入Dequeue中，
        public synchronized void execute(final Runnable r) {
            mTasks.offer(new Runnable() {
                public void run() {
                    try {
                        r.run();
                    } finally {
                        //上一個FutureTask執(zhí)行完，才調(diào)度執(zhí)行下一個FutureTask，保證任務(wù)串行執(zhí)行
                        scheduleNext();
                    }
                }
            });
            if (mActive == null) {
                scheduleNext();
            }
        }

        protected synchronized void scheduleNext() {
            if ((mActive = mTasks.poll()) != null) {
                //關(guān)鍵！?。。。。?                //FutureTask真正的運行起來
                THREAD_POOL_EXECUTOR.execute(mActive);
            }
        }
    }

    //AsyncTask生命周期的三種狀態(tài)
    public enum Status {
        /**
         * Indicates that the task has not been executed yet.
         * 任務(wù)還未執(zhí)行
         */
        PENDING,
        /**
         * Indicates that the task is running.
         * 任務(wù)正在執(zhí)行
         */
        RUNNING,
        /**
         * Indicates that {@link AsyncTask#onPostExecute} has finished.
         * 任務(wù)結(jié)束
         */
        FINISHED,
    }

1. 首先，execute方法會去調(diào)用executeOnExecutor方法，并將AsyncTask所提供的默認(rèn)線程池SERIAL_EXECUTOR作為參數(shù)傳入。
2. 在executeOnExecutor方法中，會先對任務(wù)的狀態(tài)進(jìn)行判斷。AsyncTask只存在三種狀態(tài)PENDING、RUNNING、FINISHED，僅當(dāng)當(dāng)前任務(wù)狀態(tài)為PENDING時才會執(zhí)行后面的步驟，否則會拋出對應(yīng)的異常，這也印證了為什么一個AsyncTask只能被執(zhí)行一次。
3. 當(dāng)確定任務(wù)狀態(tài)為PENDING后，就將任務(wù)狀態(tài)改為RUNNING，并執(zhí)行我們之前所覆寫的方法onPreExecute()來完成一些任務(wù)開始前的準(zhǔn)備工作，隨后SERIAL_EXECUTOR就會執(zhí)行該FutureTask。
4. SERIAL_EXECUTOR是一個SerialExecutor類的靜態(tài)對象，SerialExecutor內(nèi)部維護了一個雙向任務(wù)隊列，該進(jìn)程中所有AsyncTask所執(zhí)行的任務(wù)都會暫存到該隊列中。mActive是從該隊列中所取出的任務(wù)，當(dāng)且僅當(dāng)mActive為null或者上一任務(wù)完成后才會調(diào)用scheduleNext()方法執(zhí)行下一任務(wù)，而具體任務(wù)的執(zhí)行則是交由線程池THREAD_POOL_EXECUTOR來執(zhí)行的。
5. THREAD_POOL_EXECUTOR是在AsyncTask類加載的時候就構(gòu)造好了的線程池，是真正提供工作線程來執(zhí)行任務(wù)的地方。

Tip：
該部分的難點主要在于AsyncTask內(nèi)部有兩個線程池，SerialExecutor的作用其實并不是執(zhí)行線程操作，而是維護了一個任務(wù)隊列。通過一個同步鎖的形式不斷往任務(wù)隊列中添加任務(wù)，并且在執(zhí)行完隊列頭的任務(wù)后才能再去執(zhí)行下一個任務(wù)，這就導(dǎo)致了我們在執(zhí)行多個異步任務(wù)的時候并非我們所想的是并行，而是串行。當(dāng)然如果你想進(jìn)行并行操作直接調(diào)用executeOnExecutor()方法傳入自己所構(gòu)造的線程池即可。

疑惑：
有一點我不理解的是，既然是為了提供串行執(zhí)行任務(wù)的線程池，那為什么不直接使用SingleThreadExecutor，直接把任務(wù)都丟進(jìn)SingleThreadExecutor不也是一樣的效果嗎？希望有緣看到我這篇文章的大佬能解答一下我這個疑問。

分析完execute方法，下面我們再看看cancel方法內(nèi)做了些什么

   private final AtomicBoolean mCancelled = new AtomicBoolean();

   //AsyncTask的cancel方法
   public final boolean cancel(boolean mayInterruptIfRunning) {
       mCancelled.set(true);
       return mFuture.cancel(mayInterruptIfRunning);
   }

   //FutureTask的cancel方法
   public boolean cancel(boolean mayInterruptIfRunning) {
       if (!(state == NEW &&
             U.compareAndSwapInt(this, STATE, NEW,
                 mayInterruptIfRunning ? INTERRUPTING : CANCELLED)))
           return false;
       try {    // in case call to interrupt throws exception
           if (mayInterruptIfRunning) {
               try {
                   Thread t = runner;
                   if (t != null)
                       //中斷線程
                       t.interrupt();
               } finally { // final state
                   U.putOrderedInt(this, STATE, INTERRUPTED);
               }
           }
       } finally {
           finishCompletion();
       }
       return true;
   }

AsyncTask的cancel方法接收一個boolean類型的參數(shù)mayInterruptIfRunning，從字面意思就可以推斷出這個boolean參數(shù)可能代表著是否在運行時進(jìn)行中斷。在cancel方法內(nèi)部，首先將mCancelled設(shè)置為true。mCancelled是一個AtomicBoolean類的變量，其標(biāo)識了當(dāng)前任務(wù)的狀態(tài)是否為“取消”。隨后調(diào)用了FutureTask的cancel方法，并將我們傳入boolean參數(shù)mayInterruptIfRunning也傳入其中。
在FutureTask的cancel方法中，可以看到對mayInterruptIfRunning進(jìn)行判斷，若為true，則對線程進(jìn)行中斷操作t.interrupt()。

如此，我們便了解了為什么AsyncTask的cancel方法并不能直接結(jié)束掉該任務(wù)，因為源碼中確實沒有相應(yīng)的業(yè)務(wù)代碼......（尷尬）

上面分析完了AsyncTask的構(gòu)造函數(shù)以及execute方法和cancel方法所完成的操作，最后我們分析一下AsyncTask是如何與主線程進(jìn)行交互的。

    protected final void publishProgress(Progress... values) {
        if (!isCancelled()) {
            getHandler().obtainMessage(MESSAGE_POST_PROGRESS,
                    new AsyncTaskResult<Progress>(this, values)).sendToTarget();
        }
    }

    //任務(wù)完成后會調(diào)用該方法，可回看構(gòu)造函數(shù)源碼解析部分
    private Result postResult(Result result) {
        @SuppressWarnings("unchecked")
        Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
                new AsyncTaskResult<Result>(this, result));
        message.sendToTarget();
        return result;
    }

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

    public final boolean isCancelled() {
        return mCancelled.get();
    }

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

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

上面這段代碼涵蓋了三個使用AsyncTask常見的回調(diào)方法：onCancelled、onPostExecute和onProgressUpdate。不難看出，AsyncTask與主線程間的交互還是完全依賴于Handler來實現(xiàn)的。
重點關(guān)注publishProgress和finish方法中對mCancelled的判斷，可以看出，只要當(dāng)前任務(wù)被設(shè)置成了“取消”，那么更新進(jìn)度的操作將不會執(zhí)行，并且任務(wù)結(jié)束后不會調(diào)用onPostExecute方法，而是調(diào)用onCancelled方法。

以上，基本上完成對AsyncTask源碼的完整分析。在熟悉了AsyncTask原理的基礎(chǔ)上，我們完全可以自己嘗試著使用Handler加上Excutors的組合來自己實現(xiàn)一個異步任務(wù)框架。

若您覺得本文章對您有用，請您為我點上一顆小心心以表支持。感謝！