AsyncTask封装了Thread,Handler,用于方便的执行后台任务以及在主线程中访问UI。
类的声明如下:
public abstract class AsyncTask
首先看execute()方法,execute()直接调用了executeOnExecutor()方法:
可以看到,首先调用了onPreExecute(),然后将参数传给mWorker,然后执行sDefaultExecutor.execute(mFuture)
public final AsyncTask execute(Params... params) {
return executeOnExecutor(sDefaultExecutor, params);
}
public final AsyncTask 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;
}
继续看mWorker是什么:
为实现Callable的AsyncTask的内部抽象类WorkerRunnable,增加了参数属性。
private final WorkerRunnable mWorker;
...
private static abstract class WorkerRunnable implements Callable {
Params[] mParams;
}
搜索代码,发现在构造方法中实现了WorkerRunnable:
重写了call()方法,调用doInBackground()并返回result。
mFuture也在构造方法中被实现,FutureTask继承自RunnableFuture,为Future和Runnable结合体,同时将mWorker作为参数传给mFuture。可得,现在我们的任务被放在了mFuture中。
public AsyncTask(@Nullable Looper callbackLooper) {
mHandler = callbackLooper == null || callbackLooper == Looper.getMainLooper()
? getMainHandler()
: new Handler(callbackLooper);
mWorker = new WorkerRunnable() {
public Result call() throws Exception {
mTaskInvoked.set(true);
Result result = null;
try {
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
//noinspection unchecked
result = doInBackground(mParams);
Binder.flushPendingCommands();
} catch (Throwable tr) {
mCancelled.set(true);
throw tr;
} finally {
postResult(result);
}
return result;
}
};
mFuture = new FutureTask(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);
}
}
};
}
分析exec.execute(mFuture);
最终发现exec为SerialExecutor类型,如下:
持有一个Runnable类型的mActive,可看出来,此runnable为将要执行的runable。
持有一个Runnable类型的list,execute()中新建一个Runnable,它的run()为mFuture的run()方法、取出并执行runnable的scheduleNext(),将之插入list。即每次执行SerialExecutor.execute()都会将mFuture放入等待执行的list,然后依靠THREAD_POOL_EXECUTOR.execute()执行。
由于SerialExecutor.execute()为synchronized方法,即排队等待过程为串行进行。但可以通过AsyncTask.executeOnExecutor()指定并行线程池THREAD_POOL_EXECUTOR执行runnable。
private static class SerialExecutor implements Executor {
final ArrayDeque mTasks = new ArrayDeque();
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);
}
}
}
THREAD_POOL_EXECUTOR的定义如下:
static {
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE_SECONDS, TimeUnit.SECONDS,
sPoolWorkQueue, sThreadFactory);
threadPoolExecutor.allowCoreThreadTimeOut(true);
THREAD_POOL_EXECUTOR = threadPoolExecutor;
}
执行到此结束,由于执行的最终为mWorker的call()方法,再次看call()会在最终完成后台任务后调用postResult()
mWorker = new WorkerRunnable() {
public Result call() throws Exception {
mTaskInvoked.set(true);
Result result = null;
try {
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
//noinspection unchecked
result = doInBackground(mParams);
Binder.flushPendingCommands();
} catch (Throwable tr) {
mCancelled.set(true);
throw tr;
} finally {
postResult(result);
}
return result;
}
};
postResult()使用Handler发出任务已完成的消息,并携带result
private Result postResult(Result result) {
@SuppressWarnings("unchecked")
Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
new AsyncTaskResult(this, result));
message.sendToTarget();
return result;
}
消息的处理由如下mHandler解决,当指定Looper且该Looper不是MainLooper时,就new Handler(),否则为如下类型.
当任务完成时,结束,当进度更新时,更新进度
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;
}
}
}