八、AsyncTask解析

如果在一个进程中，频繁创建和销毁线程，显然不是高效的做法。正确的做法是采用线程池，一个线程池中会缓存一定数量的线程，通过线程池可以避免因为频繁创建和销毁线程所带来的消耗。

1.AsyncTask简介

Asynctask是一个抽象类，它是Android封装的一个轻量级异步类（轻量级体现在使用方便，代码简洁）,它可以在线程池中执行后台任务，然后把执行的进度和最终的结果呈现给主线程，并且更新UI。
Asynctask内部封装了两个线程池（SerialExecutor和THREAD_POOL_EXECUTOR），和一个Handler（IntentHandler）。

SerialExecutor线程池用于任务的排队，让需要执行的多个耗时任务按顺序排列。

THREAD_POOL_EXECUTOR线程池才真正执行任务。

IntentHandler用于从工作线程切换到主线程

1.1 AsyncTask的泛型参数

AsyncTask的类型声明：

public abstract class AsyncTask {}

AsyncTask是一个抽象的泛型类。

Params： 开始异步任务执行时传入的参数类型。
Progress：异步任务执行过程中，返回下载进度值的类型。
Result： 异步任务执行完成，返回的结果类型。
如果AsyncTask确定不需要传递具体参数，那么这三个泛型参数可以用Void来代替。

1.2 AsyncTask的核心方法

onPreExecute()（主线程中执行）：这个方法会在后台任务开始执行前调用，在主线程执行。用于进行一些界面上的初始化操作，比如显示一个对话框列表什么的。
doInBackground(Params...)（子线程中执行）： 这个方法在子线程中执行，负责处理耗时操作。
任务一旦完成就可以通过return语句来将任务的执行结果进行返回，如果AsyncTask的第三个参数指定的是Void，就可以不返回执行结果。如果要更新UI，可以通过调用publishProgress(Progess...)方法来完成比如反馈当前的进度。
onProgressUpdate(Progress...)(主线程中执行)：当在后台进程中调用publishProgress（Progress...）方法后，这个方法就会被调用，方法中携带的参数就是后台任务中传递过来的。在这个方法中可以对UI进行更新操作。
onPostExecute(Result)（主线程中执行）：当doInBackground(Params...)执行完毕并通过return语句进行返回时，这个方法就很快会被调用。返回的数据会作为参数传递到这个方法里面。利用参数的数据，就可以进行UI的修改。

上面几个方法的调用顺序：onPreExcute() --> doInBackground() --> publishProgress() --> onProgressUpdate() --> onPostExcute()
如果不需要执行更新UI操作，顺序是：onPreExcute() --> doInBackground() --> onPostExcute()。

onCancelled()（主线程中执行）：该方法被调用，onPostExecute()方法将不会被执行，需要注意的是，AsncTask中的cancel()不是真正的取消任务，只是将任务标记为取消状态，我们需要在doInBackground()内判断终止任务。就好比想要终止一个线程，调用interrupt()方法，只是进行标记为中断，需要在线程内部进行标记判断，然后中断线程。

1.3 AsyncTask的简单使用

public class DownloadTask extends AsyncTask {
    @Override
    protected void onPreExecute() {
        progressDialog.show();
    }
    @Override
    protected Boolean doInBackground(Void... voids) {
        try {
            while (true) {
                int downloadPercent = doDownload();
                publishProgress(downloadPercent);
                if (downloadPercent >= 100) {
                    break;
                }
            }
        } catch (Exception e) {
            return false;
        }
        return true;
    }
    @Override
    protected void onProgressUpdate(Integer... values) {
        progressDialog.setMessage("当前下载进度： " + values[0] + "%");
    }
    @Override
    protected void onPostExecute(Boolean result) {
        progressDialog.dismiss();
        if (result) {
            Toast.makeText(context, "下载成功", Toast.LENGTH_SHORT).show();
        } else {
            Toast.makeText(context, "下载失败", Toast.LENGTH_SHORT).show();
        }
    }
}

这里模拟了一个下载任务，在doInBackground方法中，去执行具体的下载逻辑，在onProgressUpdate()方法中显示下载的进度。在onPostExecute()方法中提示下载任务的结果。
调用方法：

  new DownloadTask().execute();

1.4 使用AsyncTask的注意事项

1. 异步任务的实例必须在UI线程中创建，即AsynacTask对象必须在UI线程中创建。
1. execute(Params... params)必须在UI线程中调用。
1. 不要手动调用onPreExecute(),doInBackground(),onProgressUpdate(),onPostExecute()这几个方法。
1. 不能在doInBackground()中更改UI组件的信息。
1. 一个任务实例只能执行一次，如果执行第二次会抛出异常。

2.AsyncTask的源码分析

AsyncTask的构造函数：

 public AsyncTask() {   this((Looper) null);    }

 public AsyncTask(@Nullable Looper callbackLooper) {
        mHandler = callbackLooper == null || callbackLooper == Looper.getMainLooper()
            ? getMainHandler()
            : new Handler(callbackLooper);

        mWorker = new WorkerRunnable() {
            public Result call() throws Exception {
                mTaskInvoked.set(true);
                Result result = null;
                try {
                    Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
                    result = doInBackground(mParams);
                    Binder.flushPendingCommands();
                } catch (Throwable tr) {
                    mCancelled.set(true);
                    throw tr;
                } finally {
                    postResult(result);
                }
                return result;
            }
        };

        mFuture = new FutureTask(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);
                }
            }
        };
    }

