AsyncTask使用
AsyncTask是一个泛型类，它提供了Params，Progress，Result三个泛型参数。Params用来指定异步任务的参数类型，Progress指定后台任务执行进度的参数类型，Result指定后台任务返回的参数类型，它有以下4个主要方法：
-
onPreExecute()主线程中执行，开始异步任务之前调用，用于准备工作 -
doInBackground(Params...params)执行在线程池中，执行异步任务的主要方法。它内部可以调用publishProgress(Progress...values)来通知onProgressUpdate更新进度，它还需要返回Result给onPostExecute(Result result)方法 -
onProgressUpdate(Progress...values)主线程中执行，主要用于更新进度 -
onPostExecute(Result result)主线程中执行，异步任务执行结束后调用
除此之外，它还提供了一个onCancelled()方法，当异步任务被取消时此方法被调用，并且onPostExecute(Result result) 不再执行。
典型的AsyncTask用法如下：
//自定义Task
class MyTask extends AsyncTask {
@Override
protected void onPreExecute() {
super.onPreExecute();
}
@Override
protected Bitmap doInBackground(String... params) {
InputStream is = null;
ByteArrayOutputStream baos = null;
byte[] data = null;
try {
HttpURLConnection connection = (HttpURLConnection)new URL(params[0]).openConnection();
is = connection.getInputStream();
int totalLength =0;
totalLength = connection.getContentLength();
baos = new ByteArrayOutputStream();
byte[] buf = new byte[128];
int length ;
int count = 0;
while ((length = is.read(buf)) != -1) {
baos.write(buf, 0, length);
count += length;
publishProgress(count * 1.0f / totalLength);
}
data = baos.toByteArray();
} catch (IOException e) {
e.printStackTrace();
}finally {
try {
baos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
Bitmap bitmap= BitmapFactory.decodeByteArray(data, 0, data.length);
//Bitmap bitmap = BitmapFactory.decodeStream(is);//返回null
Log.d("mytask", "BitMap is " + bitmap);
return bitmap;
}
@Override
protected void onProgressUpdate(Float... values) {
Log.d("mytask", "Progress is " + values[0]*100 + "%");
}
@Override
protected void onPostExecute(Bitmap bitmap) {
MyImage.setImageBitmap(bitmap);
}
}
//主线程中调用task：
new MyTask().execute("http://192.168.1.105:8080/largeicon.png");
使用AsyncTask有几点注意事项：
- Asynctask对象必须在主线程创建
- execute方法必须在主线程调用
- 不要在外部手动调用AsyncTask的四个主要内部方法
- 一个AsyncTask对象只能执行一次，否则会报错
- AsyncTask的执行除了execute之外，还有
executeOnExecutor方法
AsyncTask源码解析：
我们从execute方法作为入口，开始一步一步看一下AsyncTask是怎样工作的，execute源码如下：
public final AsyncTask execute(Params... params) {
return executeOnExecutor(sDefaultExecutor, params);
}
可以看到，调用AsyncTask的execute方法之后，除了我们传入的参数之外，它另外加了一个sDefaultExecutor，这是一个调度任务用的串行线程池，稍后会详细介绍，实际上执行的是executeOnExecutor方法，源码如下：
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;
}
首先会进入状态判断，如果任务已经在执行，或者执行过了，会抛出异常，这也就是为什么一个AsyncTask只能执行一次的原因了。
继续往下，onPreExecute() 在这里执行了，此时还没有出现与线程相关的操作，所以onPreExecute()一定是运行在主线程的。
下面的两句就是执行异步任务的核心了，首先将传入的参数赋值给了mWorker.mParams，然后调用exec.execute(mFuture)，这里的exec默认情况下是sDefaultExecutor，这里调用了它的execute方法。
上面已经提到了，sDefaultExecutor是一个执行调度任务的线程池，它指向的是AsyncTask类中的静态变量，SERIAL_EXECUTOR，也就是说，所有的AsyncTask对象，都是通过一个线程池来调度的，它就是SERIAL_EXECUTOR。
从名字就可以看出，SERIAL_EXECUTOR是串行的，源码如下：
//定义SERIAL_EXECUTOR
public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
//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 的内容，首先定义了一个队列mTasks，用来存放它接收到的任务。在execute方法中，首先在队列mTasks的尾部添加一个任务，这个任务的内容包括两个部分：
- 执行参数
Runnable对象的run方法（这里的参数是mFuture，稍后会查看run方法的内容） - 执行
scheduleNext。
注意，mTasks.offer(.....);这一步只是将任务添加到队列的尾部，实际上并未执行。
直到if (mActive == null)，执行任务之前会进行判断。如果这是AsyncTask对象的第一次执行，那么条件成立，调用scheduleNext，在这里先将mActive指向下一个任务，然后又调用了THREAD_POOL_EXECUTOR的execute方法，在这里异步任务将得到最终的执行。
注意synchronized 的存在，使得线程池只能有一个线程来执行Runnable对象，从而保证了任务会按添加顺序串行执行。
异步任务开始执行以后，由于mTasks的任务中包含了scheduleNext，所以，只要队列中还有任务，执行完一个之后会继续执行下一个，直到任务全部执行完毕。
这里我们先不分析THREAD_POOL_EXECUTOR，只需要知道，它是AsyncTask的最终执行者。再回到mTasks，可以看到执行任务时调用的是mFuture的run方法。
相关的关键代码如下：
//AsyncTask构造函数中对mWorker ，和mFuture赋值
//mWorker是一个Runnable对象，封装了doInBackground和postResult方法，等待执行。只有它内部封装的方法会在子线程执行
mWorker = new WorkerRunnable() {
public Result call() throws Exception { ---------->###1
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);//该方法通过Handler将消息发送到主线程
}
return result;
}
};
mFuture = new FutureTask(mWorker) {
@Override
protected void done() {
try {
......
};
//mFuture 对应FutureTask类，主要方法如下
//mFuture 赋值时调用此构造函数，将mWorker传递给了成员变量callable ；
public FutureTask(Callable callable) {
if (callable == null)
throw new NullPointerException();
this.callable = callable;
this.state = NEW; // ensure visibility of callable
}
//mFuture 的run方法
public void run() {
if (state != NEW ||
!U.compareAndSwapObject(this, RUNNER, null, Thread.currentThread()))
return;
try {
//取出callable，实际上就是传入的mWorker
Callable c = callable;
if (c != null && state == NEW) {
V result;
boolean ran;
try {
//执行mWorker的call方法，并返回结果，call方法在AsyncTask构造函数中对mWorker赋值时覆写，上文###1处
result = c.call();
ran = true;
} catch (Throwable ex) {
result = null;
ran = false;
setException(ex);
}
if (ran)
set(result);
}
} finally {
......
}
到这里，整个逻辑就清楚了。 AsyncTask将doInBackground方法封装到mWorker中 ，mFuture 又接管了mWorker 的执行，最后将mFuture 交给THREAD_POOL_EXECUTOR的execute方法，最后doInBackground会在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,
sPoolWorkQueue, sThreadFactory);
threadPoolExecutor.allowCoreThreadTimeOut(true);
THREAD_POOL_EXECUTOR = threadPoolExecutor;
实际上，AsyncTask中构建了一个核心线程数等于CPU核心数+1，最大线程数为CPU核心数2倍的线程池，用来执行AsyncTask任务。
通过上边的分析，我们可以看到，虽然AsyncTask任务最终是在线程池中执行的，但是由于SerialExecutor的存在，线程会被丢进队列中，从第一个开始排队执行，所以仍然是串行的。
实际上Android在这里有过几次变动，在Android1.6之前是串行的，1.6-3.0采用线程池并行处理，3.0以后又改为串行处理了，但是我们可以通过executeOnExecutor来指定AsyncTask使用线程池来并行处理：
new MyTask().executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR,"http://192.168.1.105:8080/largeicon.png");