AsyncTask的使用
public abstract class AsyncTask<Params,Progress,Result>
Progress:异步任务执行过程中,返回下载进度值的类型,即在doInBackground中调用publishProgress()时传入的参数类型;
Result:异步任务执行完成后,返回的结果类型,即doInBackground()方法的返回值类型;
有了这三个参数类型之后,也就控制了这个AsyncTask子类各个阶段的返回类型,如果有不同业务,我们就需要再另写一个AsyncTask
class MAsyncTask extends AsyncTask<Void, Integer, String>{
private ProgressBar mProgressBar;
private TextView mTextView;
public MAsyncTask(ProgressBar mProgressBar, TextView mTextView) {
this.mProgressBar = mProgressBar;
this.mTextView = mTextView;
}
@Override
protected void onPreExecute() {
mTextView.setText("开始执行");
super.onPreExecute();
}
@Override
protected String doInBackground(Void... params) {
for(int i = 0; i <= 100; i++){
publishProgress(i);//此行代码对应下面onProgressUpdate方法
try {
Thread.sleep(100);//耗时操作,如网络请求
} catch (InterruptedException e) {
e.printStackTrace();
}
}
return "执行完毕";
}
@Override
protected void onProgressUpdate(Integer... values) {
mProgressBar.setProgress(values[0]);
super.onProgressUpdate(values);
}
@Override
protected void onPostExecute(String s) {
mTextView.setText(s);
super.onPostExecute(s);
}
}
AsyncTask提供了4个核心回调方法,含义如下所示:
(1)onPreExecute() 主线程执行,异步方法执行前调用。
(2)doInBackground(Params...params) 线程池中执行,用于执行异步任务;在方法内部用publishProgress 来更新任务进度。
(3)onProgressUpdate(Progress...value)主线程执行,后台任务进度状态改变时被调用。
(4)onPostExecute(Result result) 主线程执行,异步任务执行之后被调用,其中result参数是后台任务的返回值,即doInBackground的返回值。
AsyncTask对线程和handler进行了封装,那它的封装性体现在哪里呢?其实,AsyncTask的几个回调方法正是这种封装性的体现,使得我们感觉在子线程进行UI更新一样。
执行顺序: onPreExecute->doInBackground->onPostExecute 如果需要取消异步任务,只需调用cancel()方法,该方法会将asynctask类的
mCancelled属性置为true,onPostExecute则不会被调用
然后在主线程中直接调用AsyncTask开启任务线程。
MAsyncTask asyncTask = new MAsyncTask(mTestPB, mTestTV);
asyncTask.execute();//开始执行
AsyncTask内部实现原理
AsyncTask内部封装了异步任务队列和Handler,下面来分别介绍
1 AsyncTask的内部异步队列
AsyncTask的内部是基于工作队列这种方式的,每次执行execute()就会把当前的任务加入到工作队列中。并且,AsyncTask内部的线程池、工作队列的定义都是static的,而static定义的变量是属于进程范围内的。只有这样,这些static的变量才能交给AsyncTask这个类来管理,而不是AsyncTask的具体子类对象。
//真正用来执行任务的线程池
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;
}
//定义一个线程池,在线程池中有一个Runnable任务队列,用来存放、顺序执行任务
public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
//默认使用的线程池
private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
//自定义的一个Handler
private static InternalHandler sHandler;
可以看到,与线程池有关的都定义为了static类型,其中,SERIAL_EXECUTOR内部就定义了一个任务队列ArrayDeque,当我们调用AsyncTask的execute()时,就会将当前任务加入到该队列中。先来看执行AsyncTask的execute()时的情景:
public final AsyncTask<Params, Progress, Result> execute(Params... params) {
return executeOnExecutor(sDefaultExecutor, params);
}
AsyncTask的execute()交给了executeOnExecutor()方法,将将默认的线程池作为参数传进来,进入executeOnExecutor方法中:
public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,
Params... params) {
if (mStatus != Status.PENDING) {//1、这里判断当前AsyncTask是否正在执行或已执行完毕
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;//2、设置正在执行的状态
onPreExecute();//3、回调onPreExecute()方法
mWorker.mParams = params;
exec.execute(mFuture);//4、放到前面默认构造的线程池中去执行
return this;
}
上面第一步,先判断当前AsyncTask是否正在运行或已经执行完毕,如果正在执行或执行完毕再次执行将抛出异常,这也正是我们前面在使用的时候谈到,同一个AsyncTask不能多次进行execute()的原因!到了第三步的时候,先去调用一下onPreExecute()方法,因为executeOnExecutor方法本身就是在UI线程中运行的,所以onPreExecute也会在UI线程中运行。第四步,才会开始讲当前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 run() {
try {
r.run();
} finally {
scheduleNext();
}
}
});
if (mActive == null) {
scheduleNext();
}
}
protected synchronized void scheduleNext() {
if ((mActive = mTasks.poll()) != null) {
THREAD_POOL_EXECUTOR.execute(mActive);
}
}
}
在第四步执行execute时,实际就是调用的SerialExecutor中的execute方法,在这里面,先创建了一个Runnable对象,然后将这个Runnable对象添加到任务队列mTasks中,在当执行到这个Runnable时调用scheduleNext去队列中取出一个任务,然后交给另一个线程池去真正执行这个任务。
2 与UI线程进行交互-handler
AsyncTask内部通过自定义的static类型的InternalHandler和UI线程进行交互。InternalHandler实现如下:
private static class InternalHandler extends Handler {
public InternalHandler() {
super(Looper.getMainLooper());
}
@SuppressWarnings({"unchecked", "RawUseOfParameterizedType"})
@Override
public void handleMessage(Message msg) {
AsyncTaskResult<?> result = (AsyncTaskResult<?>) msg.obj;
switch (msg.what) {
case MESSAGE_POST_RESULT:
// There is only one result
result.mTask.finish(result.mData[0]);
break;
case MESSAGE_POST_PROGRESS:
result.mTask.onProgressUpdate(result.mData);
break;
}
}
}
每当收到子线程发来的和UI线程进行通信的handler请求时,先从Message中拿到子线程发来的结果参数AsyncTaskResult,AsyncTaskResult里面封装了AsyncTask对象和数据信息,如下:
private static class AsyncTaskResult<Data> {
final AsyncTask mTask;
final Data[] mData;
AsyncTaskResult(AsyncTask task, Data... data) {
mTask = task;
mData = data;
}
}
然后根据不同状态调用不同方法,如果是MESSAGE_POST_RESULT状态,就调用AsyncTask的finish()方法,finish方法中会去判断当前任务是否被cancel,如果没有cancel则开始回调onPostExecute()方法;如果状态是MESSAGE_POST_PROGRESS,则回调onProgressUpdate()方法。
当子线程需要和UI线程进行通信时,就会通过这个handler,往UI线程发送消息。需要通过handler来发送消息,肯定是在子线程异步任务的时候才需要,在AsyncTask中需要handler的地方其实就是两个地方,一个是doInBackground()在运行过程中,需要更新进度值的时候;一个是doInBackground()运行完成后,需要回到到UI线程中的onPostExecute()方法的时候。
对于一:我们在doInBackground()中调用publicProgress()进行进度值的更新,因此在publicProgress()中肯定会有handler的身影,如下:
protected final void publishProgress(Progress... values) {
if (!isCancelled()) {
getHandler().obtainMessage(MESSAGE_POST_PROGRESS,
new AsyncTaskResult<Progress>(this, values)).sendToTarget();
}
}
对于二:其实就是一个异步任务执行完后后的返回处理,而FutureTask正是处理处理Runnable运行返回结果的。
在1部分的executeOnExecutor方法中第四步,我们在执行execute(mFuture),传入了一个mFuture,mFuture是在初始化AsyncTask的时候进行构建的,如下:
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);
}
}
};
在上面的postResultIfNotInvoked()中会通过handler进行消息的发送。
AsyncTask原理总结:
AsyncTask主要是对异步任务和handler的封装,在处理异步任务时,AsyncTask内部使用了两个线程池,一个线程池sDefaultExecutor是用来处理用户提交(执行AsyncTask的execute时)过来的异步任务,这个线程池中有一个Runnable异步任务队列ArrayDequemTasks,把提交过来的异步任务放到这个队列中;另一个线程池THREAD_POOL_EXECUTOR,用来真正执行异步任务的。在处理handler时,自定义了一个InternalHandler,在publicProgress()和doInBackground()运行完成后,会通过这个handler往UI线程发送Message。
3 AsyncTask在使用中的一个特殊情况
我们在使用AsyncTask的时候,一般会在onPreExecute()和onPostExecute()中进行UI的更新,比如等待图片的显示、进度条的显示...当我们一个Activity中正在使用AsyncTask进行文件的下载时,如果此时屏幕发生了旋转,Activity会进行re-onCreate,又会创建一个AsyncTask进行文件的下载,这个正是我们前面将取消任务的时候谈到的第二个现象,我们只需要在onPause()中进行取消cancel()即可。但是这样仅仅是解决了发生等待的情况,因为Activity再次进入了onCreate()方法,还是会进行文件的下载,为了解决这个问题,一种方案是通过判断onCreate(Bundle savedInstanceState)方法参数中的savedInstanceState==null?来判断是哪种情况,只有savedInstanceState==null时才去创建新的AsyncTask。
4 AsyncTask和Handler的比较
AsyncTask:
优点:AsyncTask是一个轻量级的异步任务处理类,轻量级体现在,使用方便、代码简洁上,而且整个异步任务的过程可以通过cancel()进行控制;
缺点:不适用于处理长时间的异步任务,一般这个异步任务的过程最好控制在几秒以内,如果是长时间的异步任务就需要考虑多线程的控制问题;当处理多个异步任务时,UI更新变得困难。
Handler:
优点:代码结构清晰,容易处理多个异步任务;
缺点:当有多个异步任务时,由于要配合Thread或Runnable,代码可能会稍显冗余。
总之,AsyncTask不失为一个非常好用的异步任务处理类,只要不是频繁对大量UI进行更新,可以考虑使用;而Handler在处理大量UI更新时可以考虑使用。