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 在不同版本间线程池的差别，可能还有其他方面的区别，有待以后的发掘。
网友评论