android_AsyncTask的源码解析

AsyncTask的相关结论

下面是AsyncTask的相关结论,相关结论都会在下面的源码分析中一一印证。

  1. onPreExecute()是在异步任务执行之前调用的,它是在主线程中运行。
  2. doInBackground()是在子线程中运行,该方法执行的耗时的异步任务。
  3. onPostExecute(Result result)是执行完doInBackground之后被调用,参数result就是doInBackground计算的结果。
  4. 1,2,3以上3个方法不用手动调用,它们的调用都是AsyncTask自己去调用的。
  5. onProgressUpdate(Progress...values)在UI线程中执行,用于时时的更新UI,以进度条的方式,增加用户体验。
  6. protected final void publishProgress(Progress... values) 该方法一般会在doInBackground中执行,将计算的数据时时通过该方法传递给onProgressUpdate方法。该方法是final类型的。
  7. 异步任务就是能执行耗时耗时操作,并且将操作结果通知到UI线程中,完成此操作就需要使用到Handler消息机制,在AsyncTask中是通过InternalHandler去实现的。
  8. AsyncTask通过线程池去维护多个异步任务的创建和运行。
  9. AsyncTask实例需要在主线程中去实例化,因为postExecute是AsyncTask的方法,AsyncTask若是在子线程中运行,那么该方法也是在非UI线程调用,那么达不到刷新UI的效果了。
  10. AsyncTask#execute()需要在主线程调用,若在子线程中调用,那么在onPreExecute就会在子线程中运行,那么操作UI相关的操作就会出问题。
  11. AsyncTask异步任务不可以被执行多次,每一个异步任务都会有一个状态标记,分别为PENDDING,RUNING,FINISH,只要状态不是为PENDING都会抛出异常。
  12. AsyncTask#cancel(boolean)设置取消异步任务,设置之后会调用onCancelled()通知用户。
  13. AsyncTask#onCancelled()在finish()中判断当前状态是否为取消状态,取消状态的话则调用onCancelled(Result)方法。
  14. AsyncTask默认是串行执行的,需要并行执行异步任务的话则需要在executeOnExecutor方法传递一个Executor就可以实现并行执行。

1. AsyncTask构造方法

实例化对象中,实例化了mWorker,mFuture对象,具体实现待会具体分析。

public AsyncTask() {
    mWorker = new WorkerRunnable<Params, Result>() {
    public Result call() throws Exception{
            ...
        }
    };
    mFuture = new FutureTask<Result>(mWorker) {
    @Override
    protected void done() {
            ...
        }
    };
}

2.WorkerRunnable&FutureTask

从类的定义可以知道mWorker是Callable的子类对象,mFuture是Runnabel的子类对象。

private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {
    Params[] mParams;
}

public interface RunnableFuture<V> extends Runnable, Future<V> {}
public class FutureTask<V> implements RunnableFuture<V> {}

3.AsyncTask#execute(Params... params)

有了AsyncTask实例之后,怎样去开始执行一个异步任务?可以通过execute方法开启一个异步任务。有一个疑问?params是什么?我们看源码得出去找params用来干嘛。execute会通过executeOnExecutor(Executor exec,Params... params) 去执行任务。

@MainThread
public final AsyncTask<Params, Progress, Result> execute(Params... params) {
    return executeOnExecutor(sDefaultExecutor, params);
}

4.AsyncTask#executeOnExecutor(Executor exec,Params... params)

从源码中可知道execute传递的params原来是会被赋值给mWorker.params,具体什么作用,我们先不分析,待会用到再说。现在我们看到一个熟悉的方法,那就是onPreExecute(),这证实了AsyncTask的第(1)条结论,那就是onPreExecute()是在主线程中运行(前提:AsyncTask是在主线程创建的),然后是在异步任务执行之前调用,通常用于准备工作。

@MainThread
public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,Params... params) {
    ...
    onPreExecute();//异步执行之前调用。
    mWorker.mParams = params;
    exec.execute(mFuture);//将任务放到线程池的,开始异步任务。
    return this;
}

疑问1:exec是什么?

它是一个线程池,从传入的参数sDefaultExecutor可以看出,它是一个默认的线程池,内部维护一个ArrayDeQue队列。AsyncTask里默认维护了一个静态的线程池,不管有多少个AsyncTask调用execute方法都会去共享这个静态的线程池,该线程池只允许一次运行一个任务,多余的任务需要等待,这印证了第(8)点结论。SerialExecutor内部只是维护了一个队列,真正执行任务还是THREAD_POOL_EXECUTOR 去执行。代码如下:

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>();//内部维护一个队列

    public synchronized void execute(final Runnable r) {
        ...
        //真正执行任务还是THREAD_POOL_EXECUTOR 去执行,代码暂时不贴。
    }
     ...
}

疑问2:怎么体现异步任务在子线程执行?

