AsyncTask深度剖析

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

AsyncTask基本使用

AsyncTask是一個抽象類，通常需要我們自己實現(xiàn)一個類來繼承AsyncTask考润，并在對應的回調函數中編寫響應的操作辉哥。

AsyncTask工作流程圖.png

泛型類

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

Params
指代啟動該任務所需參數的類型，如String類可用于描述下載地址的url螺戳。
Progress
指代任務執(zhí)行進度的數值類型，主要用于進度更新折汞。
Result
指代任務執(zhí)行完后返回的結果的類型倔幼。

回調方法

AsyncTask常用的回調函數有以下五個：

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

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

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

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

    // 運行在UI線程膏燃，非必須方法
    // 任務正常結束后回調此方法
    @Override
    protected void onPostExecute(Boolean aBoolean) {
        
    }

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

    }

}

以上五個回調方法蹄梢，只有doInBackground方法是在工作線程中執(zhí)行的疙筹，其余四個全部工作在主線程中，即代表我們可以在這四個回調方法內對UI進行操作禁炒。

控制方法

上述偽代碼中而咆，在doInBackground方法內我們還調用到了兩個方法publishProgress和cancel。這倆方法都是AsyncTask內置的final方法幕袱，用來輔助我們對正在執(zhí)行的任務進行控制管理暴备。

publishProgress：主動調用此方法能引起onProgressUpdate方法被回調，以實現(xiàn)進度更新的效果们豌。傳入的參數類型為AsyncTask指定的第二種泛型類<Progress>涯捻。
cancel：主動調用此方法能使得正在被執(zhí)行的任務被標識為“取消”，以使得
onProgressUpdate和onPostExecute方法在后續(xù)過程中無法被回調望迎，轉而使得任務結束后會回調onCancelled方法障癌。該方法接收一個boolean類型的參數，表示是否對工作線程進行一次中斷辩尊。

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

使用

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

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

AsyncTask源碼解析

下面以 AsyncTask的構造函數為起點呀伙，逐步分析AsyncTask內部的工作原理补履。

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

    public AsyncTask(@Nullable Looper callbackLooper) {
    //由于傳入的Looper為null，所以此處會調用getMainHandler()方法來構造一個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
                    //關鍵＝肆怼ｓ锎浮１嵬堋！Ｑ柙堋阳准！
                    //在worker中調用doInBackground(mParams)開始執(zhí)行任務
                    result = doInBackground(mParams);
                    Binder.flushPendingCommands();
                } catch (Throwable tr) {
                    mCancelled.set(true);
                    throw tr;
                } finally {
                    //任務結束，發(fā)送結果
                    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) {
                //關鍵Ａ蟪簟Ｒ坝！＠ㄈ濉Ｈ粕颉！帮寻！
                //該Handler傳入的是主線程的Looper
                sHandler = new InternalHandler(Looper.getMainLooper());
            }
            return sHandler;
        }
    }

    //通過Handler來發(fā)送結果
    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;
    }

大部分注釋已添加到代碼中乍狐，這里還是簡要描述一下：
①調用AsyncTask無參的構造函數，會導致傳遞至有參構造函數的Looper為null固逗，程序便會執(zhí)行getMainHandler()方法浅蚪，該方法用于實例化一個工作于主線程上的Handler。
②隨后構造一個worker烫罩，該worker即是我們要在子線程中所執(zhí)行的任務惜傲，在該worker中可以看到我們繼承AsyncTask時所覆寫的doInBackground(mParams)方法被調用。構造好的worker被封裝到FutureTask中贝攒，以待后面交由線程池執(zhí)行操漠。
③當worker中的任務執(zhí)行完畢后會執(zhí)行finally{}中的postResult(result)方法，該方法通過第一步中所構造的Handler來傳遞任務執(zhí)行完后的結果饿这。

