转载请注明出处：http://www.jianshu.com/p/531657db36f4
上一篇主要说了下AsyncTask的基本用法和注意事项。这篇主要从源码的角度研究下AsyncTask的原理。
先说下AsyncTask类中表示状态的一个枚举类，代码如下：
public enum Status {
PENDING,
RUNNING,
FINISHED,
}
PENDING 表示尚未执行任务。
RUNNING 表示任务正在运行。
FINISHED 表示任务结束。
AsyncTask中有一个Status类型变量mStatus，初始值为PENDING。
接着分析任务的执行方法，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;
}
第6行：首先判断mStatus 的值，如果为PENDING则向下运行，设置mStatus为RUNNING；否则抛出异常。也就是说每个异步任务只能执行一次，多次运行会抛出异常。
第18行：调用onPreExecute()函数。这是在UI线程中。
第19行：将参数赋值给mWorker.mParams。
第20行： exec.execute(mFuture)。
这里的mWorker、exec（sDefaultExecutor）、mFuture看的比较模糊。我们看一下AsyncTask构造函数
public AsyncTask() {
mWorker = new WorkerRunnable<Params, Result>() {
public Result call() throws Exception {
mTaskInvoked.set(true);
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
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代码如下：
private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {
Params[] mParams;
}
WorkerRunnable类是AsyncTask内部的一个抽象类，它实现了Callable<Result>接口，其中参数mParams用来保存传入的参数。mWorker实现了Callable<Result>中的call()方法。Callable类似于Runnable的接口，实现Callable接口和Runnable都是可被其他线程执行的任务。
Callable定义的方法是call，Runnalbe定义的是run。
mWorker 的call方法中设置线程优先级为后台级别。然后调用AsyncTask的doInBackground方法（在子线程中）。
mFuture是FutureTask的实例（java.util.concurrent.FutureTask）,FutureTask是一个可以中途取消的异步计算类。mFuture实例中，将会调用mWorker做任务，完成后会调用其done方法。
exec是由函数execute(Params...）传过来的参数sDefaultExecutor。sDefaultExecutor的初始化如下：
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 是SerialExecutor的实例，SerialExecutor实现了Executor接口，该类中有一个任务队列，任务执行execute，然后 exec.execute(mFuture)会调用到SerialExecutor的execute方法。
第9行 将任务添加到任务队列中。
第14行 该任务执行完后，调用scheduleNext，执行下一个任务。
第18行 判断mActive 是否为null，为空则调用scheduleNext。这表示任务是一个一个执行（串行）。
scheduleNext函数从任务队列取出首任务，如果不为null，则传入THREAD_POOL_EXECUTOR执行该任务。
多个任务依次调用execute方法。第一个任务入队，mActive 为null，执行scheduleNext，从队列中取出第一个任务，交给线程池去执行。第二个任务入队，mActive此时不为空，所以先不执行该任务。之后的各个任务也都添加到队列中，不会串行执行。前面的任务执行完后，会执行Runnable中的finally代码块中的scheduleNext函数，然后从队列中取出任务，交给线程池执行。
接着看THREAD_POOL_EXECUTOR：
private static final int CORE_POOL_SIZE = 5;
private static final int MAXIMUM_POOL_SIZE = 128;
private static final int KEEP_ALIVE = 1;
//线程工厂
private static final ThreadFactory sThreadFactory = new ThreadFactory() {
private final AtomicInteger mCount = new AtomicInteger(1);
public Thread newThread(Runnable r) {
return new Thread(r, "AsyncTask #" + mCount.getAndIncrement());
}
};
//队列 存放线程。
private static final BlockingQueue<Runnable> sPoolWorkQueue =
new LinkedBlockingQueue<Runnable>(10);
public static final Executor THREAD_POOL_EXECUTOR
= new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,
TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);
THREAD_POOL_EXECUTOR是新建的一个线程池执行器，用于管理线程的执行。
接着看mFuture。
mFuture的done()方法中，如果任务顺利完成，则调用postResultIfNotInvoked(get())，get()方法用来获取执行任务的结果；如果捕捉到CancellationException则调用postResultIfNotInvoked(null)。
接着看postResultIfNotInvoked
private void postResultIfNotInvoked(Result result) {
final boolean wasTaskInvoked = mTaskInvoked.get();
if (!wasTaskInvoked) {
postResult(result);
}
}
private Result postResult(Result result) {
Message message = sHandler.obtainMessage(MESSAGE_POST_RESULT,
new AsyncTaskResult<Result>(this, result));
message.sendToTarget();
return result;
}
postResultIfNotInvoked函数调用postResult函数。
第10行 创建AsyncTaskResult对象，保存异步任务的结果及对应的任务。
第11行 将message发送给Handler进行处理。
看下Handler的代码：
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:
result.mTask.finish(result.mData[0]);
break;
case MESSAGE_POST_PROGRESS:
result.mTask.onProgressUpdate(result.mData);
break;
}
}
}
接收到MESSAGE_POST_RESULT消息，调用AsyncTask的finish方法。
private void finish(Result result) {
if (isCancelled()) {
onCancelled(result);
} else {
onPostExecute(result);
}
mStatus = Status.FINISHED;
}
第2行，判断任务是否取消，如果取消则回调onCancelled(Result)方法。否则调用onPostExecute(Result)方法。
第7行，将任务状态设置为FINISHED。
publishProgress
protected final void publishProgress(Progress... values) {
if (!isCancelled()) {
sHandler.obtainMessage(MESSAGE_POST_PROGRESS,
new AsyncTaskResult<Progress>(this, values)).sendToTarget();
}
}
通过调用publishProgress来更新任务进度。该方法中先判断任务是否取消，如果取消则不在处理。否则向Handler发送消息。
Handler接收到MESSAGE_POST_PROGRESS消息后，调用AsyncTask的onProgressUpdate()方法，更新进度。
到此AsyncTask就说的差不多了。AsyncTask是对线程池、Handler的良好封装，是我们使用更加简单方便。但是AsyncTask使用也有一定的缺陷，长时间的任务不建议使用AsyncTask。
欢迎大家关注、评论、点赞。
你们的支持是我坚持的动力。
欢迎关注我的微信公众号
网友评论