优缺点:
优点
它封装了Handler,使创建异步任务变得更加简单,相较于Handler+Thread的模式,不再需要编写任务线程和Handler实例即可完成相同的任务。
缺点
- 不适合长时间的后台操作(适合几秒钟的操作)
- AsyncTask的生命周期没有跟Activity的生命周期同步
AsyncTask不会随着activity的销毁而销毁,它会一直执行, 直到doInBackground()方法执行完毕。如果在Activity销毁之前,没有取消 AsyncTask,有可能让我们的AsyncTask崩溃(crash)。因为它在onPostExecute()中想要处理的view已经不存在了。所以,我们总是必须确保在销毁活动之前取消任务。
另外,即使我们正确地调用了cancle() 也未必能真正地取消任务。因为如果在doInBackgroud里有一个不可中断的操作,比如BitmapFactory.decodeStream(),那么这个操作会继续下去。 - 容易内存泄漏
如果AsyncTask被声明为Activity的非静态的内部类,那么AsyncTask会保留一个对创建了AsyncTask的Activity的引用。如果Activity已经被销毁,AsyncTask的后台线程还在执行,它将继续在内存里保留这个引用,导致Activity无法被回收,引起内存泄露。 - 结果丢失
屏幕旋转或Activity在后台被系统杀掉等情况会导致Activity的重新创建,之前运行的AsyncTask会持有一个之前Activity的引用,这个引用已经无效,这时调用onPostExecute()再去更新界面将不再生效。
要注意的地方:
- 并行还是串行
在Android 1.6之前的版本,AsyncTask是串行的,在1.6至2.3的版本,改成了并行的。在2.3之后的版本又做了修改,可以支持并行和串行,当想要串行执行时,直接执行execute()方法,如果需要并行执行,则要执行executeOnExecutor(Executor)。 - 在activity的destroy()中执行cancel()后,AsyncTask将执行完doInBackground(),但不再执行onPostExecute()和onProgressUpdate(),而是执行onCancelled().
使用:
public class MainActivity extends AppCompatActivity {
private static final String TAG = "MainActivity";
private ProgressDialog mDialog;
private TextView mTextView;
MyAsyncTask myAsyncTask;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
mTextView = (TextView) findViewById(R.id.id_tv);
mDialog = new ProgressDialog(this);
mDialog.setMax(100);
mDialog.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);
mDialog.setCancelable(true);
myAsyncTask = new MyAsyncTask();
myAsyncTask.execute();
}
@Override
protected void onDestroy() {
super.onDestroy();
if (myAsyncTask != null)
myAsyncTask.cancel(true);
}
private class MyAsyncTask extends AsyncTask {
@Override
protected void onPreExecute() {
mDialog.show();
Log.e(TAG, Thread.currentThread().getName() + " onPreExecute ");
}
@Override
protected Void doInBackground(Void... params) {
// 模拟数据的加载,耗时的任务
for (int i = 0; i < 100; i++) {
try {
Thread.sleep(80);
} catch (InterruptedException e) {
e.printStackTrace();
}
publishProgress(i);
}
Log.e(TAG, Thread.currentThread().getName() + " doInBackground ");
return null;
}
@Override
protected void onProgressUpdate(Integer... values) {
mDialog.setProgress(values[0]);
Log.e(TAG, Thread.currentThread().getName() + " onProgressUpdate ");
}
@Override
protected void onPostExecute(Void result) {
// 进行数据加载完成后的UI操作
mDialog.dismiss();
mTextView.setText("LOAD DATA SUCCESS ");
Log.e(TAG, Thread.currentThread().getName() + " onPostExecute ");
}
}
}
效果:
源码分析:
好了,上述我们基本得到了AsyncTask的执行流程,现在我们通过源码并且结合上述案例,对AsyncTask做更为细致的分析:
一、 首先我们是在主线程上创建了一个继承AsyncTask的MyAsynTask类: MyAsynTask myAsynTask = new MyAsynTask();由于是继承关系,上述方法执行了MyAsynTask的父类AsyncTask的构造方法:
public AsyncTask() {
mWorker = new WorkerRunnable() {
public Result call() throws Exception {
mTaskInvoked.set(true);
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
//noinspection unchecked
Result result = doInBackground(mParams);
Binder.flushPendingCommands();
return postResult(result);
}
};
mFuture = new FutureTask(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);
}
}
};
}
- AsyncTask类初始化了两个类:mWorker 与mFuture:
- WorkerRunnable是实现了Callable接口的抽象方法;FutureTask实现了RunnableFuture,而RunnableFuture接口继承了Runnable和Future
private static abstract class WorkerRunnable implements Callable
public interface RunnableFuture extends Runnable, Future
public class FutureTask implements RunnableFuture
二、 调用myAsynTask对象的execute()方法,并且传递参数huhx;我们跟进去,发现实际的执行是:executeOnExecutor(sDefaultExecutor, params);
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;
}
- 该方法首先是判断mStatus状态,如果是正在运行(RUNNING)或者已经结束运行(FINISHED),就会抛出异常。
- 接着设置状态为运行,执行onPreExecute()方法,并把参数的值赋给mWorker.mParams;
- 于是Executor去执行execute的方法,学过java多线程的都知道。这个方法是开启一个线程去执行mFuture中的run()方法
- 注意mFuture和mWorker都是在AsyncTask的构造方法中初始化过的
三、根据上述讲解,将执行mFuture的run,也就是将执行mWorker的call方法,如下:
public Result call() throws Exception {
mTaskInvoked.set(true);
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
//noinspection unchecked
Result result = doInBackground(mParams);
Binder.flushPendingCommands();
return postResult(result);
}
- 设置最高优先级,接着执行了doInBackground()方法,注意它的参数mParams正是mWorker的属性mParams,而我们在之前有过这样的代码:mWorker.mParams = params;因此doInBackground方法的参数就是execute方法传递的参数
- 好了,执行到了我们重写的doInBackground()方法了,现在要回到MyAsynTask类中的来了,在doInBackground中执行了publishProgress方法。跟进去,我们看一下代码
protected final void publishProgress(Progress... values) {
if (!isCancelled()) {
getHandler().obtainMessage(MESSAGE_POST_PROGRESS,
new AsyncTaskResult
四、 上述我们讲到了Handler的部分了,很自然的我们是不是要看一下Handler的handleMessage方法呢?跟进去,我们看一下
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;
}
}
由于上述传递的消息是MESSAGE_POST_PROGRESS,所以result.mTask.onProgressUpdate(result.mData);得到执行,那么result.mTas是什么了,对了,就是我们的AsyncTask。由于AsyncTaskResult的第二个参数是values是publishProgress的参数,那么onProgressUpdate中的参数就是publishProgress方法的参数,如下:
private static class AsyncTaskResult {
final AsyncTask mTask;
final Data[] mData;
AsyncTaskResult(AsyncTask task, Data... data) {
mTask = task;
mData = data;
}
}
五、 好了,我们要回到第三步的,最后一个postResult(result)方法了,在这个方法当中,如下
private Result postResult(Result result) {
@SuppressWarnings("unchecked")
Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
new AsyncTaskResult(this, result));
message.sendToTarget();
return result;
}
看到没有,发送了MESSAGE_POST_RESULT信息,于是在第六步中的handleMessage方法的代码中result.mTask.finish(result.mData[0])得到执行,在这个方法中,执行了AsyncTask的finish方法
private void finish(Result result) {
if (isCancelled()) {
onCancelled(result);
} else {
onPostExecute(result);
}
mStatus = Status.FINISHED;
}
在这代码中,如果没有取消,那么就执行onPostExecute方法,记得result是什么吗?Result result = doInBackground(mParams);正是doInBackground方法返回的结果
最后将状态设置为Status.FINISHED,还记得我们在AsyncTask的简要说明的第四点说过吗?一个任务实例只能执行一次,如果执行第二次将会抛出异常,因为执行完一次之后,状态变成FINISHED,在executeOnExecutor方法中会有如下判断:会报异常的!
case FINISHED:
throw new IllegalStateException("Cannot execute task:"
+ " the task has already been executed "
+ "(a task can be executed only once)");
}
六、对于在任务的取消中那些说明,我们额外去对它的源码做一些简单的分析:
调用onCancelled(true)时,系统会发送MESSAGE_POST_RESULT信息,也就是提前进入了上述第五步:执行如下代码
private void finish(Result result) {
if (isCancelled()) {
onCancelled(result);
} else {
onPostExecute(result);
}
mStatus = Status.FINISHED;
}
由于设置了onCancelled(true),所以onCancelled(result)方法得到执行。之后再设置状态为Status.FINISHED;
建议阅读
Java多线程:Executor,Executors,Future,Callable,Runnable等
参考
为什么Android AsyncTask的使用要遵循五大原则