深入理解AsyncTask

【原文地址 点击打开链接】

什么是AsyncTask

AsyncTask是一个轻量级的异步任务类，它可以在线程池中执行后台任务，然后把执行的进度和结果传递给主线程并在主线程中更新UI。

AsyncTask这个类的声明如下：

public abstract class AsyncTask<Params, Progress, Result>

它提供了 Params,Progress 和 Result 三个泛型参数，在下面会仔细分析这三个泛型参数的具体含义。

AsyncTask提供了四个核心方法：

• onPreExecute() 
  此方法在主线程中执行，在异步任务执行之前，此方法会被调用，一般用于一些准备工作，例如下载进度条的初始化。

  
  

• doInBackground(Params… params) 
  此方法在子线程中执行，用于执行异步任务，注意这里的params就是AsyncTask的第一个参数类型。在此方法中可以通过调用publicProgress方法来更新任务进度，publicProgress会调用 onProgressUpdate 方法。

  
  

• onProgressUpdate(Progress… values) 
  此方法在主线程中执行，values的类型就是AsyncTask传入的第二个参数类型，当后台任务的执行进度发生变化时此方法执行。

  
  

• onPostExecute(Result result) 
  此方法在主线程中执行，在 doInBackground 方法执行完成以后此方法会被调用，其中result的类型就是AsyncTask传入的第三个参数类型，它的值就是doInBackground方法的返回值。

接着还是看一下AsyncTask最常见的用法，该事例就是下载一张图片到手机内存的cache目录下，下载开始时会弹出进度框，在下载过程中显示下载的进度，下载完成后关闭进度框，如成功则出现下载成功的Toast，失败则弹出失败的Toast：

这个类主要用于模拟文件的下载过程，它输入参数为图片url地址，后台的进程参数为Integer类型，后台任务的返回结果为boolean类型。当要执行上述下载任务时，可以通过如下方式来完成：

//在主线程中调用，执行后就会执行doInBackground等方法
URL url = new URL("http://192.168.43.21:8080/ditu.jpg");
new MyAsyncTask().execute(url);

源码分析

首先我们从AsyncTask的构造方法着手：

1. 如注释所说，这个构造方法必须在UI线程中调用。

2. 构造函数主要是创建了两个实例。一个是WorkerRunnable，它是一个Callback对象。另一个是FutureTask，它的参数就是前面创建的WorkerRunnable对象。

接下来我们再看AsyncTask的execute()方法，这个方法是整个异步任务的入口：

我们看到了onPreExecute()被调用了，证明它确实是在执行后台任务之前调用了，且是在主线程调用。此时我们执行了实例代码中的进度条显示框的显示操作，此时的界面如下：

在此方法中还进行了一个操作 exec.execute(mFuture)，首先我们得知道 exec 到底是什么？在下面源码中我们就能得到答案：

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

根据如上代码以及 executeOnExecutor 传进来的参数，我们看到这里的 exec 其实就是 SerialExecutor，那我们就来看看 SerialExecutor 的execute 方法：

public synchronized void execute(final Runnable r) {
    mTasks.offer(new Runnable() {
        public void run() {
            try {
                r.run();
            } finally {
                scheduleNext();
            }
        }
    });
    if (mActive == null) {
        scheduleNext();
    }
}

我们看到在 子线程 里执行了 r.run(),根据 execute() 方法传入的参数可知这里的r就是最开始在构造方法中创建的 FutureTask，当然接下来就该看看FutureTask的run() 方法了：

这里有一个 result = c.call() 方法，而这里的 c 就是 Callable<V> c = callable;里传进来的 callable，而 callable 就是我们最开始在AsyncTask构造方法里传进来的 WorkerRunnable，所以接着就该看看 WorkerRunnable的call() 方法，这个 call() 方法主要是调用了 doInBackground(mParams) 和postResult(result) 方法：

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

