android多线程之AsyncTask源码分析
在有关线程的操作中一定要记住两点：
1、不能在UI线程中执行耗时的操作
2、不能在非主线程中更新UI界面
一、AsyncTask简介
AsyncTask封装了线程池和Handler，是Android的一个轻量级的异步类，它可以在线程池中执行后台操作，然后把执行的进度和结果通过Handler传递给主线程并在主线程里面更新UI。可以方便开发者实现异步操作。
二、AsyncTask用法和示例
1、用法
AsyncTask是一个抽象的泛型类，提供了Params、Progress、Result三个泛型参数
public abstract class AsyncTask<Params, Progress, Result>(){}
Params:需要传入参数的类型
Progress：后台任务的执行进度的类型
Result：后台任务返回结果的类型
AsyncTask提供了4个核心的方法，分别是：
1. OnPreExecute(), 在主线程中执行，在异步任务之前，此方法被调用一般做一些准备性的工作；
2. doInBackground(Params...params),在线程池中执行，用于执行异步任务，params表示异步任务的传入参数，此方法会调用publshProgress()来更新任务进度，publshProgress()会调用onProgressupdate()，会返回计算结果给onPostExecute().
3. onProgressUpdate(Progress...value)，在主线程中执行，后台执行任务的进度有变化时被调用。
4. onPostExecute(Result result), 在主线程中执行，在异步任务执行之后，此方法会被调用，result为后台任务的返回值，即doInBackground()的返回值。
2、示例
public class DownloadFilesTask extends AsyncTask<URL, Integer, Long>{
protected Long doInBackground(URL...url){
int count = url.length;
long totalSize = 0;
for(int i = 0; i< count; i++){
totalSize += DownloadFile(url[i]);
publishProgress((int) (i/(float)count)*1000);
if(isCancelled){
break;
}
}
}
protected void onProgressUpdate(Integer...progress){
setProgressPercent(progress[0]);
}
protected void onPostExecute(Long result){
showDialog("bytes"+result);
}
}
在DownloadFileTask中，doInBackground()执行下载任务并通过publishProgress()来更新进度，同时还会调用isCancelled()判断下载任务是否被取消。下载任务完成后doInBackground()会返回结果。publishProgress()被执行了调用onProgressUpdate()方法更新进度。当下载任务完成后onPostExecute()就会被调用，在主线程中做一些改变。
三、AsyncTask的限制
1. AsyncTask的类必须在主线程里加载；
2. AsyncTask的对象必须在主线程中调用；
3. execute方法必须在UI线程调用；
4. 不要在程序中直接调用onPreExecute()、onPostExecute()、doInBackground()、和onProgressUpdate()；
5. 一个AsyncTask对象只能执行一次，即只能调用一次execute(),否则会报运行时异常；
三、AsyncTask工作原理
列表内容分析AsyncTask原理，先从execute()开始，execute()调用了executor(),源码实现如下：
public final AsyncTask<Params, Progress, Result> execute(Params...params){
return executeOnExecutor(sDefaultExecutor params);
}
public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executorexec, 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 is already finishing.")
}
}
mStatus = Status.RUNNING;
onPreExecute();
mWorker.mParams = params;
exec.execute(mFuture);
return this;
}
sDefaultExecutor实际上是一个串行的线程池，一个进程的所有的线程都在这个串行的线程池里面排队，在executor()方法中， AsyncTask的onProExecute() 最先执行，然后线程池开始执行。
public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
private static volatile Executor sDefaultExecutor = SERIAL＿EXECUTOR;
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);
}
}
}
系统把AsyncTask的Params参数封装为FutureTask对象，Future是一个并发类，充当Runnable的作用，接着这个FutureTask会交给SerialExecutor的execute方法去处理，SerialExecutor的execute方法会把FutureTask插入到mTask任务队列中，如果没有正在执行的任务，那么就会调用SerialExecutor的scheduleNext方法来执行下一个AsyncTask任务，同时当一个任务执行完后，AsyncTask会继续调用其他任务直到所有任务都被执行完。
AsyncTask有两个线程池，SerialExecutor 和THREAD_POOL_EXECUTOR和一个Handler(InternalHandler)，SerialExecutor用于任务的排队，而THREAD_POOL_EXECUTOR用于真正的执行任务，而InternalHandler用于将执行环境从线程池切换到主线程。
mWorker = new WorkerRunnable<Params, Result>(){
public Result call() throws Exception{
mTaskInvoked.set(true);
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
return postResult(donInBackground(mParams));
}
};
在mWorker的call方法中将mTaskInvoked设为true，表示当前任务已经被调用了，然后执行doInBackground方法，接着返回值传递给postResult方法。
private Result postResult (Result result){
Message message = sHandler.obtainMessage(MESSAGE_POST_RESULT, new AsyncTaskResult<Result>(this, result));
message.sendToTarget();
return result;
}
postResult方法会通过sHandler发送一个MESSAGE_POST_RESULT的消息，这个sHandler的定义如下：
private static final InternalHandler sHandler = new InternalHandler();
private static class InternalHandler extends Handler{
public void handleMessage(Message msg){
AsyncTaskResult result = (AsyncTaskResult)msg.obj;
switch(msg.what){
case MESSAGE_POST_RESULT:
result.mTask.finish(result.mData[0]);
break;
case MESSAGE_POST_PROGRESS:
result.mTask.onProgressUpdate(result.mData);
break;
}
}
}
sHandler是一个静态的Handler对象，为了能够将执行环境切换到主线程，这就要求sHandler必须是在主线程中创建。由于静态成员在加载类的时候进行初始化，这就要求AsyncTask的类必须在主线程中加载。sHandler收到MESSAGE_POST_RESULT这个消息后会调用AsyncTask的finish方法。
private void finish(Result result){
if(isCancelled()){
onCancelled(result);
} else {
onPostExecute(result);
}
mStatus = Status.FINISHED;
}
如果AsyncTask被取消执行了，那么就会调用onCanedlled方法，否则就会调用onPostExecute方法，doInBackground的返回结果传递给onPostExecute方法。到这里AsyncTask的整个工作过程就分析完毕了。
