Android AsyncTask源码简单分析

分析看的4.0的源码，3.0下会有不同，简单分析一下，记录下学习过程，从熟悉的方法开始分析，逐渐深入。

1.首先从构造方法开始分析

构造方法：

public AsyncTask() {
mWorker = new WorkerRunnable<Params, Result>() {
public Result call() throws Exception {
mTaskInvoked.set(true);
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
Result result = doInBackground(mParams);
Binder.flushPendingCommands();
return postResult(result);
}
};

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 occurred while executing doInBackground()",
e.getCause());
} catch (CancellationException e) {
postResultIfNotInvoked(null);
}
}

主要就是初始化mWorker和mFuture对象，看下这两个的定义。

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

mWorker是一个Callable对象，mFuture是FutureTask，java并发包提供的，关于这两个类的介绍看这里，这里mWorker传给了mFuture的构造方法，真正执行的是mWorker里的call方法。call方法里面的逻辑，主要是doInBackground和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就是异步任务的结果，它把这个结果是传给了getHandler()处理。

private static Handler getHandler() {
synchronized (AsyncTask.class) {
if (sHandler == null) {
sHandler = new InternalHandler();
}
return sHandler;
}
}
private static class InternalHandler extends Handler {
public InternalHandler() {
super(Looper.getMainLooper());
}
@Override
public void handleMessage(Message msg) {
AsyncTaskResult<?> result = (AsyncTaskResult<?>) msg.obj;
switch (msg.what) {
case MESSAGE_POST_RESULT:result.mTask.finish(result.mData[0]);
break;
case MESSAGE_POST_PROGRESS:
result.mTask.onProgressUpdate(result.mData);
break;
}
}
}
private static class AsyncTaskResult<Data> {
final AsyncTask mTask;
final Data[] mData;

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

这里handler调用的是result.mTask.finish(result.mData[0]) ，其实也就是AsyncTask的finish()。

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

finsh()会先判断是否是取消了，如果不是，则调用onPostExecute，否则调用onCancelled，并把状态设置为已完成。onPostExecute这个就是最后开发者需要重写的方法，任务执行完成，回调这个方法，后续处理开发者自定义。同理onCancelled也是一样。

从构造方法开始分析，已经分析完了后台任务的执行和结束的回调。

2.分析execute()方法

上面的分析已经知道任务的执行是通过mWorker和mFuture执行的，通过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) {
/×省略了异常的判断×/
mStatus = Status.RUNNING;
onPreExecute();
mWorker.mParams = params;
exec.execute(mFuture);
return this;
}

可以看到最终执行的是executeOnExecutor，先是把状态设置为running，在是调用了onPreExecute方法，现在为止，代码的执行还是在主线程中，所以在onPreExecute中我们可以做控件的初始化操作，然后把参数赋给mWorker，最后sDefaultExecutor执行execute(mFuture)。上面分析过，mFuture里就是我们后台任务的执行逻辑，sDefaultExecutor是一个线程池，看看它怎么做的。关于这里SDK3.0一下会有不同，后面再说。

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

可以看到sDefaultExecutor就是一个线程池，它的execute方法接受一个Runnable，代码里传的就是mFuture，mTasks是一个队列，储存所有的任务，mActive代表当前执行的任务，在execute方法里，首先把传参的run方法包装了一下，然后入队，第一次执行这里的时候，mActive为空，所以执行scheduleNext(),这个方法里，先出队一个任务，然后THREAD_POOL_EXECUTOR.execute(mActive);，看下THREAD_POOL_EXECUTOR。

public static final Executor THREAD_POOL_EXECUTOR
= new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,
TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);

它设置了线程池的最大数量，同时能运行的线程数等信息。它才是真正调用任务执行线程的地方。为什么这里存在两个线程池呢，第一个线程池好像没作用啊，其实第一个线程池的作用就在于它对任务的包装，在它包装的Runnable里，结尾都加了一句scheduleNext()，还是try-finally包围，也就是这句代码必须执行，也就是说当一个任务完成之后，再次调用这个方法，继续出队，继续执行下一个任务，执行完后，继续执行scheduleNext()，继续出队…….直到任务全部执行完毕，分析这个过程，可以得到结论，多个任务执行不是并行的，而是一个执行完之后再执行下一个，每个时刻只有一个任务在执行。

之前说3.0之前这里不同，3.0之前的源码我没看，但通过查资料得知，其实3.0以前没有第一个线程池，只有第二个，所以执行任务是并行的，这和前面分析的第一个线程池的作用吻合。但是这里又存在一个问题，源码里，对第二个线程池设置了最大任务的数量128，超过这个数量会报错。

那怎么在3.0之后的AsyncTask执行任务是并行的呢？只要把第一个线程池覆盖或者不调用它就好了。

1.调用setDefaultExecutor(Executor exec)方法。可以自己写一个线程池，也可以用第二个线程池，传AsyncTask.THREAD_POOL_EXECUTOR就好了

2.调用的时候不调用execute()而是调用executeOnExecutor(Executor exec,

Params… params)，第一个参数可以自定义，也可以用THREAD_POOL_EXECUTOR。

3.总结

还有一个方法，onProgressUpdate(Progress…)显示进度信息的，在上面的分析中，handler里，其实有处理，开发者调用publishProgress()方法时，其实内部就是跟handler发了个msg，然后回调onProgressUpdate，开发者自己处理。

大概流程分析的差不多了，简单分析而已。学习查看源码，很重要，从熟悉的方法，逐渐深入。路漫漫其修远兮。

参考：

http://www.cnblogs.com/dolphin0520/p/3949310.html

http://blog.csdn.net/singwhatiwanna/article/details/17596225