Android AsyncTask 完美解析 看不懂源码你就输了

源码版本：SDK 28

   
    public AsyncTask() {
        this((Looper) null);
    }
    
    public AsyncTask(@Nullable Looper callbackLooper) {
        mHandler = callbackLooper == null || callbackLooper == Looper.getMainLooper()
            ? getMainHandler()
            : new Handler(callbackLooper);
        mWorker = new WorkerRunnable() {
            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(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);
                }
            }
        };
    }

在构造函数里做了三件事，初始化Handler 的实例mHandler，WorkerRunnable 的实例mWorker 以及 FutureTask 的实例 mFuture。
mHandler：用于连接后台线程和UI 线程，做消息分发的。
mWorker：本质上是一个Callable，查看 WorkerRunnable 发现是实现的 java.util.concurrent.Callable 接口，而 Callable 是一个可以携带返回结果的任务。

    private static abstract class WorkerRunnable implements Callable {
        Params[] mParams;
    }

在mWorker 的 call() 方法中执行 doInBackground 函数来获取返回结果

而后在finally 中执行了 android.os.AsyncTask#postResult 方法，此方法是发送一个message，其中携带的数据就是doInBackground 方法返回的数据。

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

mFuture：用来处理异步请求，配合 java.util.concurrent.Callable 接口可以实现在工作线程获取返回结果。在这里 mWorker 表示的也就是 mFuture 要执行的任务。另外，还复写 java.util.concurrent.FutureTask#done 的方法，该方法在任务执行完毕时被调用，这里做了个安全校验，当没有执行task 时仍会调用 postResult 方法，执行到UI线程上。

    mFuture = new FutureTask(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 void postResultIfNotInvoked(Result result) {
        final boolean wasTaskInvoked = mTaskInvoked.get();
        if (!wasTaskInvoked) {
            postResult(result);
        }
    }

mTaskInvoked 是个原子操作（AtomicBoolean），在mWorker 的run 方法中设置为true。

    private final AtomicBoolean mTaskInvoked = new AtomicBoolean();

android.os.AsyncTask#execute(Params…) 内部会执行 android.os.AsyncTask#executeOnExecutor 方法，传入sDefaultExecutor

    @MainThread
    public final AsyncTask execute(Params... params) {
        return executeOnExecutor(sDefaultExecutor, params);
    }
    @MainThread
    public final AsyncTask 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();// 1.
        mWorker.mParams = params;
        exec.execute(mFuture);// exec 为 sDefaultExecutor
        return this;
    }

在方法内部调用了android.os.AsyncTask#onPreExecute 函数，到这里目前还是运行在UI 线程。其次执行 exec.execute(mFuture)，而入参 exec 为 sDefaultExecutor。那sDefaultExecutor 是啥呢？

    
    public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
    private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;

这里 sDefaultExecutor 指向了 SERIAL_EXECUTOR，这是一个串行的任务调度器，将进入的任务按顺序取出执行。

private static class SerialExecutor implements Executor {
    // 这是一个双端队列，符合先进先出的原则。
    final ArrayDeque mTasks = new ArrayDeque();
    // 当前执行的任务
    Runnable mActive;
    public synchronized void execute(final Runnable r) {
        // 1.把传递进去来的runnable 打包成一个新的Runnable对象，然后入队。
        mTasks.offer(new Runnable() {
            public void run() {
                try {
                    // 4.执行传入进来的runnable 任务，即 FutureTask -> WorkerRunnable -> doInBackground
                    r.run();
                } finally {
                    // 5.执行完毕后，继续执行下一个任务。
                    scheduleNext();
                }
            }
        });
        // 2.当 mActive 为 null 时，从队列中取出任务并执行
        if (mActive == null) {
            scheduleNext();
        }
    }
    protected synchronized void scheduleNext() {
        // 3.从队头取出一个任务，如果不为null，则通过线程池获取一个子线程来执行该任务
        if ((mActive = mTasks.poll()) != null) {
            THREAD_POOL_EXECUTOR.execute(mActive);
        }
    }
}

当一个新的任务（FutureTask）进来时

THREAD_POOL_EXECUTOR 指向了一个线程池的对象，当有Runnbale 任务进来时，通过 threadPoolExecutor 来开启一个新线程执行任务。注意，这里执行的任务是经过 SerialExecutor 包装过的任务，在包装的任务内首先执行的才是FutureTask 中的 WorkerRunnable。

话不多说，直接上图
emmmmmm… 算了算了 画图太浪费时间了，还是简单的做个描述吧。

android.os.AsyncTask#execute(Params…)

android.os.AsyncTask#executeOnExecutor
-> android.os.AsyncTask#onPreExecute
-> exec.execute(mFuture) 调用调度器执行任务

android.os.AsyncTask.SerialExecutor
-> 打包传递进来的Runnable，然后执行入队（offer）操作。
-> 检查当前是否有正在执行的任务，如果没有，则获取任务执行。
从队头取出一个任务，如果不为null，则通过线程池获取一个子线程来执行该任务 （AsyncTask 内包装了一个特有的线程池）。
-> 执行传入进来的runnable 任务，即 可获取返回值的task ，该任务中执行 doInBackground 方法，还有执行结果的消息分发。
-> 继续执行下一个任务，重复 3-4-5，直到任务队列中没有需要执行的任务。

FutureTask -> android.os.AsyncTask.WorkerRunnable
-> android.os.AsyncTask#doInBackground
-> android.os.AsyncTask#postResult 发送消息，通知任务完成。

InternalHandler
-> Message -> android.os.AsyncTask#MESSAGE_POST_RESULT -> android.os.AsyncTask#finish -> android.os.AsyncTask#onPostExecute
-> Message -> android.os.AsyncTask#MESSAGE_POST_PROGRESS -> android.os.AsyncTask#onProgressUpdate