AsyncTask 解析

概述

AsyncTask 是一个轻量级的异步任务类，它可以在线程池中执行后台任务，然后把执行的进度和最终结果传递到主线程并在主线程中更新 UI 。从实现的角度来看呢， AsyncTask 对线程池和 Handler 进行了很好的封装。

基本使用

• 创建一个继承 AsyncTask<Params, Progress, Result> 的子类。

  • 其中三个泛型参数的意义为， Params 表示执行后台任务方法的参数类型， Progress 表示更新后台任务进度方法的参数类型。Result 表示后台任务的返回结果类型。如果不需要指定类型参数则传入 void 就好。

• AsyncTask 类对外提供了关键的四个核心方法：

  • onPreExecute(): 此方法在后台任务之前调用，可以用此方法做一些准备方法。
  • doInBackground(Params... params): 此方法在线程池中执行，用于执行异步耗时任务。可在此方法中调用 publishProgress() 方法来通知主线程更新UI或者任务进度。需要注意的就是此方法执行完毕，需返回一个结果给 onPostExecute() 方法。
  • onProgressUpdate(Progress.. values):在主线程中执行，用于更新UI或者根据任务进度做些事。
  • onPostExecute(): 此方法用于执行后台任务结束时返回的结果的处理，在主线程中调用。

AsyncTask 结构分析

我们首先从 AsyncTask 的入口开始分析。从 execute() 方法开始，然后呢此方法又调用了 executeOnExecutor() 方法，实现如下：

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

从上面的代码中可以看出，AsyncTask 最终把参数传递给 mWorker ，mFuture 是 FutureTask 类为一个并发类。在这里充当了 Runnable 的作用，而这个类的 run() 方法最终会调用到 mWorker 的 call() 方法。AsyncTask 的 onPreExecute 方法会最先执行，然后再调用线程池执行后台任务，mFuture 最终会交于线程池来执行。线程池的执行过程分析如下：

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

从源码可以看出 SerialExecutor 类其实主要作用用于将任务插入 mTasks 队列中，如果没有正在运行的任务，则调用 THREAD_POOL_EXECUTOR 线程池来做事。一般情况下 AsyncTask 默认串行执行任务。
在 AsyncTask 中 有两个线程池(SerialExecutor 和 THREAD_POOL_EXECUTOR)和一个 Handler (InternalHandler)。SerialExecutor 线程池用于任务的排队， THREAD_POOL_EXECUTOR 线程池用于正真执行任务。InternalHandler 用于从线程池环境切换主线程。

这里再来看下 WorkerRunnable 类的定义，源码如下：

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

    .....
}

以匿名内部类的形式定义，在 mWorker 的 call() 方法中，首先将 mTaskInvoked 设为 true ，表示任务已经调用。然后将对象的 mParams 传入 AsyncTask 的 doInBackground() 中开始执行任务，接着获取执行结果再调用 postResult(result), postResult() 方法实现如下：

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

从 postResult() 的代码中可以看出，此方法通过 AsyncTask 类的 Handler 发送一个 MESSAGE_POST_RESULT的消息，那么接下来应该看的就是 AsyncTask 类中的 Handler 类的 HandleMessage() 方法的实现了，代码如下：

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

    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 类 在构造函数中就与主线程的 looper 绑定了，从 handleMessage() 中可以看出当收到 MESSAGE_POST_RESULT 时会继续调用 AsyncTask 类的 finish() 方法。然后我们再来看看 finish() 方法的代码：

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

finish() 方法的逻辑比较简单，首先判断 AsyncTask 的任务是否已经被取消，如取消则调用 onCancelled() , 没取消调用 onPostExecute() 来进行后台任务执行完毕的收尾工作。publishProgress() 更新进度的逻辑同上。至此呢 AsyncTask 的流程就基本分析完毕了。