在我学习 AsyncTask 原理之前，我觉得 Retrofit+Rxjava 已经挺好用的了，就没有必要去用或者了解 AsyncTask 了。说真的我已经几百年没有用过 AsyncTask 了。但是我觉得存在即是合理的。那么下面说说为什么：
- AsyncTask 是通过线程池来实现的，在这一点上减少了新建线程和销毁线程的开销，减少了内存的使用。这一点在我们日常开发过程中是要学习的。
- AsyncTask 封装了Threan 和 Handler 便于前台和后台线程的切换。
- 使用范型参数，这对于我们的实际开发也是很有启发意义的。
- 对于我来说，也是阅读源码的开端，有点意义。
基本使用方法
首先得新建一个 class 去实现 AsyncTask：
class MyAsynTask extends AsyncTask<String, Integer, String> {
@Override
protected void onPreExecute() {
// 初始化各类数据
super.onPreExecute();
}
@Override
protected String doInBackground(String... params) {
// 该方法在线程池中进行
// do something here ,网络操作等
publishProgress(55);//只有调用了该方法后，才会调用 onProgressUpdate(Integer... values) 方法，因为 publishProgress() 会间接调用 onProgressUpdate()
return "zone";
}
@Override
protected void onProgressUpdate(Integer... values) {
// 该方法在 UI 线程中进行，用于更新进度值
super.onProgressUpdate(values);
}
@Override
protected void onPostExecute(String s) {
// 该方法在 UI 线程中进行，用于处理结果
Log.d("zoneLog", "onPostExecute: " + s);
super.onPostExecute(s);
}
@Override
protected void onCancelled() {
// 取消执行之后，会调用该方法
super.onCancelled();
}
}
具体的调用：
MyAsynTask myAsynTask = new MyAsynTask();
myAsynTask.execute();
// myAsynTask.cancel(true);
在下面的学习中，我建议打开 AndroidStudio 跟着走，不太清楚的地方好点进源码看个究竟。那么我们从 AsyncTask 的执行方法 execute() 开始。
@MainThread
public final AsyncTask<Params, Progress, Result> execute(Params... params) {
return executeOnExecutor(sDefaultExecutor, params);
}
从上面这段代码得知，execute() 又调用了 executeOnExecutor() ，那么多出来的参数 sDefaultExecutor 是什么鬼？继续按住 ctrl + 鼠标单击，进去看看。
public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
ok，从上面看出，sDefaultExecutor 参数就是一个线程池。接着继续往下走，看看 executeOnExecutor()
@MainThread
public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,
Params... params) {
if (mStatus != Status.PENDING) {//if 语句判是否正在执行 AsyncTask ，如果是则抛出异常
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();//调用 onPreExecute()，进行初始化工作
mWorker.mParams = params;// 参数
exec.execute(mFuture);//那么点进 mFuture 看看，如下
return this;
}
mFuture 是 FutureTask 的实例，他的继承关系如下：
class FutureTask<V> implements RunnableFuture<V>
interface RunnableFuture<V> extends Runnable, Future<V>
ok，有了上面的铺垫，我们就来看看线程池的执行过程：
下面的 execute() 方法，也就是对应着这个地方 -- > exec.execute(mFuture);
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();//这里其实就是调用了 mFuture 的 run() 方法
} finally {
scheduleNext();
}
}
});
if (mActive == null) {
scheduleNext();
}
}
protected synchronized void scheduleNext() {
if ((mActive = mTasks.poll()) != null) {
THREAD_POOL_EXECUTOR.execute(mActive);
}
}
}
FutureTask 最顶层实现了 Runnable，所以会有 run() 方法，在 run() 中会调用 mWorker 的 call() 方法，那么 mWorker 是什么鬼呢？如下： mWorker 是在 AsyncTask 的构造方法中实例化的
mWorker = new WorkerRunnable<Params, Result>() {
public Result call() throws Exception {
mTaskInvoked.set(true);//表示当前任务已经被调用过了
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
//noinspection unchecked
Result result = doInBackground(mParams);//此处调用了 doInBackground()
Binder.flushPendingCommands();
return postResult(result);
}
};
上面这段代码，最终 return postResult(result) ，那么我们进去看postResult(result) 。
private Result postResult(Result result) {
@SuppressWarnings("unchecked")
Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
new AsyncTaskResult<Result>(this, result));
message.sendToTarget();
return result;
}
上面这段代码通过 handler 发送了消息。且看看 handleMessage() 是如何处理这个消息的。代码如下：
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;
}
}
通过查看，我们知道，handleMessage() 又调用了 mTask 的 finish() 。且看看 finish() 里面又调用了什么？代码如下：
private void finish(Result result) {
if (isCancelled()) {//如果取消了，则调用 onCancelled(result)
onCancelled(result);
} else {//否则，调用 onPostExecute(result)
onPostExecute(result);
}
mStatus = Status.FINISHED;
}
一路下来，下面四个方法的具体调用也找到了出处，对 AsyncTask 原理也有了初步的了解，这次的探索也就到这里了。
@Override
protected void onPreExecute() {
}
@Override
protected String doInBackground(String... params) {
}
@Override
protected void onPostExecute(String s) {
}
@Override
protected void onCancelled() {
}
