Android AsyncTask源码解析

AsyncTask是平时我们用于异步线程修改UI的一个类，我们需要继承这个抽象类，添加自己的实现

这个类本质上缩减我处理子线程和UI线程的交互过程，隐藏了handler。这里值得一提，我们所见到的，几乎所有异步线程更新UI，本质都是使用了hanlder和主线程进行信息交互，而大多数工具类只是对这个过程进行了封装。

为了更加好地理解AsyncTask，本篇文章对AsyncTask的源码进行解析说明，希望能给大家带来帮助。

我们知道AsyncTask使用时要先new出一个对象了，所以我们从其构造方法开始看起

/**
* Creates a new asynchronous task. This constructor must be invoked on the UI thread.
*/
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，它实现了Callable接口
private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {
Params[] mParams;
}一个是mFuture，它继承了FutureTask抽象类(匿名内部类的本质就是继承)，然后将mWworker当成参数传了进去

对于这两个接口和类可能不熟悉JAVA多线程的朋友不怎么熟悉，其实这个两类的对应者，分别是Runnable接口和Thread类，我们可以将两者进行对比
两者都是用于执行异步线程的，不同的是Callbale接口和FutureTask类在异步结束以后，会有一个返回值

我们一般使用Runnable接口和Thread类来创建的异步线程，是没有返回值的。

OK，暂时我们只需要了解我们创建了这个两个对象，至于他们具体做了什么，我们先不管。

接下来，我看AsyncTask的execute()方法

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;
}
首先是调用了onPreExecute()，这里还是在主线程中执行的

我们注意到，这里讲params，也就是execute()方法的参数，赋给了mWorker，这样mWorker就持有这些参数了，还记得吗？它是一个Callable，如果理解不来，我们也可以把它当做是runnable对象(其实FutureTask类才是继承了runnable接口，而callbale没有)
然后就是调用了exec.execute(mFuture)，mFuture也是在构造方法中新建的对象

但是我们先来了解exec整个参数，追溯上文，我们知道它是sDefaultExecutor，应该是AasyncTask的一个私有属性，我们看看

public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;OK，显然我们还要看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();
} finally {
scheduleNext();
}
}
});
if (mActive == null) {
scheduleNext();
}
}

protected synchronized void scheduleNext() {
if ((mActive = mTasks.poll()) != null) {
THREAD_POOL_EXECUTOR.execute(mActive);
}
}
}这个类中有一个队列mTasks用于存储Runnable对象，然后有一个execute()方法，这个方法新建一个runnable对象，将这个对象添加入队列
还有一个scheduleNext()方法，可以从队列中取出一个runnable，交给THREAD_POOL_EXECUTOR，这是一个线程池，也就是异步线程真正开始执行的地方

我们注意到SerialExecutor是一个静态类，也就是所有AsyncTask共用的，在一个run()方法执行完毕以后，就会调用scheduleNext()去执行下一个AsyncTask

那么归根结底，就是调用了mFuture的run()方法了，而这个run()方法，会调用mWorker类的call()方法（不要问我怎么知道的，本质就是这样，这是java并发的内容）

我们来看call()方法

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));
}
};第一行是原子类，设置为true表明这个线程正在执行，防止一个asynctask被执行两次
然后就是调用我们熟悉的doInBackground()方法啦，并且将execute()方法传入的参数传了进入

那么我们来看postResult()做了什么

private Result postResult(Result result) {
@SuppressWarnings("unchecked")
Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
new AsyncTaskResult<Result>(this, result));
message.sendToTarget();
return result;
}其实就是将执行的result，通过handler传递到主线程中，并且这里对result做了一个封装，成了AsyncTaskResult
private static class AsyncTaskResult<Data> {
final AsyncTask mTask;
final Data[] mData;

AsyncTaskResult(AsyncTask task, Data... data) {
mTask = task;
mData = data;
}
}

也就是持有AsyncTask对象本身，和doInbackGound()返回的结果
我们可以看看是怎么获得主线程的handler的

private static Handler getHandler() {
synchronized (AsyncTask.class) {
if (sHandler == null) {
sHandler = new InternalHandler();
}
return sHandler;
}
}

也就是new InternalHandler()方法
private static class InternalHandler extends Handler {
public InternalHandler() {
super(Looper.getMainLooper());
}

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

很好，这里是我们熟悉的代码了，继承handler，然后重写handleMessage()方法
在这个方法中，有两个状态，对于MESSAFE_POST_RESULT,调用了asyncTask的finish()方法

private void finish(Result result) {
if (isCancelled()) {
onCancelled(result);
} else {
onPostExecute(result);
}
mStatus = Status.FINISHED;
}也就是调用了onPostExecute()方法，所以这个方法是在主线程中执行的

直到这里为止，一个asynctask就执行结束了

可是我们好像忘了什么，我要更新进度怎么办呢？在asycntask中，要更新进度，就必须在doInBackground()方法中主动调用publishProgress()方法

另外我们还注意到，刚才handlerMessage()方法中，还有一种情况是MESSGAE_POST_PREOGREE

protected final void publishProgress(Progress... values) {
if (!isCancelled()) {
getHandler().obtainMessage(MESSAGE_POST_PROGRESS,
new AsyncTaskResult<Progress>(this, values)).sendToTarget();
}
}所以本质也是讲信息交给handler去处理，切换到主线程，然后就会调用onProgressUpdate()，我们就可以在这里更新进度了