上面分析了AsyncTask構造函數所執(zhí)行的一系列操作浊伙，無非就是對任務的封裝以及相關輔助工具(如Handler)初始化的工作。下面開始走進execute()的源碼來分析任務具體執(zhí)行的原理长捧。

    public static final Executor SERIAL_EXECUTOR = new SerialExecutor();

    private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;

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

    //任務執(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) {
        //此處傳入的默認的線程池即是SERIAL_EXECUTOR
        return executeOnExecutor(sDefaultExecutor, params);
    }

    public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,
            Params... params) {
        if (mStatus != Status.PENDING) {
            //關鍵Ｏ伞！４帷Ｑ谱印！肌割！
            //此處對當前AsyncTask所處狀態(tài)進行判斷卧蜓，不管是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)");
            }
        }

        //將任務狀態(tài)由PENDING改為RUNNING
        mStatus = Status.RUNNING;
        //執(zhí)行預備操作
        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í)行任務的能力，
        //它的excute方法主要是為了將FutureTask放入Dequeue中把敞，
        public synchronized void execute(final Runnable r) {
            mTasks.offer(new Runnable() {
                public void run() {
                    try {
                        r.run();
                    } finally {
                        //上一個FutureTask執(zhí)行完弥奸，才調度執(zhí)行下一個FutureTask，保證任務串行執(zhí)行
                        scheduleNext();
                    }
                }
            });
            if (mActive == null) {
                scheduleNext();
            }
        }

        protected synchronized void scheduleNext() {
            if ((mActive = mTasks.poll()) != null) {
                //關鍵７茉纭ＪⅥＴ取！７哒ā期揪！
                //FutureTask真正的運行起來
                THREAD_POOL_EXECUTOR.execute(mActive);
            }
        }
    }

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

首先，execute方法會去調用executeOnExecutor方法规个，并將AsyncTask所提供的默認線程池SERIAL_EXECUTOR作為參數傳入凤薛。
在executeOnExecutor方法中，會先對任務的狀態(tài)進行判斷诞仓。AsyncTask只存在三種狀態(tài)PENDING枉侧、RUNNING、FINISHED狂芋，僅當當前任務狀態(tài)為PENDING時才會執(zhí)行后面的步驟榨馁，否則會拋出對應的異常，這也印證了為什么一個AsyncTask只能被執(zhí)行一次帜矾。
當確定任務狀態(tài)為PENDING后翼虫，就將任務狀態(tài)改為RUNNING，并執(zhí)行我們之前所覆寫的方法onPreExecute()來完成一些任務開始前的準備工作屡萤，隨后SERIAL_EXECUTOR就會執(zhí)行該FutureTask珍剑。
SERIAL_EXECUTOR是一個SerialExecutor類的靜態(tài)對象，SerialExecutor內部維護了一個雙向任務隊列死陆，該進程中所有AsyncTask所執(zhí)行的任務都會暫存到該隊列中招拙。mActive是從該隊列中所取出的任務，當且僅當mActive為null或者上一任務完成后才會調用scheduleNext()方法執(zhí)行下一任務措译，而具體任務的執(zhí)行則是交由線程池THREAD_POOL_EXECUTOR來執(zhí)行的别凤。
THREAD_POOL_EXECUTOR是在AsyncTask類加載的時候就構造好了的線程池，是真正提供工作線程來執(zhí)行任務的地方领虹。

Tip：
該部分的難點主要在于AsyncTask內部有兩個線程池规哪，SerialExecutor的作用其實并不是執(zhí)行線程操作，而是維護了一個任務隊列塌衰。通過一個同步鎖的形式不斷往任務隊列中添加任務诉稍，并且在執(zhí)行完隊列頭的任務后才能再去執(zhí)行下一個任務，這就導致了我們在執(zhí)行多個異步任務的時候并非我們所想的是并行最疆，而是串行杯巨。當然如果你想進行并行操作直接調用executeOnExecutor()方法傳入自己所構造的線程池即可。

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

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

   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類型的參數mayInterruptIfRunning烙荷，從字面意思就可以推斷出這個boolean參數可能代表著是否在運行時進行中斷镜会。在cancel方法內部，首先將mCancelled設置為true终抽。mCancelled是一個AtomicBoolean類的變量戳表，其標識了當前任務的狀態(tài)是否為“取消”。隨后調用了FutureTask的cancel方法昼伴，并將我們傳入boolean參數mayInterruptIfRunning也傳入其中匾旭。
在FutureTask的cancel方法中，可以看到對mayInterruptIfRunning進行判斷圃郊，若為true价涝，則對線程進行中斷操作t.interrupt()。

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

上面分析完了AsyncTask的構造函數以及execute方法和cancel方法所完成的操作，最后我們分析一下AsyncTask是如何與主線程進行交互的逸寓。

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

    //任務完成后會調用該方法居兆，可回看構造函數源碼解析部分
    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常見的回調方法：onCancelled、onPostExecute和onProgressUpdate竹伸。不難看出泥栖，AsyncTask與主線程間的交互還是完全依賴于Handler來實現(xiàn)的。
重點關注publishProgress和finish方法中對mCancelled的判斷勋篓，可以看出吧享，只要當前任務被設置成了“取消”，那么更新進度的操作將不會執(zhí)行譬嚣，并且任務結束后不會調用onPostExecute方法耙蔑，而是調用onCancelled方法。

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

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