AsyncTask源码笔记
AsyncTask在注释中建议只用来做短时间的异步操作，也就是只有几秒的操作；如果是长时间的操作，建议还是使用java.util.concurrent包中的工具类，例如Executor, ThreadPoolExecutor, FutureTask等。
使用
AsyncTask类中定义了三个重要的参数类型：Params, Progress, Result。还有四个重要的过程：onPreExecute, doInBackground, onProgressUpdate, onPostExecute。
使用AsyncTask的时候必须要实现AsyncTask<Params,Progress,Result>的子类。
这三个类型分别代表：
Params: 执行时传入的参数类型
Progress: 更新时的传入的参数类型
Result: 异步返回结果的参数类型。
如果某个类型不用，在继承的时候直接使用Void类。
四个过程分别代表：
onPreExecute: 异步执行前的回调，在UI线程调用，通常用来初始化。
doInBackground: 异步执行的内容，在后台线程调用。在执行过程中可以通过publishProgress发起更新回调。
onProgressUpdate: 异步执行过程中的通知，它就是publishProgress的回调方法。它的内容是在UI线程中执行。
onPostExecute: 异步执行结束后的回调方法，它在UI线程中执行。
可以看到除了doInBackground方法之外其它的回调都是在UI线程中执行的。
取消任务
可以随时使用cancel(boolean)方法来取消一个任务。一个任务被取消之后，系统会执行onCandelled(Object)作为结果回调接口，而不是使用onPostExecute(Object)。可以使用isCancelled(Object)方法判断一个任务是否被取消。如果一个任务可能被取消的话，就尽量在doInBackground()方法中定期的检查isCancel()方法，如果任务被取消可以提早结束任务，节约资源。
注意事项
AsyncTask类必须在主线程中加载。在Build.VERSION_CODES.JELLY_BEAN(API 16)版本以后自动完成。AsyncTask类的实例必须在UI线程中被创建。execute方法必须在UI线程中调用。- 不能手动调用
onPreExecute(),onPostExecute,doInBackground,onProgressUpdate四个方法。 - 一个任务实例只能执行一次。(第二次执行会被抛出异常)
变量赋值
如果一个变量是AsyncTask子类的成员变量，那么：
- 在构造函数中赋值或者在
onPreExecute方法中赋值，可以在所有的回调中获取该值； - 在
doInBackground方法中赋值，可以在onProgressUpdate，onPostExecute，onCancel中获取该值。
执行顺序
AynsTask的执行顺序随系统版本有过巨大的改变。
- API 4 以前，它是在一个后台线程中顺序执行的，由调用顺序决定了任务的执行顺序；
- API 4 - 11 它是在一个线程池当中并发执行的
- API 11- ～ 它又是在一个后台线程中顺序执行。但是，如果我们想让AsyncTask并发的执行，我们可以使用
executeOnExecutor方法，为它指定一个Executor对象，控制它的执行顺序。
基本原理
想要了解这个工具，我们可以从它暴露出来的接口入手，了解执行的整个流程。我这里看的是6.0的源码，其它版本的源码可能会有所不同。
public 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);
Binder.flushPendingCommands();
return postResult(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);
}
}
};
}
从构造函数看起。构造函数里面先是创建了一个WorkerCallable实例mWorker，并利用它构造了一个FutureTask实例mFuture。mWorker这个对象对doInBackground方法做了封装。它先标记此对象已经执行过，再设置线程优先级，再获取doInBackground返回结果，并通过postResult方法将结果返回给了mFuture对象。在mFuture对象中，我们看到它主要是做了异常处理，并将结果交给了postResultIfNotInvoked()方法。
下面我们就看看posResult方法与postResultIfNotInvoked()方法。
private void postResultIfNotInvoked(Result result) {
final boolean wasTaskInvoked = mTaskInvoked.get();
if (!wasTaskInvoked) {
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;
}
private static Handler getHandler() {
synchronized (AsyncTask.class) {
if (sHandler == null) {
sHandler = new InternalHandler();
}
return sHandler;
}
}
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;
}
}
}
@SuppressWarnings({"RawUseOfParameterizedType"})
private static class AsyncTaskResult<Data> {
final AsyncTask mTask;
final Data[] mData;
AsyncTaskResult(AsyncTask task, Data... data) {
mTask = task;
mData = data;
}
}
private void finish(Result result) {
if (isCancelled()) {
onCancelled(result);
} else {
onPostExecute(result);
}
mStatus = Status.FINISHED;
}
可以看到，postResultIfNotInvoked方法最终还是调用了postResult方法。postResult方法通过一个单例的InternalHandler类发出了一个Message。这个InternalHandler是用主线程(UI)线程的Looper构建的，所以Message被传到了UI线程中了。最后一番辗转，在UI线程中调用了自己的finish方法。在finish方法中我们看到了两个熟悉的回调方法。并对自己的状态做了处理。
所以，我们从构造方法中就能够看到AsyncTask大致的执行流程了。接下来通过我们调用的第二个方法execute来看一看，mWorker与mFuture触发的逻辑。
@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;
}
execute方法调用了executeOnExecutor方法。它使用了一个默认的Executor对象管理线程的执行顺序。在executoOnExecutor方法中，首先对状态进行了处理，非PENDING状态执行都会抛出异常，这里可以解释为什么不能执行两次。然后首先调用了onPreExecute()方法，然后利用传进来的Executor对象执行了mFuture任务，并将自己返回。
如果你使用了指定线程池的方式调用，那么多个任务之间的执行顺序由Executor对象来控制。这个执行顺序是可以自定义控制的。
如果使用默认的顺序，那么我们来看看它的逻辑：
public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
/**
* An {@link Executor} that can be used to execute tasks in parallel.
*/
public static final Executor THREAD_POOL_EXECUTOR
= new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,
TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);
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();
} finally {
scheduleNext();
}
}
});
if (mActive == null) {
scheduleNext();
}
}
protected synchronized void scheduleNext() {
if ((mActive = mTasks.poll()) != null) {
THREAD_POOL_EXECUTOR.execute(mActive);
}
}
}
这里设计的很巧妙。先看scheduleNext()方法，它就是从队列中取出首个元素并执行。再看execute方法，每次调用execute的时候都会将一个任务放到队尾，并且这个任务封装好了目标任务。这个封装的作用是任务执行结束（正常或者异常结束）的时候，就会调用scheduleNext()方法。这样就像链表一样，一个执行结束就触发下一个，达到了顺序执行的目的。每次插入任务的时候都会检查一次是否有任务执行，没有任务执行的时候才会执行队首的任务。
AsyncTask的主要流程就差不多了, 剩下的一些调用都比较简单。
public final boolean isCancelled() {
return mCancelled.get();
}
public final boolean cancel(boolean mayInterruptIfRunning) {
mCancelled.set(true);
return mFuture.cancel(mayInterruptIfRunning);
}
@WorkerThread
protected final void publishProgress(Progress... values) {
if (!isCancelled()) {
getHandler().obtainMessage(MESSAGE_POST_PROGRESS,
new AsyncTaskResult<Progress>(this, values)).sendToTarget();
}
}
这里可以看到cancel完全是通过FutureTask的cancel方法来实现的。publishProgress也是通过Message-Handler来实现的。
AsyncTask的源码分析就到这里了，有什么不对的地方还请大家指教。