Android AsyncTask实现原理和使用技巧分享
作者：互联网
为什么要用AsyncTask
我们写App都有一个原则，主线程不能够运行需要占用大量CPU时间片的任务，如大量复杂的浮点运算，较大的磁盘IO操作，网络socket等，这些都会导致我们的主线程对用户的响应变得迟钝，甚至ANR，这些会使应用的用户体验变差，但是有时又的确需要执行这些耗时的任务，那么我们通常可以使用AsyncTask或者new Thread
来处理，这样把任务放入工作线程中执行，不会占用主线程的时间片，所以主线程会及时响应用户的操作，如果使用new Thread来执行任务，那么如果需要中途取消任务执行或者需要返回任务执行结果，就需要我们自己维护很多额外的代码，而AsyncTask是基于concurrent架包提供的并发类实现的，上面的二个需求都已经帮我们封装了，这也是我们选择AsyncTask的原因。
怎么用AsyncTask
我们还是简单介绍下AsyncTask一些使用示例。我们先新建一个类DemoAsyncTask继承AsyncTask，因为AsyncTask是抽象类，其中doInBackground方法必须重写。
private class DemoAsyncTask extends AsyncTask<String, Void, Void> {
@Override
protected void onPreExecute() {
super.onPreExecute();
}
@Override
protected Void doInBackground(String... params) {
return null;
}
@Override
protected void onPostExecute(Void aVoid) {
super.onPostExecute(aVoid);
}
@Override
protected void onProgressUpdate(Void... values) {
super.onProgressUpdate(values);
}
@Override
protected void onCancelled(Void aVoid) {
super.onCancelled(aVoid);
}
@Override
protected void onCancelled() {
super.onCancelled();
}
}
DemoAsyncTask task = new DemoAsyncTask();
task.execute("demo test AsyncTask");
//task.executeOnExecutor(AsyncTask.SERIAL_EXECUTOR, "test");
//myTask.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, "test");
简单分析下
上面就是AsyncTask最简单的使用方法，我们上面重写的方法中，onInBackground方法运行在工作线程，其他的方法全部运行在主线程，另外它的运行方式Android提供给我们2个方法，上面都列出了。
1.第一个方法会使用默认的Executor执行我们的任务, 其实也就是SERIAL_EXECUTOR，SERIAL_EXECUTOR我们其实也是可以通过方法去自定义的，Android帮我们的默认实现是逐个执行任务，也就是单线程的，关于AsyncTask的任务执行是单线程实现还是多线程实现还有一段很有意思的历史，较早的版本是单线程实现，从Android2.X开始，Google又把它改为多线程实现，后来Google发现，多线程实现的话，会有很多需要保证线程安全的额外工作留给开发者，所以从Android3.0开始，又把默认实现改为单线程了，今天我们演示的是Framwork代码版本是21(Android5.0)。
2.同时也提供了多线程实现的接口，即我们上面写的最后一行代码 AsyncTask.THREAD_POOL_EXECUTOR。
public final AsyncTask<Params, Progress, Result> execute(Params... params) {
return executeOnExecutor(sDefaultExecutor, params);
}
private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
其实相信大家平时工作学习中经常使用AsyncTask，我们直接去看AsyncTask类源码（插一句题外话，平时大家也可以把自己工作学习中的心得体会总结一下，记下来~~）
public abstract class AsyncTask<Params, Progress, Result> {
....
}
AsyncTask抽象类，有三个泛型参数类型，第一个是你需要传递进来的参数类型，第二个是任务完成进度的类型一般是Integer，第三个是任务完成结果的返回类型，有时这些参数不是全部需要，不需要的设为Void即可，另外Result只有一个，但Params可以有多个。
我们可以看到AsyncTask的默认构造器初始化了二个对象，mWorker和mFuture。
private final WorkerRunnable<Params, Result> mWorker;
private final FutureTask<Result> mFuture;
mWorker = new WorkerRunnable<Params, Result>() {
public Result call() throws Exception {
mTaskInvoked.set(true);
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
//noinspection unchecked
return postResult(doInBackground(mParams));
}
};
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 occured while executing doInBackground()",
e.getCause());
} catch (CancellationException e) {
postResultIfNotInvoked(null);
}
}
};
mWoker实现了Callback接口，Callback接口是JDK1.5加入的高级并发架包里面的一个接口，它可以有一个泛型返回值。
public interface Callable<V> {
/**
* Computes a result, or throws an exception if unable to do so.
*
* @return computed result
* @throws Exception if unable to compute a result
*/
V call() throws Exception;
}
FutureTask实现了RunnableFuture接口，RunnableFuture接口是JDK提供的，看名称就知道它继承了Runnable和Future接口，mFuture是FutureTask的一个实例，可以直接被Executor类实例execute。我们来继续看AsyncTask的execute方法。
public final AsyncTask<Params, Progress, Result> execute(Params... params) {
return 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;
}
先调用onPreExecute()方法，此时还在主线程(严格来说是调用AsyncTask执行的线程)，然后exec.execute(mFuture)，把任务交给exec处理，execute mFuture其实就是invoke mWoker，然后调用postResult(doInBackground(mParams))，此时已经运行在工作线程池，不会阻塞主线程。然后给mHandler发送MESSAGE_POST_RESULT消息，然后调用finish方法，如果isCancelled，回调onCancelled，否则回调onPostExecute。
private Result postResult(Result result) {
@SuppressWarnings("unchecked")
Message message = sHandler.obtainMessage(MESSAGE_POST_RESULT,
new AsyncTaskResult<Result>(this, result));
message.sendToTarget();
return result;
}
private static final InternalHandler sHandler = new InternalHandler();
private static class InternalHandler extends Handler {
@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;
}
}
}
private void finish(Result result) {
if (isCancelled()) {
onCancelled(result);
} else {
onPostExecute(result);
}
mStatus = Status.FINISHED;
}
现在其实我们已经把AsyncTask整个执行任务的过程走完了，其中暴露给我们的那几个回调方法也都走到了。现在我们回过头来看，AsyncTask其实只是对JDK 1.5提供的高级并发特性，concurrent架包做的一个封装，方便开发者来处理异步任务，当然里面还有很多细节处理的方法值得大家学习，如任务执行进度的反馈，任务执行原子性的保证等，这些留给大家自己学习了。
使用AsyncTask一点小技巧
我们以一个实例来说明，“点击按钮开始下载QQAndroid安装包，然后显示一个对话框来反馈下载进度”。我们先初始化一个对话框，由于要显示进度，我们用Github上面一个能够显示百分比的进度条 NumberProgressbar，启动任务的按钮我们使用* circlebutton*，一个有酷炫动画的按钮，Github上面有很多非常好的开源项目，当然炫酷的控件是其中一部分了，后面有机会，会去学习一些比较流行的控件它们的实现原理，今天就暂且拿来主义了~~。
1.先初始化进度条提示对话框。
builder = new AlertDialog.Builder(
MainActivity.this);
LayoutInflater inflater = LayoutInflater.from(MainActivity.this);
mDialogView = inflater.inflate(R.layout.progress_dialog_layout, null);
mNumberProgressBar = (NumberProgressBar)mDialogView.findViewById(R.id.number_progress_bar);
builder.setView(mDialogView);
mDialog = builder.create();
- 2.设置按钮点击事件。
findViewById(R.id.circle_btn).setOnClickListener(new View.OnClickListener(){
@Override
public void onClick(View v) {
dismissDialog();
mNumberProgressBar.setProgress(0);
myTask = new MyAsyncTask();
myTask.execute(qqDownloadUrl);
}
});
3.DownloadAsyncTask实现，有点长。
private class DownloadAsyncTask extends AsyncTask<String , Integer, String> {
@Override
protected void onPreExecute() {
super.onPreExecute();
mDialog.show();
}
@Override
protected void onPostExecute(String aVoid) {
super.onPostExecute(aVoid);
dismissDialog();
}
@Override
protected void onProgressUpdate(Integer... values) {
super.onProgressUpdate(values);
mNumberProgressBar.setProgress(values[0]);
}
@Override
protected void onCancelled(String aVoid) {
super.onCancelled(aVoid);
dismissDialog();
}
@Override
protected void onCancelled() {
super.onCancelled();
dismissDialog();
}
@Override
protected String doInBackground(String... params) {
String urlStr = params[0];
FileOutputStream output = null;
try {
URL url = new URL(urlStr);
HttpURLConnection connection = (HttpURLConnection)url.openConnection();
String qqApkFile = "qqApkFile";
File file = new File(Environment.getExternalStorageDirectory() + "/" + qqApkFile);
if (file.exists()) {
file.delete();
}
file.createNewFile();
InputStream input = connection.getInputStream();
output = new FileOutputStream(file);
int total = connection.getContentLength();
if (total <= 0) {
return null;
}
int plus = 0;
int totalRead = 0;
byte[] buffer = new byte[4*1024];
while((plus = input.read(buffer)) != -1){
output.write(buffer);
totalRead += plus;
publishProgress(totalRead * 100 / total);
if (isCancelled()) {
break;
}
}
output.flush();
} catch (MalformedURLException e) {
e.printStackTrace();
if (output != null) {
try {
output.close();
} catch (IOException e2) {
e2.printStackTrace();
}
}
} catch (IOException e) {
e.printStackTrace();
if (output != null) {
try {
output.close();
} catch (IOException e2) {
e2.printStackTrace();
}
}
} finally {
if (output != null) {
try {
output.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
return null;
}
```
}
这样一个简单的下载文件文件就基本实现了，到目前为止谈不上技巧，但是现在我们有一个问题，就是如果我们的Activity正在后台执行一个任务，可能耗时较长，那用户可能会点击返回退出Activity或者退出App，那么后台任务不会立即退出，如果AsyncTask内部有Activity中成员变量的引用，还会造成Activity的回收延时，造成一段时间内的内存泄露，所以我们需要加上下面的第四步处理。
- 4.onPause中判断应用是否要退出，从而决定是否取消AsyncTask执行。
@Override
protected void onPause() {
super.onPause();
if (myTask != null && isFinishing()) {
myTask.cancel(false);
}
}
这样我们的异步任务就会在Activity退出时，也随之取消任务执行，顺利被系统销毁回收，第四步很多时候会被遗漏，而且一般也不会有什么致命的问题，但是一旦出问题了，就很难排查，所以遵循编码规范还是有必要的。
小结
AsyncTask的基本实现原理我们已经清楚了，同时我们也介绍了一个使用AsyncTask要注意的一个小技巧，希望大家读完能有所收获
欢迎大家一起交流讨论哈！
标签：void,AsyncTask,protected,result,Override,new,Android,分享 来源： https://blog.csdn.net/TQLSDLWSL/article/details/121384094