在构造函数中，主要是初始化了3个成员变量， mHandler,mWorker,mFuture。并在初始化mFutrue的时候，mWorker作为参数传入。 mWorker是一个Callable对象，mFuture是以一个FutureTask对象。FutureTask实现了Runnable接口。
mWorker中的call()方法执行了耗时操作，即result = doInBackground(mParams);，然后把得到的结果通过postResult(result);传递给内部的Handler跳转到主线程中。这里实际是在实例化变量，并没有开启执行任务。
postResult()方法源码：

private Result postResult(Result result) {
       @SuppressWarnings("unchecked")
       Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
               new AsyncTaskResult(this, result));
       message.sendToTarget();
       return result;
   }

mFuture对象被加载线程池中，并加载的过程。
new DownloadTask().execute();其中execute()就是执行了这一操作。
execute()源码：

public final AsyncTask execute(Params... params) {
        return executeOnExecutor(sDefaultExecutor, params);
    }

    @MainThread
    public final AsyncTask executeOnExecutor(Executor exec,
            Params... params) {
        mStatus = Status.RUNNING;
        onPreExecute();
        mWorker.mParams = params;
        exec.execute(mFuture);
        return this;
    }

可以看出，execute()方法，实际上是执行了executeOnExecutor()方法，先执行了onPreExecute()，然后具体执行耗时任务是 exec.execute(mFuture);。对象exec是sDefaultExecutor，往上追溯就是SerialExecutor的实例化对象。

    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对象共有的SerialExecutor，内部维护了一个队列，通过锁使得保证AsyncTask中的任务是串行执行的，即多个任务需要一个个加到该队列中。
这个方法中主要有两个步骤。

1. 向队列中加入一个新的任务，即之前实例化的mFuture对象。
2.调用scheduleNext()，调用THREAD_POOL_EXECUTOR执行队列头部任务。
由此可以知道SerialExecutor仅仅是为了保持任务执行队列是串行的实际执行交给了THREAD_POOL_EXECUTOR。

THREAD_POOL_EXECUTOR源码：

 public static final Executor THREAD_POOL_EXECUTOR;

    static {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE_SECONDS, TimeUnit.SECONDS,
                new SynchronousQueue(), sThreadFactory);
        threadPoolExecutor.setRejectedExecutionHandler(sRunOnSerialPolicy);
        THREAD_POOL_EXECUTOR = threadPoolExecutor;
    }

实际上就是个线程池，开启了一定数量的核心线程和工作线程。然后调用线程池的execute()方法，执行具体的耗时任务，即开头构造函数mWorker中的call()方法。先执行doInBackground()方法，然后再执行postResult()方法。

在postResult()方法中，向在AsyncTask构造函数中初始化的mHandler发送了一个消息。
在构造函数中通过调用getMainHandler(),实例化mHandler的源码：

   private static Handler getMainHandler() {
        synchronized (AsyncTask.class) {
            if (sHandler == null) {
                sHandler = new InternalHandler(Looper.getMainLooper());
            }
            return sHandler;
        }
    }

private static class InternalHandler extends Handler {
        public InternalHandler(Looper looper) {
            super(looper);
        }
        @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;
            }
        }
    }

在InternalHandler中，

如果收到的消息是MESSAGE_POST_PROGRESS，回调onProgressUpdate()方法，更新进度。
如果收到的消息是MESSAGE_POST_RESULT，即执行完了doInBackground()方法并传递结果，那就调用AsyncTask.finish()方法。

   private void finish(Result result) {
        if (isCancelled()) {
            onCancelled(result);
        } else {
            onPostExecute(result);
        }
        mStatus = Status.FINISHED;
    }

如果任务已经取消了，就回调onCancelled()方法，否则就回调onPostExecute()方法。

InternalHandler是一个静态类，为了能够将执行环境切换到主线程，因此这个类必须在主线程中进行加载。所以变相要求AsyncTask的类必须在主线程中进行加载。到此为止，从任务执行的开始到结束都从源码分析完了。

AsyncTask的串行和并行:
默认情况下因为有SerialExecutor类来维持保证队列的串行。如果想要使用并行执行任务，那么可以直接跳过SerialExecutor类，使用executeOnExecutor()来执行任务。

3. AsyncTask使用不当的后果

1）生命周期
AsyncTask不与任何组件绑定生命周期，所以在Activity或Fragment中创建执行AsyncTask时候，最好在Activity/Fragment的onDestroy()方法中调用cancle(boolean)方法。
2）内存泄漏
如果AsyncTask被声明为Activity的非静态的内部类，那么AsyncTask会保留一个对创建了AsyncTask的Activity引用。如果Activity已经被销毁，AsyncTask的后台线程还在执行，它将继续在内存中保存这个引用，导致Activity无法被回收，导致内存泄漏。
3）结构丢失
屏幕旋转或者Activity在后台被系统杀死等情况会导致Activity的重新创建，之前运行的AsyncTask（非内部静态类）会持有之前的Activity的引用，这个引用已经无效，这时调用onPostExecute()再去更新界面将不会再生效。