在Android中ui是非线程安全的，更新ui只能在主线程操作，所以我们平时如果遇到子线程更新UI的情况，必须要切换到主线程上之后再执行，Handler消息机制就是一种处理方案，为了更方便的处理异步任务以及更新操作，Android在很早的版本就提供了AsyncTask类供我们处理短耗时的异步任务，方便我们子线程处理耗时任务，主线程更新UI。
AsyncTask其实相当于是Handler和Thread的一个封装，下面我们来看下它的用法吧！
1.AsyncTask的基本使用
我们来看一个简单的例子：
class MyAsyncTask extends AsyncTask<String,Integer,Boolean>{
@Override
protected void onPreExecute() {
//在doInBackground之前执行
Log.e("wangkeke","----onPreExecute thread: "+ Thread.currentThread().getName());
}
@Override
protected Boolean doInBackground(String... strings) {
Log.e("wangkeke","----doInBackground thread: "+ Thread.currentThread().getName());
for (int i = 1; i <= 10; i++) {
try {
Thread.sleep(500);
//更新进度
publishProgress(i*10);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
return true;
}
@Override
protected void onProgressUpdate(Integer... values) {
Log.e("wangkeke","----onProgressUpdate当前下载进度："+values[0]+" thread: "+ Thread.currentThread().getName());
}
@Override
protected void onPostExecute(Boolean aBoolean) {
Log.e("wangkeke","----onPostExecute任务结束 result = "+aBoolean.booleanValue()+" thread: "+ Thread.currentThread().getName());
}
}
要使用AsyncTask处理异步任务必须要是继承了它的子类，我们创建了MyAsyncTask类，我们必须重写它的doInBackground方法，当然其他几个方法也很重要一般也要重写，几个关键方法的具体含义如下：
a. onPreExecute：任务开始时会先调用它，它在doInBackground之前执行，用于做一些初始化的工作，它运行在主线程。
b. doInBackground：就像它的名字那样，它用来在子线程中处理耗时操作。
c. onProgressUpdate：用来接收publishProgress()方法传递过来的进度，运行在主线程中。
d. onPostExecute：doInBackground方法执行结束后会调用它，它的参数就是doInBackground的返回值
下面我们来运行一下这个任务：
new MyAsyncTask().execute("start");
嗯，代码很简单，执行AsyncTask的execute方法就可以了，看下运行结果：
我们可以发现AsyncTask类有三个泛型参数，下面介绍一下三个参数的具体含义，AsyncTask<Params, Progress, Result>，Params参数就是execute方法里传递过来的，它的类型是不定长数组，Progress参数代表onProgressUpdate方法的参数类型，Result参数代表onPostExecute方法的参数类型，如果不需要返回类型指定Void即可。
虽然AsyncTask可以用来执行耗时操作，但是官方建议我们最好用于短操作，几秒钟之内的操作，如果是长时间运行的任务，建议使用Executor, ThreadPoolExecutor，FutureTask等。
取消AsyncTask任务：我们可以调用cancel(boolean)方法来取消任务，调用了cancel方法之后，我们可以通过判断isCancel()的返回值是否为true来判断任务取消是否成功，为了尽快取消任务，可以用它来打破for循环。
几个注意点：
1.AsyncTask的类必须在UI线程中加载（android 4.1之后会自动处理），创建和调用。
2.不要主动调用onPreExecute，onPostExecute, doInBackground, onProgressUpdate方法。
3.一个AsyncTask对象只能执行一次execute方法，否则会抛出IllegalStateException异常。
4.AsyncTask在1.6之前是串行执行的，1.6之后允许多个任务并行执行，但3.0之后再次改为串行执行任务（为避免并行执行引发的错误）。
2.AsyncTask串行和并行
测试一下AsyncTask的串行和并行，看看是不是像我们上面说的那样，写个简单的例子，每个任务睡眠2秒后打印当前时间：
class MyAsyncTask extends AsyncTask<String,Integer,String>{
@Override
protected void onPreExecute() {
}
@Override
protected String doInBackground(String... strings) {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return strings[0];
}
@Override
protected void onProgressUpdate(Integer... values) {
}
@Override
protected void onPostExecute(String taskName) {
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Log.e("wangkeke",taskName+ "任务结束 时间 = "+df.format(new Date()));
}
}
开启3个任务测试：
new MyAsyncTask().execute("one");
new MyAsyncTask().execute("two");
new MyAsyncTask().execute("three");
我是在Android 4.3系统运行的，运行结果如下，可以看到多任务是串行执行：
本来想启动个1.6-3.0的模拟器试试的，但是很遗憾，没有找到版本这么低的模拟器，因为现在Android版本普遍已经是4.0+了，这里就不测试了，感兴趣的同学可以自己尝试下。
3.AsyncTask源码分析
话不多说，从new MyAsyncTask().execute("start")开始：
@MainThread
public final AsyncTask<Params, Progress, Result> execute(Params... params) {
return executeOnExecutor(sDefaultExecutor, params);
}
把传入的params和sDefaultExecutor作为参数，调用了executeOnExecutor方法，sDefaultExecutor是什么呢：
//sDefaultExecutor的定义如下
private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
//SERIAL_EXECUTOR的定义如下，注意SerialExecutor对象，下面要用到
public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
sDefaultExecutor其实就是android中的线程池的概念，接着看executeOnExecutor方法：
@MainThread
public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,
Params... params) {
//开启的AsyncTask任务必须是处于等待执行状态的，如果已经在运行或者已经执行完成，则抛出异常信息
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)");
}
}
//开始执行把状态置为RUNNING
mStatus = Status.RUNNING;
//之前也说了，onPreExecute会先执行用于一些初始化的操作
onPreExecute();
//把参数保存在了mWorker中，mWorker是一个Callable对象
mWorker.mParams = params;
//这里调用了Executor的execute方法
exec.execute(mFuture);
return this;
}
这段代码也很简单，最后调用了Executor的execute方法，并传递了一个FutureTask，这个exec就是上面的sDefaultExecutor对象，而上面说了它其实就是SerialExecutor对象，看下SerialExecutor的execute方法：
private static class SerialExecutor implements Executor {
//队列存储每次的异步任务
final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
//当前正在执行的AsyncTask任务
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);
}
}
}
这里的r就是之前传递过来的FutureTask，看下它的定义：
mFuture = new FutureTask<Result>(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);
}
}
};
mWorker = new WorkerRunnable<Params, Result>() {
public Result call() throws Exception {
//mTaskInvoked标识任务是否被执行过，这里置为true
mTaskInvoked.set(true);
Result result = null;
try {
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
//开始调用doInBackground执行异步任务
result = doInBackground(mParams);
Binder.flushPendingCommands();
} catch (Throwable tr) {
mCancelled.set(true);
throw tr;
} finally {
postResult(result);
}
return result;
}
};
上面分析到SerialExecutor的execute方法，内部会调用r.run()，这里的r是futuretask，于是找到futuretask的run方法，发现会执行FutureTask<Result>(mWorker)构造函数中mWorker的call方法，mWorker的定义代码在上面列出来了，它调用了doInBackground方法，当futuretask的run方法执行完毕后，会回调自身的done方法。
从上面的代码可以看出done方法中调用了postResultIfNotInvoked，看下它的代码：
private void postResultIfNotInvoked(Result result) {
final boolean wasTaskInvoked = mTaskInvoked.get();
//此时wasTaskInvoked为true，WorkerRunnable中call方法置为true的
if (!wasTaskInvoked) {
//发送执行结果
postResult(result);
}
}
private Result postResult(Result result) {
//发送Handler消息
Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
new AsyncTaskResult<Result>(this, result));
message.sendToTarget();
return result;
}
Handler定义如下：
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:
// 调用自身AsyncTask的finish方法
result.mTask.finish(result.mData[0]);
break;
case MESSAGE_POST_PROGRESS:
//接收到MESSAGE_POST_PROGRESS消息，更新进度，回调onProgressUpdate方法
result.mTask.onProgressUpdate(result.mData);
break;
}
}
}
private void finish(Result result) {
//如果已经撤销调用onCancelled，否则把结果传递给onPostExecute。
if (isCancelled()) {
onCancelled(result);
} else {
onPostExecute(result);
}
mStatus = Status.FINISHED;
}
到这里已经执行完毕了，之前doInBackground没有介绍，现在来看下：
@WorkerThread
protected abstract Result doInBackground(Params... params);
它是个抽象方法，需要我们自己去实现，记得我们更新进度的时候，调用了publishProgress方法，来看下它的代码：
@WorkerThread
protected final void publishProgress(Progress... values) {
if (!isCancelled()) {
getHandler().obtainMessage(MESSAGE_POST_PROGRESS,
new AsyncTaskResult<Progress>(this, values)).sendToTarget();
}
}
超级简单，直接用Handler发送了一个MESSAGE_POST_PROGRESS的消息，并且把当前AsyncTask的实例和进度值values传递给handleMessage，handler接收到MESSAGE_POST_PROGRESS消息后开始回调onProgressUpdate：
case MESSAGE_POST_PROGRESS:
result.mTask.onProgressUpdate(result.mData);
break;
onProgressUpdate其实是个空方法，我们自己根据业务逻辑实现即可：
@SuppressWarnings({"UnusedDeclaration"})
@MainThread
protected void onProgressUpdate(Progress... values) {
}
至此，AsyncTask调用逻辑分析完成。
等等，好像有个方法我们还没说，那就是scheduleNext方法：
protected synchronized void scheduleNext() {
if ((mActive = mTasks.poll()) != null) {
THREAD_POOL_EXECUTOR.execute(mActive);
}
}
如果当前没有任务在执行，就调用scheduleNext执行下一个任务，首先通过判断mTasks.poll()方法删除队列中的第一个元素，并把其返回值(它的返回值其实就是当前要执行的task，先移除队列，再执行的意思)赋值给mActive，如果获取到的mActive != null，说明队列中有任务存在，就交由线程池ThreadPoolExecutor去执行。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;
}
4.AsyncTask如何并行执行？
从上面的分析我们知道，AsyncTask在3.0之后默认是串行的，那么如果我们需要并行执行，该怎么做呢？
其实AsyncTask提供了相关的api，上面我们执行AsyncTask是通过execute方法，它还有另外一个方法executeOnExecutor，就是用来并行执行任务的，下面我们来看下它的基本用法：
class MyAsyncTask extends AsyncTask<String,Integer,String>{
@Override
protected void onPreExecute() {
}
@Override
protected String doInBackground(String... strings) {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return strings[0];
}
@Override
protected void onProgressUpdate(Integer... values) {
}
@Override
protected void onPostExecute(String taskName) {
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Log.e("wangkeke",taskName+ "任务结束 时间 = "+df.format(new Date()));
}
}
测试的代码还是上面的代码，我们通过executeOnExecutor开启任务：
new MyAsyncTask().executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR,"one");
new MyAsyncTask().executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR,"two");
new MyAsyncTask().executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR,"three");
运行结果如下：
可以看到，确实并行执行了任务。
