Android AsyncTask源码分析

谢谢原作者，尊重原创作者，转载请注明出处（转载只为知识积累）：

http://blog.csdn.net/gemmem/article/details/8957111

AsyncTask是一个抽象类，我们需要继承这个类，并实现抽象方法，在这个类的实现过程中需要定义3个类和执行4个方法。3个类分别是：

1.Params：执行异步任务需要的参数

2.Progress：异步任务后台执行中需要刷新的参数

3.Result：后台任务执行完毕需要返回的结果

当一个异步的任务执行，会执行4个方法，分别是：

1.              onPreExecute()：在异步任务调用之前，由UI线程中调用。通常用于异步任务的准备工作。

2.              doinBackground(Params …)：在上一步执行完毕后立即执行。是比较耗时的一步，也是由这步传入参数Params。在这里不仅可以产生最后的结果result，而且能调用publishProgress(Progress...)刷新UI

3.              onProgressUpdate(Progress...): 在第二步中调用publishProgress()之后，UI线程则会调用此方法。举个例子，就像你先在异步的线程中传入UI线程的handler，当执行的过程中，你可以通过消息机制向主线程发送消息，来更新UI。而publishProgress就是发送消息，主线程就会调用onProgressUpdate。

4.              onPostExecute(Result): 当异步的任务执行完毕之后，由UI线程调用。在这个方法中可以得到最终的异步结果。

 本文主要讲解这4个回调函数的调用流程，

首先看构造函数：

[java]  view plain copy

1. public AsyncTask() {  
2.     mWorker = new WorkerRunnable<Params, Result>() {  
3.         public Result call() throws Exception {  
4.             mTaskInvoked.set(true);  
5.   
6.             Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);  
7.             return postResult(doInBackground(mParams));  
8.         }  
9.     };  
10.   
11.     mFuture = new FutureTask<Result>(mWorker) {  
12.         @Override  
13.         protected void done() {  
14.             try {  
15.                 final Result result = get();  
16.   
17.                 postResultIfNotInvoked(result);  
18.             } catch (InterruptedException e) {  
19.                 android.util.Log.w(LOG_TAG, e);  
20.             } catch (ExecutionException e) {  
21.                 throw new RuntimeException("An error occured while executing doInBackground()",  
22.                         e.getCause());  
23.             } catch (CancellationException e) {  
24.                 postResultIfNotInvoked(null);  
25.             } catch (Throwable t) {  
26.                 throw new RuntimeException("An error occured while executing "  
27.                         + "doInBackground()", t);  
28.             }  
29.         }  
30.     };  
31. }  

构造函数里面创建了2个对象，mWorker和mFuture。mWorker是一个Callable，mWorker实现了其call( ) 方法。

mFuture是一个FutureTask，这个FutureTask使用Callable作为构造函数的参数，并实现了done( )方法。

再来看看AsyncTask的execure(Param...)方法:

[java]  view plain copy

1. public final AsyncTask<Params, Progress, Result> execute(Params... params) {  
2.     return executeOnExecutor(sDefaultExecutor, params);  
3. }  

[java]  view plain copy

1. public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,  
2.         Params... params) {  
3.     if (mStatus != Status.PENDING) {  
4.         switch (mStatus) {  
5.             case RUNNING:  
6.                 throw new IllegalStateException("Cannot execute task:"  
7.                         + " the task is already running.");  
8.             case FINISHED:  
9.                 throw new IllegalStateException("Cannot execute task:"  
10.                         + " the task has already been executed "  
11.                         + "(a task can be executed only once)");  
12.         }  
13.     }  
14.   
15.     mStatus = Status.RUNNING;  
16.   
17.     onPreExecute();  
18.   
19.     mWorker.mParams = params;  
20.     exec.execute(mFuture);  
21.   
22.     return this;  
23. }  

现在从execute开始分析：

1、execute调用executeOnExecutor

2、executeOnExecutor调用onPreExecute

3、随后执行：exec.execute(mFuture)

4、mFuture被执行后，mWorker的call()开始执行

5、call（）里面调用doInBackground（）

6、doInBackground（）执行完成后，会执行postResultIfNotInvoked(result)，再执行postResult（）

7、postResult导致主线程执行result.mTask.finish(result.mData[0])

8、finish（）会调用onPostExecute（）

至此，4个回调方法中的3个已经讲完了。

还剩下onProgressUpdate（），其实onProgressUpdate（）的执行是被动的，所以不在上面的分析之中，它的执行需要app去调用publishProgress。

app一般会在doInBackground（）中的循环中执行publishProgress，这样就回调到onProgressUpdate，而onProgressUpdate（）一般被实现为更新UI的函数。
至此4个函数都分析到了，如果读者对Callable和FutureTask不是很理解，请阅读我的上一篇文章：Java FutureTask理解