1. 在这里我们看到 doInBackground(mParams) 方法的调用，并且此时仍然是在子线程中，所以在这里可以执行耗时操作。在上面的案例中 doInBackground 方法里的代码将会执行，当执行到publishProgress() 方法时，会不断将进度信息传递给 onProgressUpdate() 方法（后面的分析中会解释为什么 publishProgress() 的执行能导致 onProgressUpdate()方法的调用），让此方法执行更新UI执行到这里时，案例中的下载界面如下，此时进度正好走到50%：

2. 方法的最后执行了 postResult(result) 方法，这里面的 result参数就是我们 doInBackground(mParams) 的返回值，这个方法的主要作用就是创建一个InternalHandler 实例并发送 what=MESSAGE_POST_RESULT 的消息，我们接着看这个方法的源码：

private Result postResult(Result result) {
    @SuppressWarnings("unchecked")
    Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
                new AsyncTaskResult<Result>(this, result));
    message.sendToTarget();
    return result;
}
    
//message方法的sendToTarget()，最终还是handler发送信息个消息队列
public void sendToTarget() {
    target.sendMessage(this);
}

熟悉Handler的朋友知道，target.sendMessage(this) 方法就是将消息发送给了消息队列，而这个携带的消息就是message 本身，message 当中携带有MESSAGE_POST_RESULT 和 new AsyncTaskResult<Result>(this, result)) 对象，而这个对象由 getHandler 发送，最后也会由它来handleMessage()（对这个消息进行处理），所以我们必须找到这个 handler：

private static Handler getHandler() {
    synchronized (AsyncTask.class) {
        if (sHandler == null) {
            //在这里创建了名为sHandler的InternalHandler实例
            sHandler = new InternalHandler();
        }
        return sHandler;
    }
}

根据上面 getHandler() 方法可知这个 handler 对象就是 InternalHandler，那接下来的任务就是分析 InternalHandler的handlerMessage()方法，这个方法的作用就是根据 postResult(Result result) 方法中的 sHandler 发送的不同消息进行判断来执行不同的逻辑：

由上面源码可知，它根据 msg 携带的不同 what 信息进行不同的消息处理，当 what = MESSAGE_POST_RESULT 时，最终会执行onCancelled(result) 或者 onPostExecute(result)，这两个方法执行时全部都是在主线程，而MESSAGE_POST_RESULT 就是刚刚获取信息时传入的。执行在这里时我们下载事例的代码就走到了onPostExecute(result)，我们进行了进度框的隐藏操作，执行的界面如下：

但是 MESSAGE_POST_PROGRESS 参数又是哪里传来的，没错，就是publishProgress(Progress... values) :

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

这里传入 MESSAGE_POST_PROGRESS，并且此方法在 WorkerThread 中调用。这样 onProgressUpdate(Progress... values) 方法就能顺利执行。至此，整个流程结束。

总结

1. AsyncTask的对象只能在主线程中创建。

2. execute()方法只能在UI线程执行。

3. 不要在程序中直接调用onPreExecute,onPostExecute,doInBackground,onProgressUpdate方法。

4. 一个AsyncTask对象只能执行一次execute方法，否者会报运行时错误，在执行execute方法时，会调用到如下代码证明这个结论：

5. 在Android1.6之前，AsyncTask是串行执行任务，在1.6以后，改为在线程池里并行处理任务，在3.0以后，又改为在线程池里串行执行任务。

在AsyncTask中有两个线程池(SerialExecutor和THREAD_POOL_EXECUTOR)和一个handler(InternalHandler).其中SerialExecutor 用于任务的排队。在上面代码中，我们已经看到，在 AsyncTask.execute 的执行过程中我们会调用它的execute 方法：

我们看到首先会将 FutureTask 对象插入到队列mTask 中，如果这个时候没有正在执行的AsyncTask活动，就会调用 scheduleNext() 执行下一个任务，当一个任务执行完成后又会执行下一个，这可以看出AsyncTask默认是串行执行的。