在Android中，主线程是UI线程，当需要根据其他数据进行更新UI时，如果获取数据的操作比较耗时的话，会触发ANR，所以我们应该讲耗时的操作进行异步操作，尤其是请求网络数据的操作应该放在后台线程进行，避免ANR。
而AsyncTask是Android里很常用的异步任务请求方法，AsyncTaks基本用法都会用，网上也要好多教程,就不写例子了。
以前用的时候分析过源码，发现学问还是挺多的，今天总结一下，错误之处的请诸位指正。
分析一个AsyncTask的源码，需要了解的知识：线程池，future模式，无锁操作，handler、looper和Message之间的关系。
1.先看一下AsyncTask的基本成员们：
public abstract class AsyncTask<Params, Progress, Result> {
private static final String LOG_TAG = "AsyncTask";
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.
*/
public static final Executor THREAD_POOL_EXECUTOR
= new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,
TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);
/**
* An {@link Executor} that executes tasks one at a time in serial
* order. This serialization is global to a particular process.
*/
public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
private static final int MESSAGE_POST_RESULT = 0x1;
private static final int MESSAGE_POST_PROGRESS = 0x2;
private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
private static InternalHandler sHandler;
private final WorkerRunnable<Params, Result> mWorker;
private final FutureTask<Result> mFuture;
private volatile Status mStatus = Status.PENDING;
private final AtomicBoolean mCancelled = new AtomicBoolean();
private final AtomicBoolean mTaskInvoked = new AtomicBoolean();
//后续省略
}
首先我们看到了AsyncTask必备的3大参数Params,Progress,Result。后续我们会再见到它们。
CPU_COUNT是java虚拟机可用的处理器个数，可以通过Runtime类的availableProcessors()方法得到。
看到刚开始的几个静态常量CORE_POOL_SIZE和MAXMUM_POOL_SIZE，就知道AsyncTask实现了一个线程池的机制。
定义了一个线程工场，以便于自定义线程
任务阻塞队列是一个定义了一个大小为128的*任务队列。
ThreadPoolExecutor定义了一个线程池，核心池大小是CORE_POOL_SIZE，线程池最大容量是MAXIMUM_POOL_SIZE，多余空闲线程的存活时间是KEEP_ALIVE，单位是秒，使用一个大小为128的LinkedBlockingQueue作为任务队列，用一个无锁整型计数的线程工场产生线程。
定义了两个常量MESSAGE_POST_RESULT和MESSAGE_POST_PROGRESS，用于与主线程通信的标签，表示当获取到与主线程交互的数据类型，是进度信息还是结果信息。
定义了两个无锁布尔值作为任务激活或者取消的标志位，无锁操作即CAS，使用于并发情况下数据的更新。
然后看一下这里自定义的SeiralExcuter,实现了Executor接口，用于串行执行任务，并且设置为默认的Executor.
AsyncTask定义了两个线程池：异步线程池THREAD_POOL_EXECUTOR,同步线程池SeiralExcuter
随着Android版本的不同，AsyncTask处理任务默认是串行还是并行几经更迭，至今又改回串行，因为如果有一个UI的状态信息需要不同任务下反复更改，那么并行处理显然会出现更新顺序的问题，很麻烦，所以尽量使用串行的方法。
2.执行任务的方式。
一个自定义WorkerRunnable，实现了Callable接口
private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {
Params[] mParams;
}
再看一下AsyncTask的初始化方法：
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);
}
}
};
}
随后用这个WorkerRunnable实例构造了一个FutureTask实例，这个FutureTask则是JDK中对于future模式的一种实现。future模式是多线程开发中常用的一种设计模式，主要思想是异步调用。当Client想Server请求数据时，如果这个请求操作耗时比较长，那么Server会先立即返回一个FutureData，这个数据是一份虚拟的数据，此时Client就可以去做其他的事情了，过一段时间在调用get方法，如果这个时候Server已经准备好返回数据了，就会返回我们真正需要的数据RealData，否则Client会进入等待状态，直至返回RealData。简单的说，可以把FutureData理解成一份契约，可以用来装配RealData的契约。
这样Client就不用一直等待数据的返回，拿到FutureData后就可以先去做别的事情了，到需要的时候调用get方法获得RealData.
实现一个Callable接口，它的call方法会构造我们需要的真实数据并返回。
构造futuretask的时候，使用Callable接口，告诉futuretask我们需要的数据应该如何产生，使用future.get()来获取实际的数据。
在重复一遍，WorkerRunnable实现了Callable接口，然后用这个实例去构造一个FuntureTask实例。
当准备好future模式后，我们需要决定让任务串行执行还是并行执行，Android官方认为大多数情况下尽量选择串行执行，直接调用execute方法即默认使用SeiralExcuter。
public final AsyncTask<Params, Progress, Result> execute(Params... params) {
return executeOnExecutor(sDefaultExecutor, params);
}
如果一定要并行执行，则调用executeOnExecutor方法，并且设置Executor为前文定义的线程池THREAD_POOL_EXECTOR：
execute方法也是调用executeOnExecutor方法，只是将executor直接设置为默认的SeiralExecutor。
再强调一遍，必须在UI线程中调用执行方法。
3.执行的过程
直接看一下executeOnExector方法：
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;
}
可以看到，在执行前先检查任务状态，如果正在执行或者已经完成，则抛出异常。处于挂起状态则设置为RUNNING状态，随后执行onPreExecute方法，此方法需要重写，用于执行任务前对UI的动作。
随后将执行任务所需参数赋给我们自定义的WorkerRunnable实例mWorker构造future实例mFuture，执行futureTask，处理任务。最后返回this，是为了保持UI线程对这个AsyncTask的引用。
到这里，我们回头看一下AsyncTask初始化的方法了。 （上文已引用，此处隐藏）
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);
}
}
};
}
WorkerRunnable中的Call方法是继承自Callable的方法，这个方法会返回需要构造的实际数据。任务线程被激活后就将其优先级设置为后台线程，将我们任务需要的Param参数传递给doInBackground方法，去在后台执行耗时任务,整个耗时任务包括网络请求和信息处理的过程，在执行该方法的时候，可以激活publishProcess方法来进行主线程进度更新的显示，当处理完数据后返回Result。
在mFuture中重写了done方法，即当mFuture的mWorker处理完数据后，mFuture调用了get方法和postResultIfNotInvoked方法，get方法如下：
public final Result get(long timeout, TimeUnit unit) throws InterruptedException,
ExecutionException, TimeoutException {
return mFuture.get(timeout, unit);
}
调用future模式的get方法，获取到了我们想要的结果数据，之后通过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;
}
终于到这一步了，可以看到数据处理完毕后，我们把在FutureTask中处理后的数据最终传给了一个message，用来与UI线程进行通信，有了Message，Handler还远么？通过getHandler方法得到一个Handler,这个Handler是自定义的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;
}
}
}
private void finish(Result result) {
if (isCancelled()) {
onCancelled(result);
} else {
onPostExecute(result);
}
mStatus = Status.FINISHED;
}
此处Looper.getMainLooper () 获得UI线程的Lopper，准备更新主线程的UI啦！
根据请求的标签信息判定所需行为，当需要更新进度信息时，将数据分发给onProgressUpdate方法去主线程显示进度的更新，当需要传递结果时调用finish方法，此时如果请求已被取消则不发送，如果没被取消则发送至UI线程进行UI信息的更新。
至此，AsyncTask的基本流程就走了一遍了。
总结一下：
利用FutureTask进行异步请求，通常情况下串行处理请求，如果有并行需求则使用线程池应对并发请求，线程池的配置取决于当前虚拟机所能使用的CPU数量。
三大参数：Params任务后台执行所需的参数类型，Progress是如果需要前台进度更新的更新值类型，Result则是任务返回值的类型。
使用execute方法激发异步任务执行，在发出请求之前，使用onPreExecute可以在执行任务前对UI进行标记，随后调用了doInBackground方法，进行后台耗时任务的操作，在这个过程中可以调用publishProgress方法将信息放入message，通过InternalHandler传递，调用onProgressUpdate方法将进度更新信息发送至UI线程，展示进度情况，处理完毕后，InternalHandler将结果数据的message通过onPostExecute发送至UI线程，UI线程根据结果数据进行UI的更新。
所以，在使用AsyncTask时，我们需要重写上面标红的四个方法。最少得重写一个doInBackground方法，一般情况下还得重写一个onPostExecute方法。
这种大的流程框架已经被写好（注意executrOnExecutor方法是final的），我么只需要自己定制流程一部分具体实现的方式，也就是设计模式之中的模板方法模式。
public class MainActivity extends Activity {
private static final String TAG = "ASYNC_TASK";
private Button execute;
private Button cancel;
private ProgressBar progressBar;
private TextView textView;
private MyTask mTask;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
execute = (Button) findViewById(R.id.execute);
execute.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
//注意每次需new一个实例,新建的任务只能执行一次,否则会出现异常
mTask = new MyTask();
mTask.execute("http://www.baidu.com");
execute.setEnabled(false);
cancel.setEnabled(true);
}
});
cancel = (Button) findViewById(R.id.cancel);
cancel.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
//取消一个正在执行的任务,onCancelled方法将会被调用
mTask.cancel(true);
}
});
progressBar = (ProgressBar) findViewById(R.id.progress_bar);
textView = (TextView) findViewById(R.id.text_view);
}
private class MyTask extends AsyncTask<String, Integer, String> {
//onPreExecute方法用于在执行后台任务前做一些UI操作
@Override
protected void onPreExecute() {
Log.i(TAG, "onPreExecute() called");
textView.setText("loading...");
}
//doInBackground方法内部执行后台任务,不可在此方法内修改UI
@Override
protected String doInBackground(String... params) {
Log.i(TAG, "doInBackground(Params... params) called");
try {
HttpClient client = new DefaultHttpClient();
HttpGet get = new HttpGet(params[0]);
HttpResponse response = client.execute(get);
if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
HttpEntity entity = response.getEntity();
InputStream is = entity.getContent();
long total = entity.getContentLength();
ByteArrayOutputStream baos = new ByteArrayOutputStream();
byte[] buf = new byte[1024];
int count = 0;
int length = -1;
while ((length = is.read(buf)) != -1) {
baos.write(buf, 0, length);
count += length;
//调用publishProgress公布进度,最后onProgressUpdate方法将被执行
publishProgress((int) ((count / (float) total) * 100));
//为了演示进度,休眠500毫秒
Thread.sleep(500);
}
return new String(baos.toByteArray(), "gb2312");
}
} catch (Exception e) {
Log.e(TAG, e.getMessage());
}
return null;
}
//onProgressUpdate方法用于更新进度信息
@Override
protected void onProgressUpdate(Integer... progresses) {
Log.i(TAG, "onProgressUpdate(Progress... progresses) called");
progressBar.setProgress(progresses[0]);
textView.setText("loading..." + progresses[0] + "%");
}
//onPostExecute方法用于在执行完后台任务后更新UI,显示结果
@Override
protected void onPostExecute(String result) {
Log.i(TAG, "onPostExecute(Result result) called");
textView.setText(result);
execute.setEnabled(true);
cancel.setEnabled(false);
}
//onCancelled方法用于在取消执行中的任务时更改UI
@Override
protected void onCancelled() {
Log.i(TAG, "onCancelled() called");
textView.setText("cancelled");
progressBar.setProgress(0);
execute.setEnabled(true);
cancel.setEnabled(false);
}
}
}
源码地址：https://android.googlesource.com/platform/frameworks/base/+/refs/heads/master/core/java/android/os/AsyncTask.java