Android中从源码分析关于AsyncTask的使用

Android在框架层提供了异步任务类，AysncTask，用于执行后台任务，并将执行结果更新到UI线程。为什么要用异步任务呢？这是因为如果某个任务太耗时间的话，会阻塞UI主线程，而我们知道UI线程如果阻塞5秒的话，就会发生ANR（Application No Response）错误 ，就算没有发生，主界面上看起来也会卡卡的，这显然用户体验就不太好了。

而AsyncTask类则在不影响UI线程的情况下，另起子线程去做那些耗时比较久的任务，比如我们在TodoList中去读取图片这种情况，然后将处理后的结果再更新到UI线程，从而达到更好的用户体验。

下面是AsyncTask类的定义：

public abstract class AsyncTask<Params, Progress, Result> {
private static final String LOG_TAG = "AsyncTask";
...
从上面的代码可以看出，AsyncTask是一个抽象类，所以在使用AsyncTask的时候，我们要继承它，实现一个子类，并实现其中一个方法，如下：

class LoadImageTask extends AsyncTask<String, Void, ImageView>{

@Override
protected ImageView doInBackground(String... params) {
String photoImagePath = params[0];
Bitmap bitmap = BitmapReader.readBigBitmapFromFile(photoImagePath,REQ_WIDTH);
ImageView imageView = Helper.createImageViewFromBitmap(DetailActivity.this, bitmap);
return imageView;
}

protected void onPostExecute(ImageView result) {
imageViews.add(result);
refreshGallery();
}

}
对照 AsyncTask的三个参数，Params, Progress和Result，是泛型参数。

1）Params ：参数，比如例子中定义的String类型，指向一个Image的路径，这是传给AysncTask的doInBackground方法。

2）Progress：这是在执行过程中会用到的一个参数，一般在显示进度的时候会用到，在例子中不会用到，所以可以在这里指定为Void。

3）Result：这是执行的结果对象，会作为onPostExecute方法的参数，在UI线程中处理。

由上面的例子也可以看到，一般我们实现的这个子类，要实现其中的两个方法

1）doInBackground：这个方法，其实是在另外一个线程中执行的。

2）onPostExecute：而这个方法却已经回到UI线程中来执行，所以可以在这里将上一个方法中执行所得的结果在这里更新到UI线程中。

那么这里面的机制是怎么样的呢，我们就来深入地看一下，也学习一下吧。

首先我们来看一下在Activity中，我们是怎么样来使用我们这个AsyncTask的吧，代码如下：

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data){
if (requestCode == REQUEST_FOR_CAMERA) {
if(resultCode == RESULT_OK){
isPhotoTaken = true;
photoFileNames.add(tempPhotoFileName);
}
} else if (requestCode == REQUEST_FOR_GALLERY) {
if(resultCode == RESULT_OK){
isPhotoTaken = true;
ContentResolver resolver = getContentResolver();
Uri uri = data.getData();
tempPhotoFileName = Helper.getImagePath(resolver, uri);
photoFileNames.add(tempPhotoFileName);
}
}
new LoadImageTask().execute(tempPhotoFileName);//调用其execute方法
}

在TodoList的小demo中，在相机或者图库返回来图片的路径之后，我们就会调用AsynctTask的execute方法了，那么这里就是入口了。
进入AsyncTask类中，找到execute方法，如下：

public final AsyncTask<Params, Progress, Result> execute(Params... params) {
return executeOnExecutor(sDefaultExecutor, params);
}可以看到，这里调用的是executeOnExecutor方法，我们继续找：
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;
}在这个方法中，我们可以发现，AsynctTask定义了一个mStatus的成员变量，来表示异步任务的运行状态，分别是pending，running和finished，但只有处于pending状态的AsnycTask才能被执行。当状态是Pending的时候，就会继续执行，将状态变成running，这样能够保证AsyncTask只会被执行一次。
接着会调用onPreExecute方法做一些处理工作，这个方法其实我们也可以在子类中自己实现，如果有什么需要处理的话，一般不用。

然后我们发现，我们传进来的参数params会被传给mWorker，然后会有一个executor来执行execute的方法，并且执行的参数是一个mFuture对象。那么这两个东西是什么呢？

接着看如下代码：

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

Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
//noinspection unchecked
return postResult(doInBackground(mParams));
}
};

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 occured while executing doInBackground()",
e.getCause());
} catch (CancellationException e) {
postResultIfNotInvoked(null);
}
}
};
}
mWorker是一个WorkerRunnable对象，而实际上WorkerRunnable是AsyncTask的一个抽象内部类，实现了Callable接口，如下：

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

