AsyncTask官方介绍与说明

Android主线程中无法执行耗时操作，这要求开发者在自定义的工作线程中完成耗时操作，再通过Handler进行线程间的交互，达到不阻塞主线程同时又完成操作的目的。Android官方提供了AsyncTask异步处理任务类，来良好的解决了复杂的多线程处理交互问题，同时还有IntentService，HandlerThread都是很好的解决方案。
AsyncTask通过线程池技术，对多个子线程进行统一管理，可以自动完成后台操作与发布结果至UI线程等操作。

官方建议：AsyncTask理想上适用于简短的一些耗时操作，如果耗时操作需要大量的时间，则非常建议使用 java.util.concurrent 包中提供的API封装多线程操作，例如Executor,ThreadPoolExecutor, FutureTask，AsyncTask也是使用concurrent包中API进行的进一步封装。（文章末尾分析）
异步任务主要由三种泛型类型（Params，Progress，Result）及四个步骤：onPreExecute，doInBackground， onProgressUpdate，onPostExecute所构成。

• Params：也就是在执行异步操作前传入参数的类型；
• Progress：定义在异步任务过程中，向UI线程发送的当前进度的类型如int；
• Result：在异步任务结束后，传递该类型的执行结果给
  onPostExecute，也就是传递给UI线程；

当然上面的几种类型也不是强制性需要定义的，当不需要时，可以使用以下定义方式定义上述类型：

    private class MyTask extends AsyncTask<Void, Void, Void> { ... }

AsyncTask为抽象类，实例化过程中需要重新其抽象方法，来自定义一些相关操作。

• onPreExecute()：主要用来初始化相关任务所需参数，执行于异步任务开始前，且处于UI线程中。
• doInBackground(Params...)：在onPreExecute执行完毕后执行，运行于工作线程中，可执行长时间的耗时操作。
• onProgressUpdate(Progress...)：当在doInBackground中调用了publishProgress(Progress...）：方法后（比如循环语句中），就会立即调用该方法，用于向主线程发送当前执行进度信息，且该方法执行于UI操作中，所以可以直接将Progress设置到UI控件上。
• onPostExecute(Result) ：异步任务（doInBackground）执行完毕后调用，会接收doInBackground return的参数，处理执行结果，且执行于UI线程中。

取消当前的任务

AsyncTask良好的封装使得任何时候通过主动调用cancel(boolean)方法即可终止当前异步任务（当然需要在doInBackground做处理），在调用之后，通过isCancelled()会返回ture。当然，当取消成功后，doInBackground()方法也就执行完毕，但下一个不会走onPostExecute()方法，而是onCancelled(Object)，这里可以选择性的重写该方法实现取消后的逻辑。
为了保证可以迅速的终止任务，应该在doInBackground循环体中不断调用isCancelled()来判断是否主动要求了停止继续执行。
cancel(boolean)传入的boolean参数有何用，该传什么？源码中分析。

使用中的注意

• AsyncTask类必须在主线程中加载，(也就是第一次访问AsyncTask必须发生在主线程)，Android4.1及以上版本已经被系统自动完成，Android5.0源码中，在app入口函数AcitivityThread的main方法中，会调用AsyncTask的init方法，也就完成了AsyncTask的类必须在主线程加载。
• AsyncTask实例必须在主线程上创建；

• execute(Params...) 启动异步任务方法必须执行于主线程；

• 不可手动调用onPreExecute，doInBackground，onProgressUpdate，onPostExecute等方法。

• 一个异步任务只可被执行一次，多次执行将会抛异常。

多个异步任务池的管理

在android1.6之前，AsyncTask是串行执行任务，1.6开始采用线程池来处理并发任务，之后3.0开始，为了避免AsyncTask的并发错误，AsyncTask又默认采用了一个线程来串行执行任务，但3.0之后的版本我们仍可以通过AsyncTask的executeOnExecutor方法来并行执行任务。

工作原理

AsyncTask的工作过程结合源码可由下面流程图概括：

AsyncTask.png

其中的核心为FutureTask与ThreadPool

FutureTask

FutureTask可用于异步获取执行结果或取消执行任务的场景。通过传入Runnable或者Callable的任务给FutureTask，直接调用其run方法或者放入线程池执行，之后可以在外部通过FutureTask的get方法异步获取执行结果，因此，FutureTask非常适合用于耗时的计算，主线程可以在完成自己的任务后，再去获取结果。另外，FutureTask还可以确保即使调用了多次run方法，它都只会执行一次Runnable或者Callable任务，或者通过cancel取消FutureTask的执行等。

ThreadPool

前面已经介绍过，在Android3.1之后，AsyncTask默认采用了串行执行的线程池，也就是任务必须一个完成了才能继续下一个，具体是如何实现的呢。

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

执行executeOnExecutor时，传入的默认Executor是sDefaultExecutor，也就是上面的SerialExecutor，这个也是一个Executor类型，它只不过是负责管理Runnable任务的，通过ArrayDeque队列，串行的存入Runnable，并串行的取出Runnable，交给THREAD_POOL_EXECUTOR去execute。

THREAD_POOL_EXECUTOR 也就是真正的线程池实现了:

   private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
    // We want at least 2 threads and at most 4 threads in the core pool,
    // preferring to have 1 less than the CPU count to avoid saturating
    // the CPU with background work
    private static final int CORE_POOL_SIZE = Math.max(2, Math.min(CPU_COUNT - 1, 4));
    private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;
    private static final int KEEP_ALIVE_SECONDS = 30;
    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;

    static {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE_SECONDS, TimeUnit.SECONDS,
                sPoolWorkQueue, sThreadFactory);
        threadPoolExecutor.allowCoreThreadTimeOut(true);
        THREAD_POOL_EXECUTOR = threadPoolExecutor;
    }

AsyncTask类维护一个THREAD_POOL_EXECUTOR静态实例，所有的AsyncTask对象都交由它来执行。
开发过程中很多情况都需要并行执行，AsyncTask也可以并行执行，只要在executeOnExecutor中传入自定义的THREAD_POOL_EXECUTOR即可。

为什么官方建议AsyncTask适用于简短的一些耗时操作？

原因主要有两点
1.AsyncTask无法绑定Activity生命周期，如果正在执行的AsyncTask所在的Activity因为某些原因重新被初始化了，AsyncTask还是会继续执行，执行完毕调用onPostExecute更新UI，引发错误。

2.一般AsyncTask都是以inner class的形式存在于Activity中，无形中就持有了外部类Activity的对象实例，长时间导致Activity无法回收，Android系统也无法释放其占用的资源，导致内存泄漏。

参考：

• http://blog.csdn.net/linchunquan/article/details/22382487
• http://blog.csdn.net/wqy19920429/article/details/41447367?ref=myread
• https://stackoverflow.com/questions/12797550/android-asynctask-for-long-running-operations