AsyncTask 是 Android 中一个异步处理的框架，它内部集成了线程池和 Handler 机制，实现了异步任务加载和主线程更新 UI 的功能，不过在 Android 中不同的版本的 AsyncTask 却有点不一样，下面就看看不同版本间内部的线程池有什么区别。

1、不同版本 AsyncTask 的获取

http://grepcode.com/

** 源码地址 **
AsyncTask 2.3.7
AsyncTask 4.0.1
AsyncTask 4.0.4

2、线程池的几个属性的说明

在分析版本区别之前我们先来了解以下关于线程池 ThreadPoolExecutor 的几个属性的概念：

• corePoolSize 线程池中核心线程的数量，当有新的任务到来时，若当前线程池的线程数量小于 corePoolSize ，那么就直接创建一个新的线程取执行。

• maximumPoolSize 线程池中能够运行的最大线程的数量，若一个新的任务到来，此时线程池中线程的数量超过了 corePoolSize ，但没有超过 maximumPoolSize时，这时会判断阻塞队列 workQueue 是否还有多余的空间来存储该任务，如果有多余空间，则会往队列中添加，否则就会创建非核心线程去执行这个任务（前提是当前创建的非核心线程与核心线程的数量之和不会超过 maximumPoolSize）。

• keepAliveTime 执行完任务的线程最长的等待时间，若这个时间段内，没有其他任务交给此线程执行，当前线程就会被终止。

• unit keepAliveTime 的单位，有毫秒，秒，分等；

• workQueue 阻塞队列，当有新的任务到来时，若当前线程池的线程数量大于 corePoolSize 并小于 maximumPoolSize 的话，那么就将该任务添加到 workQueue 中。

• threadFactory 创建线程的工厂。

• handler 当有一个新的任务到来时，发现阻塞队列已经满了，并且当前池中的线程数量超过了 maximumPoolSize 时，那么就会采取一定的策略 RejectedExecutionHandler 去拒绝这个任务。

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {

3、Android3.0以下版本

在 Android3.0 以下的版本中，AsyncTask 默认就支持并发执行任务的，它对内部的线程池 sExecutor 配置如下：

3.1、线程池

• 核心线程数为 5 个；
• 最大线程数为 128 个；
• 阻塞队列为 LinkedBlockingQueue 容量为 128 ；
• sExecutor 就是默认的线程池

//核心线程数
private static final int CORE_POOL_SIZE = 5;
//最大线程数
private static final int MAXIMUM_POOL_SIZE = 128;
//等待时间
private static final int KEEP_ALIVE = 1;
//阻塞队列
private static final BlockingQueue<Runnable> sWorkQueue =
        new LinkedBlockingQueue<Runnable>(10);
//线程工厂
private static final ThreadFactory sThreadFactory = new ThreadFactory() {
    private final AtomicInteger mCount = new AtomicInteger(1);
    public Thread More ...newThread(Runnable r) {
        return new Thread(r, "AsyncTask #" + mCount.getAndIncrement());
    }
};
//线程池
private static final ThreadPoolExecutor sExecutor = new ThreadPoolExecutor(CORE_POOL_SIZE,
        MAXIMUM_POOL_SIZE, KEEP_ALIVE, TimeUnit.SECONDS, sWorkQueue, sThreadFactory);

3.2、execute方法

在 execute 方法可以看到，内部会将任务直接交给 sExecutor 去执行的，因此在 Android 3.0 以下的版本是默认就支持并发执行的。

public final AsyncTask<Params, Progress, Result> More ...execute(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;
    //将任务直接交给 sExecutor 线程池去执行。
    sExecutor.execute(mFuture);
    return this;
}

4、Android3.0 ~4.4版本

4.1、线程池

• 核心线程数为 5 个；
• 最大线程数为 128 个；
• 阻塞队列为 LinkedBlockingQueue 容量为 10 ；(变化之处)

private static final int CORE_POOL_SIZE = 5;
private static final int MAXIMUM_POOL_SIZE = 128;
private static final int KEEP_ALIVE = 1;
private static final BlockingQueue<Runnable> sPoolWorkQueue =
           new LinkedBlockingQueue<Runnable>(10);

public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
//默认的线程池
private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
//自定义了一个线程池 THREAD_POOL_EXECUTOR(变化之处)
public static final Executor THREAD_POOL_EXECUTOR= new ThreadPoolExecutor(CORE_POOL_SIZE, 
MAXIMUM_POOL_SIZE, KEEP_ALIVE, 
TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);

4.2、默认的线程池 SerialExecutor

SerialExecutor是什么？

顾名思义，它是一个串行执行的线程池，所有的任务都会一个一个按顺序执行，可以任务是同步执行的效果，它是一个高版本的 AsyncTask 的默认线程池，因此默认是不支持并发执行的。

SerialExecutor的工作原理是怎样的？

内部维护了一个 ArrayDeque 的队列，它是一个无限制大小的队列。
它内部会将即将要执行的任务添加到 mTasks 中，然后去调用 scheduleNext 方法，而这个方法实际是调用了 THREAD_POOL_EXECUTOR.execute 方法

SerialExecutor在执行完一个任务之后，怎么去执行下一个任务的？

当任务执行完毕之后在 finally 中再次调用 scheduleNext 方法去执行下一个任务，这样就相当于一个顺序执行的线程池，此时的 AsyncTask 默认情况下是不支持并发执行的。

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 More ...run() {
                try {
                    r.run();
                } finally {
                    scheduleNext();
                }
            }
        });
        if (mActive == null) {
            scheduleNext();
        }
    }

    protected synchronized void scheduleNext() {
        //取出一个任务
        if ((mActive = mTasks.poll()) != null) {
            //最终将任务交给 THREAD_POOL_EXECUTOR 线程池去执行。
            THREAD_POOL_EXECUTOR.execute(mActive);
        }
    }
}

