主目录见：Android高级进阶知识（这是总目录索引）
国庆的假期刚刚过去，今天就用一篇比较简单的文章来收收心，AsynTask相信大家已经非常熟悉了，而且用的也是溜溜地，但是他的源码还是非常值得一看的，今天我们就一起来领略他的风采吧。
一.目标
AsynTask内部简化了Thread+handler的使用，可以让我们在后台执行任务并更新UI，但是这个开源框架经过了几次改版，代码都有稍微变化，今天我们来分析这个源码有两个目标:
1)加深Thread+Handler的结合使用;
2)熟悉FutureTask的使用;
3)能解决用这个框架出现的一些问题.
二.源码分析
要分析源码我们都是老规矩，先来看看他的基本用法是什么：
public class DownloadTask extends AsyncTask<String,Integer,String> {
private static final String TAG = "DOWNLOAD_TASK";
private String name = "DownloadTask";
public DownloadTask(String name){
super();
this.name = name;
}
@Override
protected void onPreExecute() {
super.onPreExecute();
//下载前
}
@Override
protected String doInBackground(String... strings) {
//后台执行
try{
Thread.sleep(3000);
}catch (Exception e){
e.printStackTrace();
}
return name;
}
@Override
protected void onPostExecute(String result) {
super.onPostExecute(result);
//执行完毕
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Log.e(TAG, result + "execute finish at "+df.format(new Date()));
}
@Override
protected void onProgressUpdate(Integer... values) {
super.onProgressUpdate(values);
//当前的进度
}
}
1）首先我们先来介绍AsyncTask<String,Integer,String>这其中的几个参数作用：
1.第一个参数Params：在执行调用excute时候传入，在doInBackground()方法中使用。
2.第二个参数Progress:后台任务执行时候，需要显示进度的时候，使用这里泛型作为返回参数，在onProgressUpdate()方法中使用。
3.第三个参数Result:当任务执行完毕时候对结果进行返回，则使用这个指定的泛型来作为返回参数，在onPostExecute()方法中使用。
2）接着我们就介绍这里面的几个方法，来分别实现我们的需求：
1.onPreExecute:这个方法是在后台任务执行开始之前，在这里一般会做一些初始化的工作。
2.doInBackground(Params...):这个方法会在子线程中执行，主要用于执行一些耗时的任务，其中方法的返回值类型是依据最后一个参数Result而定的，注意如果要更新进度则调用publishProgress(Progress...)方法。
3.onProgressUpdate(Progress...):当执行了publishProgress()方法之后，就会调用这个方法，在这个方法里面我们就可以显示我们的进度了，这个方法是在主线程的所以可以更新UI。
4.onPostExecute(Result)：当doInBackground执行完毕return完之后，就会把值返回给这个方法，这个方法也是可以更新UI的，做一些收尾工作。
到这里，参数和方法都已经说明完毕了，我们如果要使用就可以直接调用这句：
new DownloadTask("downloadtask#1").execute("");
1.AsyncTask 构造方法
首先从使用我们可以看出，我们代码要从构造方法开始看：
public AsyncTask() {
mWorker = new WorkerRunnable<Params, Result>() {
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<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);
}
}
};
}
虽然代码很长，但是不要被吓到，其实就new出了两个对象，第一个对象mWorker 其实是个Callable：
private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {
Params[] mParams;
}
而第二个对象mFuture 是个FutureTask，然后把这个Callbale对象传进FutureTask里面，最后执行的时候会回调Callable对象里面的call方法。接着程序会调用execute进行执行，我们继续往下看。
2.AsyncTask execute
我们直接看看execute做了些啥，内心兴奋，一定有无数珍宝:
@MainThread
public final AsyncTask<Params, Progress, Result> execute(Params... params) {
return executeOnExecutor(sDefaultExecutor, params);
}
我擦嘞，一脸闷逼，就一个方法，这么简单，我们只能往下挖了：
@MainThread
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;
}
我们可以看到这个方法才是我们的主方法，第一个参数是可以传入自己的Executor，也可以传入这个类里面的THREAD_POOL_EXECUTOR，为了实现并行，我们可以在外部这么用AsyncTask： asyncTask.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, Params... params);必须在UI线程调用此方法。然后我们看到代码会往下调用到onPreExecute()方法，这个方法就是我们上面说的会在doInBackground()方法之前执行。那么我们的doInBackground()方法在哪里执行呢？我们往下看到程序会执行exec.execute(mFuture)，这里的exec是我们默认传进来的sDefaultExecutor，我们找到sDefaultExecutor是什么先：
我们看到sDefaultExecutor其实模式的是SerialExecutor，那就是说我们程序会调用SerialExecutor的execute()方法：
private static class SerialExecutor implements Executor {
//线性双向队列,存储所有的Task
final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
//当前正在执行的Task
Runnable mActive;
public synchronized void execute(final Runnable r) {
//将新的任务添加进队列中
mTasks.offer(new Runnable() {
public void run() {
try {
//执行task
r.run();
} finally {
//如果执行完task则执行下一个任务，这里明显体现了串行执行的特征
scheduleNext();
}
}
});
//如果没有任务在执行，则直接进入执行
if (mActive == null) {
scheduleNext();
}
}
//从线性双向队列中取出任务进行执行
protected synchronized void scheduleNext() {
if ((mActive = mTasks.poll()) != null) {
//用Executor执行task
THREAD_POOL_EXECUTOR.execute(mActive);
}
}
}
从程序可以看出我们程序会执行传进来Runnable的run方法，那么这里的Runnable其实就是我们前面传进来的FutureTask，也就是说会执行这个FutureTask的run方法，我们来看看：
public void run() {
if (state != NEW ||
!U.compareAndSwapObject(this, RUNNER, null, Thread.currentThread()))
return;
try {
Callable<V> c = callable;
//如果不为空，且状态是NEW则调用
if (c != null && state == NEW) {
V result;
boolean ran;
try {
//调用task的call方法
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);
}
}
从程序可以看出，程序会调用FutureTask的call方法，而这里的c就是callable对象，也就是传进来的WorkerRunnable，所以我们看WorkerRunnable的call方法干了啥：
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;
}
可以看到我们这里执行到了我们的doInBackground(),然后我们最后把结果传给了postResult()方法。我们直接跟进这个方法看下：
private Result postResult(Result result) {
@SuppressWarnings("unchecked")
Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
new AsyncTaskResult<Result>(this, result));
message.sendToTarget();
return result;
}
可以看到这里发送了一个消息携带了MESSAGE_POST_RESULT和一个AsyncTaskResult对象，这个AsyncTaskResult对象是什么呢？
@SuppressWarnings({"RawUseOfParameterizedType"})
private static class AsyncTaskResult<Data> {
final AsyncTask mTask;
final Data[] mData;
AsyncTaskResult(AsyncTask task, Data... data) {
mTask = task;
mData = data;
}
}
其实就是携带一个AsncTask和result，我们直接看到发送到的Handler，从getHandler跟进去，我们找到最终跑到InternalHandler：
private static class InternalHandler extends Handler {
public InternalHandler() {
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;
}
}
}
我们看到这里有两个分支，我们的消息携带的是MESSAGE_POST_RESULT，所以我们的程序会走到result.mTask.finish(result.mData[0])。这个finish其实就是AsynTask的内部方法：
private void finish(Result result) {
if (isCancelled()) {
onCancelled(result);
} else {
onPostExecute(result);
}
mStatus = Status.FINISHED;
}
只有特殊情况下会调用onCancelled方法，正常情况下都会调用onPostExecute()方法，这里是在Handler中调用的，所以是在UI线程中调用的，这也印证了前面说的。我们的WorkerRunnable的call执行完毕后，就会执行到FutureTask的done方法。
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);
}
}
};
这个方法里面的get()就是callable对象（WorkerRunnable）返回的result，然后我们看postResultIfNotInvoked方法做了啥：
private void postResultIfNotInvoked(Result result) {
final boolean wasTaskInvoked = mTaskInvoked.get();
if (!wasTaskInvoked) {
postResult(result);
}
}
wasTaskInvoked 这个标志在mWorker初始化的时候已经设置为true，所以这里postResult一般执行不到。但是我们前面说到更新进度，怎么这里就没看见呢？我们说过更新进度我们必须要手动调用publishProgress才行，我们看这个方法做了啥：
@WorkerThread
protected final void publishProgress(Progress... values) {
if (!isCancelled()) {
getHandler().obtainMessage(MESSAGE_POST_PROGRESS,
new AsyncTaskResult<Progress>(this, values)).sendToTarget();
}
}
我们看到这个方法也是发送一条消息，不过这时候标志是MESSAGE_POST_PROGRESS，我们看到Handler里面：
private static class InternalHandler extends Handler {
public InternalHandler() {
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;
}
}
}
这个方法会到handleMessage方法里面的onProgressUpdate方法，我们直接跟进这个方法：
@SuppressWarnings({"UnusedDeclaration"})
@MainThread
protected void onProgressUpdate(Progress... values) {
}
这个方法就是给我们子类重写的，我们就可以在这个地方来更新我们的精度。好了，我们的源码讲解就到这里了。
总结：从我们分析看，我们AsynTask现在默认是串行的，以前3.0版本之前是并行的，现在如果要实现并行也是可以的，而且也可以自己实现一个Executor这里面的线程池数量，线程数都是可以自己设置，所以网络上说的AsynTask的坑其实不是什么大问题，只要使用得当，好啦，了解了源码，我相信不用再听别人说:坑了
