1、AsyncTask源码分析
1、构造方法
先看构造方法，在类初始化的时候，创建了Callable对象和FutureTask对象，并用FutureTask对象来包装Callable对象，call()方法将做为线程的执行体。
private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {
Params[] mParams;
}
public AsyncTask() {
mWorker = new WorkerRunnable<Params, Result>() {
public Result call() throws Exception {
//当前任务已被调用过
mTaskInvoked.set(true);
try {
...
result = doInBackground(mParams);
} catch (Throwable tr) {
...
} finally {
postResult(result);
}
return result;
}
};
mFuture = new FutureTask<Result>(mWorker) {...};
}
但是为什么要使用FutureTask和Callable，直接使用Runnable不可以吗？
2、InternalHandler
postResult()方法会通过InternalHandler，向主线程发送一个MESSAGE_POST_RESULT消息；InternalHandler收到消息后，会调用AsyncTask的finish()方法，然后就可以将结果传递给onPostExecute()方法了。
private Result postResult(Result result) {
Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
new AsyncTaskResult<Result>(this, result));
message.sendToTarget();
return result;
}
InternalHandler，用于将执行环境从线程池，切换到主线程
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());
}
@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;
}
}
}
private void finish(Result result) {
if (isCancelled()) {
onCancelled(result);
} else {
onPostExecute(result);
}
mStatus = Status.FINISHED;
}
private static class AsyncTaskResult<Data> {
final AsyncTask mTask;
final Data[] mData;
AsyncTaskResult(AsyncTask task, Data... data) {
mTask = task;
mData = data;
}
}
从以上代码中我们可以看到，sHandler是一个静态的Handler对象。我们知道创建Handler对象时需要当前线程的Looper，所以我们为了以后能够通过sHandler将执行环境从后台线程切换到主线程（即在主线程中执行handleMessage方法），我们必须使用主线程的Looper，因此必须在主线程中创建sHandler。这也就解释了为什么必须在主线程中加载AsyncTask类，是为了完成sHandler这个静态成员的初始化工作。
3、execute()方法
execute()方法接收的参数是Params类型的参数，这个参数会一路传递到doInBackground方法中；通过execute()方法，可以将FutureTask对象添加到线程池（SerialExecutor）中
@MainThread
public final AsyncTask<Params, Progress, Result> execute(Params... params) {
return executeOnExecutor(sDefaultExecutor, params);
}
如下，当AsyncTask对象的当前状态为RUNNING或FINISHED时，调用execute方法会抛出异常，这意味着不能对正在执行任务的AsyncTask对象或是已经执行完任务的AsyncTask对象调用execute方法，这就是‘一个AsyncTask对象只能调用一次execute方法’的原因
@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;
}
AsyncTask有两个线程池：sDefaultExecutor (SerialExecutor)、THREAD_POOL_EXECUTOR。
sDefaultExecutor，是一个串行的线程池，主要是把任务加到任务缓存队列中；THREAD_POOL_EXECUTOR用于真正的执行任务
- mTask代表这个线程池的任务缓存队列，我们可以使用offer()方法向这个队列添加任务。
- mActive代表当前正在执行的任务，可以通过mTasks.poll()取出一个任务，使用THREAD_POOL_EXECUTOR.execute(mActive);执行这个任务，这时后台任务便开始你真正执行了。
THREAD_POOL_EXECUTOR线程池，会执行mTasks中的run()方法——>mFuture的run()方法——>Callable的call()方法——>doInBackground()方法
private static volatile Executor sDefaultExecutor = new SerialExecutor();
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);
}
}
}
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;
}
2、AsyncTask的简单使用
AsyncTask asyncTask=new AsyncTask<String, Integer, Void>() {
@Override
protected void onPreExecute() {}
@Override
protected void onPostExecute(Void aVoid) { }
@Override
protected void onProgressUpdate(Integer... values) {}
@Override
protected Void doInBackground(String... params) { return null;}}
.execute("");
- onPreExecute()：在主线程中进行，在异步任务开始之前调用
- doInBackground()在线程池中执行，用于执行异步任务
- onProgressUpdate()：在主线程中进行，在异步任务执行进度发生变化时调用
- **onPostExecute() **：在主线程中进行，在异步任务执行完调用
3、 AsyncTask的局限性
AsyncTask的优点在于执行完后台任务后可以很方便的更新UI，然而使用它存在着诸多的限制
在Android 4.1版本之前，AsyncTask类必须在主线程中加载，这意味着对AsyncTask类的第一次访问必须发生在主线程中；在Android 4.1以及以上版本则不存在这一限制，因为ActivityThread（代表了主线程）的main方法中会自动加载AsyncTask
AsyncTask对象要在主线程中创建
execute()方法要在主线程调用
一个AsyncTask对象对象只能执行一次execute()方法
内存泄漏：如果AsyncTask被声明为Activity的非静态的内部类，那么AsyncTask会保留一个对创建了AsyncTask的Activity的引用。如果Activity已经被销毁，AsyncTask的后台线程还在执行，它将继续在内存里保留这个引用，导致Activity无法被回收，引起内存泄露。
</br></br>
参考：Android开发艺术探讨、深入理解AsyncTask的工作原理
</br></br>