4.3、3.0以上版本的 execute 方法

它内部会去将 sDefaultExecutor(就是上面所说的默认的线程池 SerialExecutor ) 传入给 executeOnExecutor 方法，该方法会将该任务直接交给 sDefaultExecutor 线程池去执行的，这里就说明了默认情况下是不支持并发的，而是串行执行的。
executeOnExecutor 方法会在下面分析。

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

4.4、修改默认的线程池

为什么Google要提供修改线程池的API？

因为在 3.0 之后 AsyncTask 默认是串行执行任务的，为了提供并发执行的功能，因此提供了 executeOnExecutor 方法让调用者可以自己去配置对一个的线程池。

高版本实现并发执行

使用 executeOnExecutor 方法代替 execute 方法，参数1表示调用者提供的线程池，参数2跟 execute 方法的参数是一样的，表示异步执行需要的参数。

public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,Params... params)

从下面的代码可以看到，它是直接将 mFuture 交给传入的线程池 exec 去执行的。

public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,
        Params... params) {
    ...
    mStatus = Status.RUNNING;
    onPreExecute();
    mWorker.mParams = params;
    //将任务交给调用者提供的线程池去执行。
    exec.execute(mFuture);
    return this;
}

4.5、示例代码

在下面的示例代码中可以看到，所有的创建的异步任务 MyAsyncTask 都共享一个线程池 AsyncTask.THREAD_POOL_EXECUTOR ，这样就可以实现并发操作了。

for (int i = 0; i < 10; i++) {
   new MyAsyncTask().executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, "task:" + i);
}


public class MyAsyncTask extends AsyncTask<String, Void, String> {
    @Override
    protected String doInBackground(String[] params) {
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return params[0];
    }
    @Override
    protected void onPostExecute(String s) {
        super.onPostExecute(s);
        Log.e("zeal", s + "#onPostExecute");
    }
}

5、Android4.4 及之后的版本

可以在 Android4.4 之后线程池的配置上又发生了一些改变，但是核心操作思想跟上面的是一样的。

private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();//虚拟机的处理数
private static final int CORE_POOL_SIZE = CPU_COUNT + 1;
private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;
private static final int KEEP_ALIVE = 1;
private static final BlockingQueue<Runnable> sPoolWorkQueue =new LinkedBlockingQueue<Runnable>(128);

好了，以上就是我所知道的 AsyncTask 在不同版本间线程池的差别，可能还有其他方面的区别，有待以后的发掘。