引用：(来自源码文件)
* AsyncTask可以在UI线程中使用。它通过操作thread和handler可以执行后台工作并将结果发布到UI线程。
* AsyncTask被设计为围绕Thread和Handler进行工作而不是单纯的线程池框架。
AsyncTask适用于最多耗时几秒的这种短操作。
如果你想保持线程的长连接，建议使用java.util.concurrent包提供的Executor、ThreadPoolExecutor和FutureTask。
* 一个异步操作的定义是在工作线程执行计算操作并且在主线程返回结果。
它由三个参数Params、Progress和Result组成。
由四个步骤onPreExecute、doInBackground、onProgressUpdate和onPostExecute组成。
* AsyncTask必须由子类继承使用。子类至少要实现doInBackground方法，并且经常会用到onPostExecute方法。
下面是一个实现子类：
* private class DownloadFilesTask extends AsyncTask<URL, Integer, Long> {
* 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方法启动。
* 一个异步任务要有这三类数据：
Params：发送给异步任务的参数。
Progress：在后台任务计算的时候发布出来的单位进度。
Result：后台任务执行完毕后返回的结果。
并不是每一个都要有。可以通过使用Void来略过。
* 4个过程步骤。当一个异步任务执行的时候会经过这四个方法。
onPreExecute()
doInBackground
onProgressUpdate
onPostExecute
onPreExecute：任务执行之前在UI线程调用。这个回调通常用于任务配置，比如在用户界面显示一个进度条。
doInBackground：onPreExecute方法执行完毕后在后台线程立即调用。这一步用于后台费时计算操作。这一步会传入之前的参数。
计算的结果必须被return返回传递给下一步。这里也可以使用publishProgress方法发布一个或多个进度单位。这些值会被传入UI线程的onProgressUpdate方法。
onProgressUpdate：在调用publishProgress方法后此方法在UI进程调用。此方法的执行时间是不确定的。用户可以在后台任务执行时在
这个方法里随意更新进度条。例如你能够显示进度动画或者显示进度log。
onPostExecute：在后台任务结束后，此方法在UI线程执行。计算的结果会通过参数传到这里。
* 取消任务。
可以在任何时候调用cancel方法取消任务。调用这个方法之后，onInBackground执行后就调用onCanceled方法而不是onPostExecute。
为了确保任务能够即使取消，应该在doInBackground中持续检测isCancelled方法。
* 线程规则。为了确保线程能够正确运行应该遵守下面几个规则。
AsyncTask必须在UI线程中启动。在版本16之后会自动这样做。
任务实例必须在UI线程中创建。
execute方法必须在UI线程中调用。
不要主动调用onPreExecute和onPostExecute方法和doInBackground和onProgressUpdate。
一个task任务只能执行一次，再次启动会抛出异常。
版本4开始AsynckTasks是串行执行的，版本11之后就改成了线程池并发执行，
* 串行执行可以避免一些应用问题，如果实在想并发执行，可以使用executeOnExecutor(Executor, Object[])方法
源码部分：
先看源码中所有static静态对象
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;
private static final ThreadFactory sThreadFactory = new ThreadFactory() {
private final AtomicInteger mCount = new AtomicInteger(1);
public Thread newThread(Runnable r) {
return new Thread(r, "AsyncTask #" + mCount.getAndIncrement());
}
};
private static final BlockingQueue<Runnable> sPoolWorkQueue =
new LinkedBlockingQueue<Runnable>(128);
/**
* An {@link Executor} that can be used to execute tasks in parallel.
* 翻译：并发执行的Executor
*/
public static final Executor THREAD_POOL_EXECUTOR
= new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,
TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);
上面的静态数据都是为了创建并发线程池执行器THREAD_POOL_EXECUTOR的。
public static final Executor SERIAL_EXECUTOR = 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);
}
}
}
声明并创建串型线程执行器SERIAL_EXECUTOR
@MainThread
public static void execute(Runnable runnable) {
sDefaultExecutor.execute(runnable);
}
使用默认线程执行器执行指定的Runnable。默认执行器默认是串型的。该方法只能在UI线程调用。
//Handler定义为static静态防止持有外部类导致内存溢出
private static InternalHandler 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;
}
}
}
创建静态内部Handler对象，构造中使用了Looper.getMainLooper()，也就是绑定了UI线程的Looper对象，所有Handler是执行在UI线程中的，而不是当前子线程。handleMessage方法处理两个事件：1、返回第一个Result结果数据。2、返回进度Progress数据。两个方法都是运行在UI线程。
/**
* @param <Params>
* @param <Result>
*
* Callable与Runanble没有什么不同，只是Runnable没有返回，Callable有返回，而且Callable只能配合ExecuotrService在线程池中使用。
*/
private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {
Params[] mParams;
}
@SuppressWarnings({"RawUseOfParameterizedType"})
private static class AsyncTaskResult<Data> {
final AsyncTask mTask;
final Data[] mData;
AsyncTaskResult(AsyncTask task, Data... data) {
mTask = task;
mData = data;
}
}
声明WorkerRunnable<Params,Result>工作线程类，继承自Callable<Result>，Callable与Runanble没有什么不同，只是Runnable没有返回，Callable有返回，而且Callable只能配合ExecuotrService在线程池中使用。
声明AsyncTaskResult结果封装类，封装了一个AsyncTask对象mTask和它对应的Data结果数组。
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);
}
}
};
}
private Result postResult(Result result) {
@SuppressWarnings("unchecked")
Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
new AsyncTaskResult<Result>(this, result));
message.sendToTarget();
return result;
}
AsyncTask构造器，也是初始化的地方，会初始化一个WorkerRunnable对象，因为它继承自Callable，所以重写call方法，在call方法中会执行doInBackground()方法，也就是是线程中执行的耗时操作，并调用postResult返回doInBackground的Result结果。
初始化一个FutureTask对象，FutureTask继承了Runnable和Future。所以可以执行run方法也可以通过get取回结果。重写计算结束时调用的done方法，在里面调用postResultIfNotInvoked(get())，它最后也会执行postResult方法返回结果。
postResult方法就是将当前对象和结果封装成AsyncTaskResult对象并发送给内部Handler。在Handle中就会调用onPostExecute(result)方法。
@WorkerThread
protected final void publishProgress(Progress... values) {
if (!isCancelled()) {
getHandler().obtainMessage(MESSAGE_POST_PROGRESS,
new AsyncTaskResult<Progress>(this, values)).sendToTarget();
}
}
@MainThread
protected void onProgressUpdate(Progress... values) {
}
在doInBackground()执行子线程耗时任务时，可以直接调用publishPorgress方法发送进度消息给内部Handler，Handler就是执行UI线程的onProgressUpdate方法更新进度了。
