Android AsyncTask原理解析
前言：AsyncTask是对Handler异步消息处理的一层封装，方便开发者便捷使用异步处理的一个类。
源码：6.0
AsyncTask的使用
/**
* 1. Params
在执行AsyncTask时需要传入的参数，用于在后台任务(doInBackground)中使用。
2. Progress
后台任务执行时，如果需要在界面上显示当前的进度(onProgressUpdate)，使用这里指定的泛型作为进度单位。
3. Result
当任务执行完毕后，如果需要对结果进行返回(onPostExecute)，使用这里指定的泛型作为返回值类型。
*/
class DownTasg extends AsyncTask<String,Integer,Boolean>{
@Override
protected void onPreExecute() {
super.onPreExecute();
//任务准备开始执行 UI线程
}
@Override
protected Boolean doInBackground(String... params) {
//进行耗时操作 工作线程
//这里的返回值在onPostExecute() 使用
return null;
}
@Override
protected void onProgressUpdate(Integer... values) {
//进度回调 UI线程
super.onProgressUpdate(values);
}
@Override
protected void onPostExecute(Boolean aBoolean) {
//任务执行结果， doInBackground() 的执行结果 UI线程
super.onPostExecute(aBoolean);
}
}这里就不啰嗦了。
源码分析
先来看看它的构造方法
public AsyncTask() {
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);
}
}
};
} WorkerRunnable
private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {
Params[] mParams;
}这里可以看见初始化了一个WorkerRunnable以及FutureTask，WorkerRunnable其实是一个Callable；
FutureTask则是异步任务使用。
FutureTask一个可取消的异步计算，FutureTask 实现了Future的基本方法，提空 start cancel 操作，可以查询计算是否已经完成，
并且可以获取计算的结果。结果只可以在计算完成之后获取，get方法会阻塞当计算没有完成的时候，一旦计算已经完成，
那么计算就不能再次启动或是取消。
一个FutureTask 可以用来包装一个 Callable 或是一个runnable对象。因为FurtureTask实现了Runnable方法，所以一个 FutureTask可以提交给一个Executor执行
注意：FutureTask的使用必须配合Executor。
Java功底扎实的其实看见初始化函数大致就清楚AsyncTask是怎么一个回事了，AsyncTask其实是使用了线程池来进行异步操作，
先看
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);
}
}
};
} FutureTask的回调done()方法执行了postResultIfNotInvoked()
//这个值在初始化WorkRunnable时赋值为true
private final AtomicBoolean mTaskInvoked = new AtomicBoolean();
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(this, result));
message.sendToTarget();
return result;
} postResultIfNotInvoked方法做了一个判断，只有在初始化AsyncTask也就是mTaskInvoked变量为false时才会去调用；初始化先分析到这里。
现在来看看AsyncTask是怎么执行的
@MainThread
public final AsyncTask<Params, Progress, Result> execute(Params... params) {
return executeOnExecutor(sDefaultExecutor, params);
}执行AsyncTask必须调用execute() 方法（方法上面加了注解，必须在MainThread调用），这里只是调用了executeOnExecutor()方法。
@MainThread
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;
//1。准备执行
onPreExecute();
mWorker.mParams = params;
//2.这个对象是一个Executor参数mFuture是AsyncTask初始化创建的
exec.execute(mFuture);
return this;
} 这里进行了各种状态检查，以及设置，注释1处调用onPreExecute()方法，然后在注释2调用Executor对象的的execute()方法。
重点来了：
public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
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() {
//2
try {
r.run();
} finally {
scheduleNext();
}
}
});
//1
if (mActive == null) {
scheduleNext();
}
}
protected synchronized void scheduleNext() {
if ((mActive = mTasks.poll()) != null) {
//注意这个Executor对象是static代码块创建的
THREAD_POOL_EXECUTOR.execute(mActive);
}
}
} 首先这里先自定义了了一个变量sDefaultExecutor，注意他的声明 static volatile 这样保证了每new一个AsyncTask都保证Executor对象在并发情况下的同步，volatile关键字有不理解的可以看关于volatile
下面来看看自定义的这个SerialExecutor内部类，先用ArrayDeque队列来存储Runnable对象，当调用execute方法的时候，先把Runnable插入ArrayDeque队列的对尾，执行注释1处mActive == null判断，然后再调用注释2处Runnable对象的run()方法，无论run()是否执行过了，都会调用scheduleNext()方法，而这个scheduleNext()方法就是把类中的Runnable对象赋值成为队列中的第一个值。
注意代码执行顺序
其实说了那么多：
就是干了一件事，维护一个Runnable对象的队列，通过递归的方式来遍历这个队列，而且注意execute()方法使用synchronized关键字修饰；保证并发操作链表数据的一致性；
接着来看scheduleNext()这个方法
public static final Executor 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;
}这里直接使用了ThreadPoolExecutor类来定义线程池。
回到SerialExecutor.execute()方法，这里的r.run()执行了我们最开始分析的那块代码
public AsyncTask() {
mWorker = new WorkerRunnable() {
public Result call() throws Exception {
mTaskInvoked.set(true);
Result result = null;
try {
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
//noinspection unchecked
//1.这里是SerialExecutor.execute()执行的所以是工作线程，可以执行异步操作。
result = doInBackground(mParams);
Binder.flushPendingCommands();
} catch (Throwable tr) {
mCancelled.set(true);
throw tr;
} finally {
//2.具体执行
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);
}
}
};
} 这里注意注释 1 调用了doInBackground；注释2则是具体执行
postResult
private Result postResult(Result result) {
@SuppressWarnings("unchecked")
Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
new AsyncTaskResult(this, result));
message.sendToTarget();
return result;
}
这里是使用Handler把处理过的结果发送出去；
来看接收
InternalHandler
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;
}
}这里分别执行了finish 和onProgressUpdate()这个方法就是进度回调的方法了。
来看finish
private void finish(Result result) {
if (isCancelled()) {
onCancelled(result);
} else {
onPostExecute(result);
}
mStatus = Status.FINISHED;
}也是进行了结束或者取消的回调。
关于AsyncTask3.0以前版本的问题
在Android 3.0之前是没有SerialExecutor这个类的，那个时候是直接在AsyncTask中构建了一个sExecutor常量，并对线程池总大小，同一时刻能够运行的线程数做了规定
private static final int CORE_POOL_SIZE = 5;
private static final int MAXIMUM_POOL_SIZE = 128;
private static final int KEEP_ALIVE = 10;
……
private static final ThreadPoolExecutor sExecutor = new ThreadPoolExecutor(CORE_POOL_SIZE,
MAXIMUM_POOL_SIZE, KEEP_ALIVE, TimeUnit.SECONDS, sWorkQueue, sThreadFactory); 可以看到，这里规定同一时刻能够运行的线程数为5个，线程池总大小为128。也就是说当我们启动了10个任务时，只有5个任务能够立刻执行，另外的5个任务则需要等待，当有一个任务执行完毕后，第6个任务才会启动，以此类推。而线程池中最大能存放的线程数是128个，也就是说，当我们添加第129个任务时，程序就会崩溃了。
而3.0之后提供的是一个executeOnExecutor()方法，如果不想使用默认的SerialExecutor则可以
Executor exec = new ThreadPoolExecutor(10, 100, 10,
TimeUnit.SECONDS, new LinkedBlockingQueue());
new DownloadTask().executeOnExecutor(exec); 这样可以更灵活的使用了。
总结
- AsyncTask使用了线程池+Handler机制来执行异步操作。
- 3.0以上默认的SerialExecutor其实是维护了一个单一线程池。
- Android 3.0之前是没有SerialExecutor这个类的，而是直接在AsyncTask中构建了一个sExecutor常量，并对线程池总大小，同一时刻能够运行的线程数做了规定，这样的后果就是，当超出线程池大小的值时，程序就会崩溃。