【源碼分析】AsyncTask源碼分析

AsyncTask類在早期的開發中佔的比重很是重，由於它能夠方便的將耗時工做與UI線程鏈接在一塊兒，隨着android版本的更新、業務的複雜度增長AsyncTask的愈來愈不能知足業務的需求，好比它不能取消一個正在執行的任務。可是AsyncTask中將耗時線程和UI線程工做組合在一塊兒的思想仍是值得咱們好好學習借鑑一下的，那麼咱們就來分析一下AsyncTask這個經典類的源碼。

按照AsyncTask的功能咱們從兩個方面來分析一下源碼：耗時線程如何工做、UI線程如何工做。

耗時線程

public AsyncTask() {
        mWorker = new WorkerRunnable<Params, Result>() {
            public Result call() throws Exception {
                mTaskInvoked.set(true);

                Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
                //noinspection unchecked
                Result result = doInBackground(mParams);
                Binder.flushPendingCommands();
                return postResult(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 abstract class WorkerRunnable<Params, Result> implements Callable<Result> {
        Params[] mParams;
    }

WorkerRunnbale是個抽象類實現了Callable接口，同時添加mParams變量用來接收參數，mWorker實現了一個匿名的WorkerRunnable類，而且把全部須要處理的任務都封裝在call方法中，doInBackground方法表示咱們須要的耗時任務，postResult方法表示更新UI的操做。mFuture變量則是一個FutureTask的變量，咱們把上面定義的mWorker封裝在mFuture中，這樣就方便咱們的線程池調用。因此在構造方法中，封裝了全部的任務到一個mFuture變量中。接着往下看executor方法。

@MainThread
    public final AsyncTask<Params, Progress, Result> execute(Params... params) {
        return executeOnExecutor(sDefaultExecutor, params);
    }
    
    ...
    
    @MainThread
    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;
    }

在executor方法中，調用了executeOnExecutor方法，而且傳遞了一個Executor變量sDefaultExecutor，這個變量實際上是一個線程池變量，後面咱們介紹。在executeOnExecutor方法中首先判斷了一下當前AsyncTask的狀態，若是是RUNNING或者是FINISHED則說明當前的狀態不對，不能執行新增的任務。檢查以後，首先設置狀態爲RUNNING狀態，而後執行onPreExecute方法，因此這個方法也是在UI線程中執行的一樣不能作一些耗時操做。 緊接着用mWorker.mParams變量來接收exexutor傳遞過來的參數，最後一步就是用調用了線程池的execute方法把mFuture添加到了線程池中。終上所述，調用exexutor方法以後，會把mFuture這個咱們定義好的任務添加到sDefaultExexutor這個預先定義好的線程池中。

UI線程

調用executor方法以後，任務會在線程池中獲得執行。也就是doBackground方法會在線程池中執行，那麼在任務執行完成以後，如何調用到了UI線程呢？mWorker的call方法最後返回的是postResult(result),那麼來看看這個方法。

private Result postResult(Result result) {
        @SuppressWarnings("unchecked")
        Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
                new AsyncTaskResult<Result>(this, result));
        message.sendToTarget();
        return result;
    }
    ...
    private static Handler getHandler() {
    synchronized (AsyncTask.class) {
        if (sHandler == null) {
            sHandler = new InternalHandler();
        }
        return sHandler;
    }
}

...

在postResult方法中，首先經過getHandler方法獲取到了一個Handler對象，從getHandler中能夠看到這個Handler是一個InternalHandler的實例。獲取handler以後，經過obtainMessage方法獲取一個關聯到InternalHandler類的Message對象，而後將AsyncTask和doBackground計算的結果封裝到AsyncTaskResult中，發送給Handler處理。

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的定義中能夠看到，它在構造方法中關聯了UI線程的mainLooper，那麼這個Handler也就是在UI線程中處理事務。因此在postResult中將result結果發送給了一個關聯UI線程的Handler來處理。若是是任務完成，傳遞的message.what就是MESSAGE_POST_RESULT，它最後會調用AsyncTask的finish方法。

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

最後也就是調用到了onPostExecute這個方法上來了。

最後說說sDefaultExecutor這個線程池。其實sDefaultExecutor並非一個線程池，它只是實現了Executor接口的一個類SerialExecutor ，看源碼

public static final Executor THREAD_POOL_EXECUTOR
            = new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,
                    TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);
     ...
    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);
            }
        }
    }

調用execute方法時，會從新封裝一下runnbale，而且將封裝後的runnbale添加到阻塞隊列ArrayDeque中，同時檢查mActive是否爲空，若是爲空的話，從ArrayDeque中取出一個runnable，放到線程池THREAD_POOL_EXECUTOR中執行這個runnable。