而在上面的赋值过程，通过匿名类实现了WorkerRunnable，并其call方法中将线程优先级调整为后台线程，然后会执行 doInBackground方法，不过现在还没执行，咱们再看看FutureTask对象，下面是它的构造函数：
public FutureTask(Callable<V> callable) {
if (callable == null)
throw new NullPointerException();
sync = new Sync(callable);
}
而FutureTask是Java多线程模型的一部分，其间接地实现了Runnable（线程属性）接口和Future（异步任务）接口，而在上面的executeOnExecutor方法中，正是将mWorker（实现了Callable接口）对象传给它了，并被其封装到成员变量sync中，这样它们就共同表示了一个异步任务，到这里，一个异步任务也就创建完成了。

从上面executeOnExecutor的方法，也可以看到，真正执行execute是一个Executor，而在AsyncTask中，其实是SerialExecutor，我们看看其构造函数：

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();//在新线程中调用了我们上面传进来的FutureTask的run方法
} finally {
scheduleNext();
}
}
});
if (mActive == null) {
scheduleNext();
}
}

protected synchronized void scheduleNext() {
if ((mActive = mTasks.poll()) != null) {
THREAD_POOL_EXECUTOR.execute(mActive);
}
}
}
从上面，我们可以看到execute方法的参数就是一个Runnable，其实也就是FutrueTask了，在这里，它会被封装到一个新的线程中作为一个任务添加到mTasks队列中，至于下面如何在THREAD_POOL_EXECUTOR中去执行mTasks我们就不再深入下去了，我们就来看看FutureTask的run方法，如下：

public void run() {
sync.innerRun();
}

我们发现，它调用的是sync.innerRun()，那么Sync的innerRun方法又干了什么呢？
void innerRun() {
if (!compareAndSetState(READY, RUNNING))
return;

runner = Thread.currentThread();
if (getState() == RUNNING) { // recheck after setting thread
V result;
try {
result = callable.call();
} catch (Throwable ex) {
setException(ex);
return;
}
set(result);
} else {
releaseShared(0); // cancel
}
}我们发现，它调用了callable的call方法，啊，我们终于来到了mWorker的call方法，回过头看，不就是在那里调用了doInBackground方法的吗？所以，我们可以确定，doInBackground的确是在一个新的线程中执行的，并且是一个后台线程。
但同时我们发现，其执行完之后，是作为一个参数传递给postResult的，继续看下去：

private Result postResult(Result result) {
@SuppressWarnings("unchecked")
Message message = sHandler.obtainMessage(MESSAGE_POST_RESULT,
new AsyncTaskResult<Result>(this, result));
message.sendToTarget();
return result;
}可以看到，在这里是利用了sHandler来发送异步消息的，而sHandler是在AsynctTask中定义的，如下：
private static final InternalHandler sHandler = new InternalHandler();InternalHandler定义如下

private static class InternalHandler extends Handler {
@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;
}
}
}

我们可以在这里发现，如果是MESSAGE_POST_RESULT，则会调用mTask的finish方法，然后就结束了，而如果是MESSAGE_POST_PROGRESS，则会调用 onProgressUpdate方法，那么，很显然这个mTask应该就是我们定久的AsyncTask了吧。我们看看AsyncTaskResult是什么先，
@SuppressWarnings({"RawUseOfParameterizedType"})
private static class AsyncTaskResult<Data> {
final AsyncTask mTask;
final Data[] mData;

AsyncTaskResult(AsyncTask task, Data... data) {
mTask = task;
mData = data;
}
}
}我们发现，在上面传进来的AsyncTaskResult的参数task的正好就是this，而它又赋值给了mTask的，所以说明，这个mTask就是我们在Activity中定义的LoadImageTask了，而它是在主线程中定义的，那么很显然，它的finish方法也是在主线程，也就是UI线程中执行的了，再来看看这个finish方法：
private void finish(Result result) {
if (isCancelled()) {
onCancelled(result);
} else {
onPostExecute(result);
}
mStatus = Status.FINISHED;
}在这里，我们终于看到了onPostExecute方法的调用了，这说明了，onPostExecute就是在UI线程中干活的了。最后mStatus也被设计成FIINISHED了，这个异步任务也就结束了。

嗯，关于AsyncTask的基本原理到这里也就结束了。