AsyncTask轻量异步

什么是AsyncTask？

AsyncTask是一种轻量级的异步任务类，它可以在线程池中执行后台任务，然后把执行的进度和最终的结果传递给主线程并在主线程中更新UI。

实际来说AsyncTask其实就是封装了Thread 和Handler.

优点：

更加方便的执行后台任务

更加方便主线程访问UI

实现方式：

它主要是一个抽象泛型类，它提供了Params，Progress，Result  三个泛型参数，、

Params：表示参数类型

Progress：后台执行任务进度

Result：返回的结果

如果这三个参数不需要可以用Void代替

public abstract class AsyncTask

重要的四个核心方法

1.onPreExecute（），在主线程执行的方法，在异步任务执行之前，此方法会被调用，一般可以做一些准备工作。

2.doInBackground（Params...params），在线程池中执行，此方法用于执行执行异步任务，params参数表示异步任务要输入的参数。在此方法中可以通过publishProgress方法来更新任务进度，publishProgress方法会调用onProgressUpdate方法。另外此方法需要返回计算结果个给onPostExecute方法。

3.onProgressUpdate（Progress values），在主线程中执行，当后台任务的执行进度发生改变时此方法会被调用

4.onPostExecute（Result result），在主线程中执行，在异步任务执行之后，此方法会被调用，其中result参数是后台返回的值，也就是doInBackground的返回值。

除了上面的四个方法  AsyncTask还提供了onCancelled（）方法，同样在主线程执行，当异步任务 被取消的时候onCancelled方法会被调用，这个时候onPostExecute方法不会被调用。

AsyncTask使用过程中的限制：

1.AsyncTask的类必须在主线程中加载。

2.AsyncTask的对象必须在主线程中创建

3.execute 方法必须在UI线程调用

4.不能在程序中直接调用onPreExecute，doInBackground，onProgressUpdate，onPostExecute等方法

5.一个AsyncTask对象只能执行一次，也可以说只能调用一次execute方法，否则会报运行时异常

下面我们讲一下AsyncTask的工作原理

首先·我们从execute方法来讲

execute方法有调用了executeOnExecutor方法，实现源码如下

public final AsyncTask execute(Params... params) {  

    return executeOnExecutor(sDefaultExecutor, params);  

}  

public final AsyncTask 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;  

}  

上面的代码中sDefaultExcutor实际上是一个串行的线程池，一个进程中的所有AsyncTask全部在这个线程池中排队执行

下面就是线程池的执行顺序

public static final Executor SERIAL_EXECUTOR = new SerialExecutor();

private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;

private static class SerialExecutor implements Executor {

          final ArrayDeque mTasks = new ArrayDeque();

          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);

                     }

          }

}

SerialExecutor如何实现AsyncTask排队的呢？

首先系统会把AsyncTask中所传入的Params参数封装为FutureTask对象，FutureTask是一个并发类，它的作用相当于Runnable的作用。紧接着FutureTask会交给SerialExecutor的scheduleNext方法来执行下一个AsyncTask任务，同时当一个执行完后，会继续执行其他的，知道执行结束，所以说它是串行执行的。

---

现在再说AsyncTask的中的两个线程池和一个Handler

它主要由两个线程池（SerialExecutor与THREAD_POOL_EXECUTOR）和一个Handler（InternalHandler），其中SerialExecutor用于作任务排队，而线程池THREAD_POOL_EXECUTOR用于真正地执行任务，InternalHandler用于将执行环境拉回到主线程，其本质还是线程调用的过程，在AsyncTask的构造方法中有如下代码，由于FutureTask的run方法会调用mWorker的call方法，因此mWorker的call方法最终还是会在线程池中执行。

在mWorker的call方法中，首先将mTaskInvoked设置为true，表示当前的任务已经被调用过了，然后执行AsyncTask的doInBackground方法，接着将其返回值传递给postResult方法 具体实现如图

在上面的代码中，postResult方法会通过getHandler发送一个MESSAGE_POST_RESULT的消息，getHandler的定义 如下图

提供get方法

mHandler创建方法

给mHandler重新赋值为sHandler

sHandler创建

这时候我们会发现sHandler是一个静态的Handler对象，为了切换到主线程所以用静态，因此这就变相的要求AsyncTask的类必须在主线程加载，否则同一个进程中的AsyncTask都将无法正常工作，sHandler收到MESSAGE_POST_RESULT这个消息后会调用AsyncTask的finish方法，如图：

finish方法

finish方法逻辑非常简单 如果取消·执行就调用onCancelled(result)方法，否则就会调用onPostExecute(result)方法，这样就可以看到doInBackground的返回值传给onPostExecute方法，源码就此分析完毕。