今天来分析一下AsyncTask，并开始尝试阅读Google源码工程师写的文档.全英文，显然是一项挑战，来吧。因为之前也没写过源码分析的文章，看的也比较少，所以如果结构混乱，原谅我不是故意的。
AsyncTask源码在源码目录的framework/base/core/java/android/os目录下，在具体代码之前，有详细的英文说明文档。这篇文章就出自此处。
一、说明
AsyncTask是Anroid系统提供给我们的在UI线程中使用该类，来进行执行后台执行长时间的操作，并将执行结果更新到UI线程中；是除了使用Thread和Handler来实现耗时操作和结果更新的另一种实现，更简单，方便。
- 定义说明：定义一个异步的AsyncTask任务时，系统允许传递3个属性类型来进行说明，Params，Progress，Result;按其执行顺序依次对应，执行前需传入的参数，执行中进度的更新单位，执行完成之后返回的结果类型；使用时可传入String，Long，Integer等类型的参数，如果不需要参数，使用时可传Void。
- 执行过程说明：AsyncTask执行的过程主要设计开发者的就是4个方法，也可以理解为4步：依次为onPreExecute，doInBackground，onProgressUpdate，onPostExecute。其中只有doInBackground方法是在非UI线程中执行的，其他三个均在UI线程中执行，极大的方便了开发者的使用。
二、用法
AsyncTask类在源码中被定义成了抽象类，如果开发者想要使用AsyncTask,必须要自己实现一个自定义任务类来extends源码，然后进行使用。自定义任务类应至少实现doInBackground方法，因为其是抽闲的。通常的情况下，还会实现onPostExecute方法，onPreExecute方法等。
举例：
private class DownloadFilesTask extends AsyncTask {
protected Long doInBackground(URL... urls) {
int count = urls.length;
long totalSize = 0;
for (int i = 0; i < count; i++) {
totalSize += Downloader.downloadFile(urls[i]);
publishProgress((int) ((i / (float) count) * 100));
// Escape early if cancel() is called
if (isCancelled()) break;
}
return totalSize;
}
protected void onProgressUpdate(Integer... progress) {
setProgressPercent(progress[0]);
}
protected void onPostExecute(Long result) {
showDialog("Downloaded " + result + " bytes");
}
}
一旦一个任务被创建，开始执行该任务，仅需调用其execute方法即可执行。
- 执行任务实例，执行任务分为串行和并行两种形式，如下：
new DownAsyncTask().extcute();//串行实例化
new DownAsyncTask().executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR,"");//并行实例化
- 取消一个任务：一个任务可以在执行期间的任何时刻被取消，只需要调用其cancel方法，调用cancel方法之后，isCancelled方法就会返回true，表示该任务已取消；在调用cancel方法之后，doInBackground方法结束执行之后，会调用onCancelled方法，不在执行onPostExecute方法；
三、使用规则谨记
- 目标任务必须在UI线程中进行加载；
- 目标任务实例必须在UI线程中进行创建；
- 开发者不能手动调用onPreExecute，onPostExecute，doInBackground，onProgressUpdate方法；
- 目标任务仅仅会执行一次，如果试图执行多次，系统会抛出异常
四、执行规则
- 起初刚开始设计时，AsyncTask仅会在后台单独的线程中进行执行，也就是说执行是串行的;
- 从SDK1.6开始，开始转变为在一个线程池中允许多个任务进行请求执行,也就是支持并行执行；
- 从3.1开始，又修改为目标任务在一个单线程中执行，也就是串行执行，主要是为了避免并发执行可能会造成的错误；如果实在想并发执行，可以调用executeOnExecutor方法进行；
以上的内容均来在AsyncTask源码声明文件前的注释，从中也可以看到，人家Google确实是伟大的公司，标准规范特别详细，特别贴心。
五、代码分析
- 关于线程池的配置
//获取到当前设备的cpu配置
private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
//核心线程数量 动态的计算
private static final int CORE_POOL_SIZE = CPU_COUNT + 1;
//线程池中允许的最大线程数目
private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;
private static final int KEEP_ALIVE = 1;
- 关于任务状态
一个目标任务在其完整的生命周期内，其任意时刻的状态仅会是一下三种中的一种：
public enum Status {
//任务未执行
PENDING,
//任务正在执行中
RUNNING,
//任务已结束
FINISHED,
}
- 构造函数中的初始化工作
public AsyncTask() {
mWorker = new WorkerRunnable() {
public Result call() throws Exception {
mTaskInvoked.set(true);
//设置线程的优先级
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
//noinspection unchecked
//调用doInBackground方法,并将postResult进行回传分发
return postResult(doInBackground(mParams));
}
};
mFuture = new FutureTask(mWorker) {
//任务执行完毕后会调用done方法
@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实现了Callable接口，使用时实现call方法
private static abstract class WorkerRunnable implements Callable {
Params[] mParams;
}
//初始化操作中涉及到的get()方法，该方法返回的就是执行后的结果,也就是mWorker的call方法的返回值
public final Result get() throws InterruptedException, ExecutionException {
return mFuture.get();
}
- 执行过程分析
1在主线程中实例化任务对象并显示调用execute方法。
/**
* An {@link Executor} that executes tasks one at a time in serial
* order. This serialization is global to a particular process.
* 全局的线程池用来执行队列任务
*/
public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
//This method must be invoked on the UI thread.方法注释说明该方法必须在UI线程调用
public final AsyncTask execute(Params... params) {
//调用executeOnExecutor方法执行后台任务
return executeOnExecutor(sDefaultExecutor, params);
}
2.执行线程池对象的execute方法，具体执行某一个队列任务.
//包含两个参数，第一个参数为默认的线程池对象，默认已经初始化；第二个参数为具体任务的传入参数
public final AsyncTask executeOnExecutor(Executor exec,
Params... params) {
//执行之前首先判断任务的状态，只有是PENDING状态才能执行，这里也照应了前文说的，一个目标任务只能被执行一次，否则会抛出异常；
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方法，注意此时还在UI线程中
onPreExecute();
//将任务传入参数进行赋值，调用execute方法执行耗时操作；同时返回为AsyncTask对象任务自身；
mWorker.mParams = params;
exec.execute(mFuture);
return this;
}
3.具体的execute方法
//变量定义
public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
//Executor 声明及实现
private static class SerialExecutor implements Executor {
//任务线程队列
final ArrayDeque mTasks = new ArrayDeque();
Runnable mActive;
//上一步骤提到的execute方法，参数说明传入一个Runnable对象
public synchronized void execute(final Runnable r) {
//将此任务添加到任务队列中
mTasks.offer(new Runnable() {
public void run() {
try {
//此处调用的run方法就是调用的传入的mFuture对象的run方法
r.run();
} finally {
//try...finally代码块,finally块一定会执行，处理队列中的下一个任务
scheduleNext();
}
}
});
//如果没有活动的runnable，从双端队列里面取出一个runnable放到线程池中运行
//第一个请求任务过来的时候mActive是空的
if (mActive == null) {
scheduleNext();
}
}
//具体处理下一个任务的方法
protected synchronized void scheduleNext() {
//从队列中取一个任务 然后执行线程池的execute方法
if ((mActive = mTasks.poll()) != null) {
THREAD_POOL_EXECUTOR.execute(mActive);
}
}
}
//线程池对象
public static final Executor THREAD_POOL_EXECUTOR
= new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,
TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);
4.关于mFuture以及具体的线程执行和方法调用
//上文已经提到过的继承自Callable接口的自定义类，同时添加了Params数组参数；
private final WorkerRunnable mWorker;
//具体的任务线程对象
private final FutureTask mFuture;
//Java库中的FutureTask声明及定义,实现了RunnableFuture接口，RunnableFuture接口继承自Runnable,这也是上一步骤的execute要传入的对象mFeature的原因，我们主要看run方法。
public class FutureTask implements RunnableFuture {
public void run() {
if (state != NEW || !UNSAFE.compareAndSwapObject(this, runnerOffset, null, Thread.currentThread()))
return;
try {
//此处涉及到了一个Callable对象
Callable c = callable;
if (c != null && state == NEW) {
V result;
boolean ran;
try {
//调用Callable的call方法。这里就明白为什么我们要看这段代码了，就是因为我们要捋清代码执行的顺序及调用关系。
//在执行run方法的时候，会回调call方法，其实就是我们AsyncTask类中以及上文分析的在构造方法中初始化操作的mWorkRunnable匿名内部类的call方法，然后执行其耗时操作。
//当执行完成时再调用done方法，进行结果分发。
result = c.call();
ran = true;
} catch (Throwable ex) {
result = null;
ran = false;
setException(ex);
}
if (ran)
set(result);
}
} finally {
// runner must be non-null until state is settled to
// prevent concurrent calls to run()
runner = null;
// state must be re-read after nulling runner to prevent
// leaked interrupts
int s = state;
if (s >= INTERRUPTING)
handlePossibleCancellationInterrupt(s);
}
}
}
上面的两个步骤比较关键，解析完代码，重新用文字进行梳理一下，具体来说就是：exec.execute(mFuture)执行时，SerialExecutor将实现了Runnable以及RunnableFeture接口的mFuture传递给实例对象执行execute方法。在execute方法中，首先将任务添加到任务队列中，添加方法为mTasks.offer(Runnable r);然后开始执行任务，第一次执行时mActive＝＝null，所以直接从任务队列中取一个任务并调用线程池的execute方法，其实就是mFuture的run方法，从任务队列取任务的方法为mTasks.poll()方法；上一个任务执行完run方法之后，接着处理下一个任务，依次循环；在执行mFeture的run方法时，也就是子线程开始执行时，会回调call方法，call方法就是上文的mWorkRunnable中的call，从而call方法中又调用了doInBackground方法执行耗时操作; doInBackground方法执行完毕后，会调用postResult方法将结果分发回传。
- postResult方法以及子线程如何通知主线程的分析
private Result postResult(Result result) {
@SuppressWarnings("unchecked")
Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
new AsyncTaskResult(this, result));
message.sendToTarget();
return result;
}
private static InternalHandler sHandler;
//使用了单例模式来保证Handler唯一
private static Handler getHandler() {
synchronized (AsyncTask.class) {
if (sHandler == null) {
sHandler = new InternalHandler();
}
return sHandler;
}
}
private static class InternalHandler extends Handler {
public InternalHandler() {
//获取到UI线程的Looper()
super(Looper.getMainLooper());
}
@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源码大概的内容就是这些。欢迎评论交流。
扫描下方的二维码，加入关注，所发布的博客文章会及时发布到公众号，方便及时查看，加入我吧，一起进步。
喜欢而非坚持