答案就在SerialExecutor#execute怎么去执行Runnbale的?mTasks.offer将一个Runnabel添加到mTask中,这样做的目的就是按顺序地去执行任务,具体的实现就在scheduleNext()中。现在所处就是在子线程中了

 private static class SerialExecutor implements Executor {
    final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();//不支持并发访问,是一个Collection数据结构,不安全
        Runnable mActive;

     public synchronized void execute(final Runnable r) {
         mTasks.offer(new Runnable() {//插入一个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);
         }
     }
}

5.FuturnTask#run()

execute方法的最终会调用Runnable中run方法被执行,也就是说mFuture#run会被执行,接下来看看run怎么实现的

public void run() {
    Callable<V> c = callable;//就是 mWorker 对象
    ...
    V result;
    result = c.call();//开始计算
    ...
    if (ran)
        set(result);
}
           

疑问1:callable是什么?

callable实际上就是在AsyncTask构造中传递给mFuture的构造参数(mWorker对象)

public FutureTask(Callable<V> callable) {
   if (callable   null)
       throw new NullPointerException();
   this.callable = callable;
   this.state = NEW;       // ensure visibility of callable
}

疑问2:result又是什么?

分析:result = c.call()将子线程中运行的结果赋值给result。result的类型就是Callable<V>的泛型类型。在mFuture初始化的时候已经被指定Result类型,也就是在AscnycTask异步任务执行结果返回值类型。接下来看看call怎么去计算异步结果的。

6.计算异步结果WorkerRunnable#call()

标记postResult方法调用的标记,这句话的作用现暂时放着,待会再解释。这时候我们又看到熟悉的身影了(doInBackground),这段代码实在子线程中执行的,也就印证了第(2)条结论。将返回结果传递给postResult,接下来看看postResult的实现

public Result call() throws Exception {
    mTaskInvoked.set(true);//标记postResult为被调用
    Result result = doInBackground(mParams);
    return postResult(result);
};

7.AsyncTask#postResult

大家看到这里相信应该都有点眉目了,刚才call方法是在子线程中运行的,现在出现的Message和Handler的身影,那么100%就将异步结果放到主线程中去。我们看看怎么实现:

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

8.InternalHandler消息机制实现消息的放松

既然需要更新UI,那么就需要将消息发送到主线程中去,那么就得拿到主线程中的Looper轮训器,在InternalHandler中的构造可以看到,获取到的Looper是主线程中的。
在这里可以看到两个case:MESSAGE_POST_RESULT是在postResult中调用,MESSAGE_POST_PROGRESS是在publishProgress中调用的
然后在onProgressUpdate中去调用,该方法是在需要子类去实现处理的,在该方法中将数据回调在主线程去。 印证了第(7)点结论

public InternalHandler() {
    super(Looper.getMainLooper());
}

@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);//印证第(5)结论
        break;
        }
    }
}

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

9.AsyncTask#finish(Result result)

在该方法中我又看到一个熟悉的身影那就是onPostExecute,由于finish是在handleMessage中调用的,所以它也是在主线程中调用,并且有Result结果,可以更新UI。 这里就印证了第(3)条结论 。

private void finish(Result result) {
    if (isCancelled()) {//判断是否取消
        onCancelled(result);
    } else {//没有取消
        onPostExecute(result);//将结果传递给该方法,主线程更新UI
    }
    mStatus = Status.FINISHED;//更新标记为完成
}

10.FuturnTask#set(result)

在call方法将结果计算之后,就需要将该结果保存起来,set方法就是做这件事的,在set中将result结果赋值给outcome,并且调用FutureTask#done(),看到这里我们会有点印象,那就是在 AsyncTask构造中实例化mFuture时重写了done()方法,这个方法就是在这里回调的 。下面我们看看done做了什么事?

protected void set(V v) {
    if (U.compareAndSwapInt(this, STATE, NEW, COMPLETING)) {
        //将计算的结果保存到 outcome 中。
        outcome = v;
        U.putOrderedInt(this, STATE, NORMAL); // final state
        finishCompletion();
    }
}

11.FutureTask#done()

该方法由子类去实现,当异步任务执行完毕之后会调用。该方法被调用表示Callable#call()方法的计算结果已经被保存在outcome中了,在需要的地方取出即可。done()除了在finishCompletion()中调用外,还有innerCancel(boolean)中调用,这个接下来再分析。

mFuture = new FutureTask<Result>(mWorker) {
@Override
protected void done() {
    ...
    postResultIfNotInvoked(get());
    ...
};

get()是什么?可以源码直到,它实质上返回就是我们刚才说的call方法计算返回的值(outcome)。该值传递给postResultIfNotInvoked(Result result)又做了什么事呢?

12.postResultIfNotInvoked(Result result)

当看到这个wasTaskInvoked这个值的时候,我们应该有一丢丢印象,那就是在call方法执行的该标记被置为true了。这时候被取出来也是为true,那么接下来的代码就没执行了。现在有一个疑问,if条件在什么情况会成立呢?请看异步任务取消的代码就直到了。

private void postResultIfNotInvoked(Result result) {
    final boolean wasTaskInvoked = mTaskInvoked.get();
    if (!wasTaskInvoked) {//wasTaskInvoked这个标记唯一被赋值的地方就是call方法,标记为true表示postResult被调用,那么就不要再调用postResultIfNotInvoked方法了,除非cancel了该任务,导致在call方法没有对该标记赋值,所以该方法就会被调用。
        postResult(result);
    }
}

13.AsyncTask#postResult()

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

14.取消异步任务AsyncTask#cancel(boolean)

将取消标记为true,并且调用mFuture#cancel取消任务。

public final boolean cancel(boolean mayInterruptIfRunning) {
    mCancelled.set(true);
    return mFuture.cancel(mayInterruptIfRunning);
}

15.FutureTask#cance(boolean)

在该方法中也执行了done()方法,该方法在AsyncTask构造中已经可以看到,直接回到先前的代码查阅,它会去调用postResultIfNotInvoked(Result),这就解释了为什么这个方法的命名,当异步任务没有执行完毕,它是不会去执行设置mTaskInvoked.set(true)的,因此该方法就可以顺利成章的执行了。代码最终会去执行postResult。

boolean innerCancel(boolean mayInterruptIfRunning) {
    ...
    done();
    return true;
}

推荐阅读更多精彩内容