AsyncTask原理
前言
本文所使用的源码应该比较新（可能是7.0以上，我的Android Studio中好像看不了源码版本），和书中代码稍有出入，但是不影响代码分析。
一.概述
AsyncTask是一个轻量型的异步任务类，它可以在线程池中执行后台任务，然后将执行进度和结果传递给主线程。
先来看看AsyncTask的定义：
public abstract class AsyncTask<Params, Progress, Result>
Params, Progress, Result是三个泛型参数，Params是参数类型，调用AsyncTask的execute方法时会传入一个这样的参数；Progress表示执行任务的进度类型；Result表示返回结果的类型。
AsyncTask有这么几个常用方法：
1.onPreExecute()，这个方法在异步任务执行之前调用，可以做一些执行前的UI操作
2.doInBackground(Params…params)，此方法在线程池中执行异步操作，方法内可以调用publishProgress方法将任务进度传给onProgressUpdate方法，返回值会传给onPostExecute方法。
3.onProgressUpdate(Progress…values)，任务进度更新时会调用这个方法。
4.onPostExecute(Result result)，任务执行完后会调用这个方法。
上面四个方法中只有doInBackground方法在线程池中执行，其他三个方法都在主线程中执行，可以进行相关的UI操作。
注意事项：
1.AsyncTask对象必须在主线程创建
2.execute方法也必须在主线程调用
3.同一个AsyncTask对象只能执行一次，否则会抛出异常。
4.execute方法用于串行执行任务，而executeOnExecutor用来并行执行任务。
二.原理介绍
- AsyncTask的实现原理 = 线程池 + Handler
其中：线程池用于线程调度、复用 & 执行任务；Handler 用于异步通信
三.源码分析
我们先从它的execute方法开始入手，execute方法中直接调用了executeOnExecutor方法：
public final AsyncTask<Params, Progress, Result> execute(Params... params) {
return executeOnExecutor(sDefaultExecutor, params); //sDefaultExecutor是Executor的实例，而Executor是一个接口，它的实现类是SerialExecutor，这是一个串行线程池
}
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(); //这里调用了onPreExecute方法
mWorker.mParams = params;
exec.execute(mFuture); //这里调用了Executor接口的实现类SerialExecutor中的execute方法。mFuture是AsynsTask类时创建的FutureTask对象
return this;
}
下面来看看SerialExecutor的实现，它是AsyncTask中的一个静态内部类：
public static final Executor THREAD_POOL_EXECUTOR;
static {
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE_SECONDS, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>(), sThreadFactory);
threadPoolExecutor.setRejectedExecutionHandler(sRunOnSerialPolicy);
THREAD_POOL_EXECUTOR = threadPoolExecutor;
}
public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR; //这就是上面executeOnExecutor方法的参数sDefaultExecutor，这是AsyncTask中的一个属性
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() { //这个offer方法将参数中的Runnable对象插入数组尾部
public void run() {
try {
r.run(); //执行这个Runnable
} finally {
scheduleNext(); //取出数组中下一个任务
}
}
});
if (mActive == null) { //执行完继续执行后面的任务，可以看出是串行执行
scheduleNext();
}
}
protected synchronized void scheduleNext() {
if ((mActive = mTasks.poll()) != null) { //poll方法取出并移除数组中的首元素
THREAD_POOL_EXECUTOR.execute(mActive); //THREAD_POOL_EXECUTOR是一个线程池，在类初始化的时候创建，这里调用execute方法执行取出的Runnable
}
}
}
可以从上面的这些代码看出，AsyncTask中有SerialExecutor和THREAD_POOL_EXECUTOR两个线程池，前者负责任务的排队并将任务交给后者执行。其中还有一个InternalHandler用来从线程池切换到主线程。
下面我们回过头来看看AsyncTask的构造方法，它的几个构造最终都会调用下面这个构造，在创建对象时会通过Looper参数创建自己的handler对象。（下面的代码和书中有所出入）
public AsyncTask(@Nullable Looper callbackLooper) {
mHandler = callbackLooper == null || callbackLooper == Looper.getMainLooper()
? getMainHandler()
: new Handler(callbackLooper);
mWorker = new WorkerRunnable<Params, Result>() {
public Result call() throws Exception {
mTaskInvoked.set(true); //mTaskInvoked表示任务是否调用过
Result result = null;
try {
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
//noinspection unchecked
result = doInBackground(mParams); //调用doInBackground方法执行异步任务
Binder.flushPendingCommands();
} catch (Throwable tr) {
mCancelled.set(true);
throw tr;
} finally {
postResult(result); //将执行结果回调给postResult方法，下面会继续分析这个方法
}
return 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);
}
}
};
}
在最上面executeOnExecutor方法中return this的上面一行代码
exec.execute(mFuture); //这里调用了Executor接口的实现类SerialExecutor中的execute方法
这里调用了SerialExecutor的execute方法，其中调用了mFuture的run方法。这个run方法又调用了Callable接口的run方法，而这个接口的实现类就是WorkerRunnable，上面的构造方法中创建了WorkerRunnable的匿名实现类，是不是有一种 “又回到最初的起点”的感觉~~
既然是在execute中run方法中调用的子类实现，所以现在还在子线程中，任务执行完成后要看handler如何进行线程切换，还要进入postResult方法一看究竟：
private Result postResult(Result result) {
@SuppressWarnings("unchecked")
//这里和书中有所出入，这里getHandler调用的是AsyncTask中的Handler而非InternalHander对象
Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
new AsyncTaskResult<Result>(this, result));
message.sendToTarget();
return result;
}
public void sendToTarget() {
target.sendMessage(this); //这个target是Message中的Handler对象
}
构造方法中有下面第一段这些代码。如果在主线程，就会通过多态创建mHandler对象，那么发送消息后子类InternalHandler就会来处理。
mHandler = callbackLooper == null || callbackLooper == Looper.getMainLooper()
? getMainHandler()
: new Handler(callbackLooper);
//下面是getMainHandler方法
private static Handler getMainHandler() {
synchronized (AsyncTask.class) {
if (sHandler == null) {
sHandler = new InternalHandler(Looper.getMainLooper());
}
return sHandler;
}
}
下面是子类InternalHandler的实现：
/**声明为静态类是为了它的对象能将执行环境切换到主线程*/
private static class InternalHandler extends Handler {
public InternalHandler(Looper looper) {
super(looper);
}
@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;
}
}
}
//上面调用了AsyncTask中的finish方法
private void finish(Result result) {
if(isCancelled()) {
onCancelled(result);
} else {
onPostExecute(result); //这里回调了onPostExecute方法返回执行结果
}
mStatus = Status.FINISHED;
}
同样的，更新任务进度时我们会调用publishProgress方法，它发送了一条MESSAGE_POST_PROGRESS的消息，InternalHandler收到消息后就会回调onProgressUpdate方法来更新进度。
protected final void publishProgress(Progress... values) {
if (!isCancelled()) {
getHandler().obtainMessage(MESSAGE_POST_PROGRESS,
new AsyncTaskResult<Progress>(this, values)).sendToTarget();
}
}
整个过程到这里就完成了。
四.参考资料
《安卓开发艺术探索》
Android 多线程：AsyncTask的原理 及其源码分析
扫一扫
1655
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
