优缺点：
优点
它封装了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<Void, Integer, Void> {
@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<Params, Result>() {
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<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);
}
}
};
}
- AsyncTask类初始化了两个类：mWorker 与mFuture：
- WorkerRunnable是实现了Callable接口的抽象方法；FutureTask实现了RunnableFuture，而RunnableFuture接口继承了Runnable和Future
private static abstract class WorkerRunnable<Params, Result> implements Callable<Result>
public interface RunnableFuture<V> extends Runnable, Future<V>
public class FutureTask<V> implements RunnableFuture<V>
二、 调用myAsynTask对象的execute()方法，并且传递参数huhx；我们跟进去，发现实际的执行是：executeOnExecutor(sDefaultExecutor, params);
public final AsyncTask<Params, Progress, Result> 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<Progress>(this, values)).sendToTarget();
}
}
四、 上述我们讲到了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<Data> {
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<Result>(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等
网友评论