Android中从源码分析关于AsyncTask的使用

Android在框架层提供了异步任务类，AysncTask，用于执行后台任务，并将执行结果更新到UI线程。为什么要用异步任务呢？这是因为如果某个任务太耗时间的话，会阻塞UI主线程，而我们知道UI线程如果阻塞5秒的话，就会发生ANR（Application No Response）错误，就算没有发生，主界面上看起来也会卡卡的，这显然用户体验就不太好了。

而AsyncTask类则在不影响UI线程的情况下，另起子线程去做那些耗时比较久的任务，比如我们在TodoList中去读取图片这种情况，然后将处理后的结果再更新到UI线程，从而达到更好的用户体验。

下面是AsyncTask类的定义：

[java] view plain copy

publicabstractclassAsyncTask<Params,Progress,Result>{
privatestaticfinalStringLOG_TAG="AsyncTask";
...

从上面的代码可以看出，AsyncTask是一个抽象类，所以在使用AsyncTask的时候，我们要继承它，实现一个子类，并实现其中一个方法，如下：

[java] view plain copy

classLoadImageTaskextendsAsyncTask<String,Void,ImageView>{
@Override
protectedImageViewdoInBackground(String...params){
StringphotoImagePath=params[0];
Bitmapbitmap=BitmapReader.readBigBitmapFromFile(photoImagePath,REQ_WIDTH);
ImageViewimageView=Helper.createImageViewFromBitmap(DetailActivity.this,bitmap);
returnimageView;
}
protectedvoidonPostExecute(ImageViewresult){
imageViews.add(result);
refreshGallery();
}
}

对照 AsyncTask的三个参数，Params, Progress和Result，是泛型参数。

1）Params ：参数，比如例子中定义的String类型，指向一个Image的路径，这是传给AysncTask的doInBackground方法。

2）Progress：这是在执行过程中会用到的一个参数，一般在显示进度的时候会用到，在例子中不会用到，所以可以在这里指定为Void。

3）Result：这是执行的结果对象，会作为onPostExecute方法的参数，在UI线程中处理。

由上面的例子也可以看到，一般我们实现的这个子类，要实现其中的两个方法

1）doInBackground：这个方法，其实是在另外一个线程中执行的。

2）onPostExecute：而这个方法却已经回到UI线程中来执行，所以可以在这里将上一个方法中执行所得的结果在这里更新到UI线程中。

那么这里面的机制是怎么样的呢，我们就来深入地看一下，也学习一下吧。

首先我们来看一下在Activity中，我们是怎么样来使用我们这个AsyncTask的吧，代码如下：

[java] view plain copy

@Override
protectedvoidonActivityResult(intrequestCode,intresultCode,Intentdata){
if(requestCode==REQUEST_FOR_CAMERA){
if(resultCode==RESULT_OK){
isPhotoTaken=true;
photoFileNames.add(tempPhotoFileName);
}
}elseif(requestCode==REQUEST_FOR_GALLERY){
if(resultCode==RESULT_OK){
isPhotoTaken=true;
ContentResolverresolver=getContentResolver();
Uriuri=data.getData();
tempPhotoFileName=Helper.getImagePath(resolver,uri);
photoFileNames.add(tempPhotoFileName);
}
}
newLoadImageTask().execute(tempPhotoFileName);//调用其execute方法
}

在TodoList的小demo中，在相机或者图库返回来图片的路径之后，我们就会调用AsynctTask的execute方法了，那么这里就是入口了。

进入AsyncTask类中，找到execute方法，如下：

[java] view plain copy

publicfinalAsyncTask<Params,Progress,Result>execute(Params...params){
returnexecuteOnExecutor(sDefaultExecutor,params);
}

可以看到，这里调用的是executeOnExecutor方法，我们继续找： [java] view plain copy

publicfinalAsyncTask<Params,Progress,Result>executeOnExecutor(Executorexec,
Params...params){
if(mStatus!=Status.PENDING){
switch(mStatus){
caseRUNNING:
thrownewIllegalStateException("Cannotexecutetask:"
+"thetaskisalreadyrunning.");
caseFINISHED:
thrownewIllegalStateException("Cannotexecutetask:"
+"thetaskhasalreadybeenexecuted"
+"(ataskcanbeexecutedonlyonce)");
}
}
mStatus=Status.RUNNING;
onPreExecute();
mWorker.mParams=params;
exec.execute(mFuture);
returnthis;
}

在这个方法中，我们可以发现，AsynctTask定义了一个mStatus的成员变量，来表示异步任务的运行状态，分别是pending，running和finished，但只有处于pending状态的AsnycTask才能被执行。当状态是Pending的时候，就会继续执行，将状态变成running，这样能够保证AsyncTask只会被执行一次。

接着会调用onPreExecute方法做一些处理工作，这个方法其实我们也可以在子类中自己实现，如果有什么需要处理的话，一般不用。

然后我们发现，我们传进来的参数params会被传给mWorker，然后会有一个executor来执行execute的方法，并且执行的参数是一个mFuture对象。那么这两个东西是什么呢？

接着看如下代码：

[java] view plain copy

publicAsyncTask(){
mWorker=newWorkerRunnable<Params,Result>(){
publicResultcall()throwsException{
mTaskInvoked.set(true);
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
//noinspectionunchecked
returnpostResult(doInBackground(mParams));
}
};
mFuture=newFutureTask<Result>(mWorker){
@Override
protectedvoiddone(){
try{
postResultIfNotInvoked(get());
}catch(InterruptedExceptione){
android.util.Log.w(LOG_TAG,e);
}catch(ExecutionExceptione){
thrownewRuntimeException("AnerroroccuredwhileexecutingdoInBackground()",
e.getCause());
}catch(CancellationExceptione){
postResultIfNotInvoked(null);
}
}
};
}

mWorker是一个WorkerRunnable对象，而实际上WorkerRunnable是AsyncTask的一个抽象内部类，实现了Callable接口，如下：

[java] view plain copy

privatestaticabstractclassWorkerRunnable<Params,Result>implementsCallable<Result>{
Params[]mParams;
}

而在上面的赋值过程，通过匿名类实现了WorkerRunnable，并其call方法中将线程优先级调整为后台线程，然后会执行 doInBackground方法，不过现在还没执行，咱们再看看FutureTask对象，下面是它的构造函数： [java] view plain copy

publicFutureTask(Callable<V>callable){
if(callable==null)
thrownewNullPointerException();
sync=newSync(callable);
}

而FutureTask是Java多线程模型的一部分，其间接地实现了Runnable（线程属性）接口和Future（异步任务）接口，而在上面的executeOnExecutor方法中，正是将mWorker（实现了Callable接口）对象传给它了，并被其封装到成员变量sync中，这样它们就共同表示了一个异步任务，到这里，一个异步任务也就创建完成了。

从上面executeOnExecutor的方法，也可以看到，真正执行execute是一个Executor，而在AsyncTask中，其实是SerialExecutor，我们看看其构造函数：

[java] view plain copy

privatestaticclassSerialExecutorimplementsExecutor{
finalArrayDeque<Runnable>mTasks=newArrayDeque<Runnable>();
RunnablemActive;
publicsynchronizedvoidexecute(finalRunnabler){
mTasks.offer(newRunnable(){
publicvoidrun(){
try{
r.run();//在新线程中调用了我们上面传进来的FutureTask的run方法
}finally{
scheduleNext();
}
}
});
if(mActive==null){
scheduleNext();
}
}
protectedsynchronizedvoidscheduleNext(){
if((mActive=mTasks.poll())!=null){
THREAD_POOL_EXECUTOR.execute(mActive);
}
}
}

从上面，我们可以看到execute方法的参数就是一个Runnable，其实也就是FutrueTask了，在这里，它会被封装到一个新的线程中作为一个任务添加到mTasks队列中，至于下面如何在THREAD_POOL_EXECUTOR中去执行mTasks我们就不再深入下去了，我们就来看看FutureTask的run方法，如下：

[java] view plain copy

publicvoidrun(){
sync.innerRun();
}

我们发现，它调用的是sync.innerRun()，那么Sync的innerRun方法又干了什么呢？ [java] view plain copy

voidinnerRun(){
if(!compareAndSetState(READY,RUNNING))
return;
runner=Thread.currentThread();
if(getState()==RUNNING){//recheckaftersettingthread
Vresult;
try{
result=callable.call();
}catch(Throwableex){
setException(ex);
return;
}
set(result);
}else{
releaseShared(0);//cancel
}
}

我们发现，它调用了callable的call方法，啊，我们终于来到了mWorker的call方法，回过头看，不就是在那里调用了doInBackground方法的吗？所以，我们可以确定，doInBackground的确是在一个新的线程中执行的，并且是一个后台线程。

但同时我们发现，其执行完之后，是作为一个参数传递给postResult的，继续看下去：

[java] view plain copy

privateResultpostResult(Resultresult){
@SuppressWarnings("unchecked")
Messagemessage=sHandler.obtainMessage(MESSAGE_POST_RESULT,
newAsyncTaskResult<Result>(this,result));
message.sendToTarget();
returnresult;
}

可以看到，在这里是利用了sHandler来发送异步消息的，而sHandler是在AsynctTask中定义的，如下： [java] view plain copy

privatestaticfinalInternalHandlersHandler=newInternalHandler();

InternalHandler定义如下
[java] view plain copy

privatestaticclassInternalHandlerextendsHandler{
@SuppressWarnings({"unchecked","RawUseOfParameterizedType"})
@Override
publicvoidhandleMessage(Messagemsg){
AsyncTaskResultresult=(AsyncTaskResult)msg.obj;
switch(msg.what){
caseMESSAGE_POST_RESULT:
//Thereisonlyoneresult
result.mTask.finish(result.mData[0]);
break;
caseMESSAGE_POST_PROGRESS:
result.mTask.onProgressUpdate(result.mData);
break;
}
}
}

我们可以在这里发现，如果是MESSAGE_POST_RESULT，则会调用mTask的finish方法，然后就结束了，而如果是MESSAGE_POST_PROGRESS，则会调用 onProgressUpdate方法，那么，很显然这个mTask应该就是我们定久的AsyncTask了吧。我们看看AsyncTaskResult是什么先， [java] view plain copy

@SuppressWarnings({"RawUseOfParameterizedType"})
privatestaticclassAsyncTaskResult<Data>{
finalAsyncTaskmTask;
finalData[]mData;
AsyncTaskResult(AsyncTasktask,Data...data){
mTask=task;
mData=data;
}
}

我们发现，在上面传进来的AsyncTaskResult的参数task的正好就是this，而它又赋值给了mTask的，所以说明，这个mTask就是我们在Activity中定义的LoadImageTask了，而它是在主线程中定义的，那么很显然，它的finish方法也是在主线程，也就是UI线程中执行的了，再来看看这个finish方法： [java] view plain copy

privatevoidfinish(Resultresult){
if(isCancelled()){
onCancelled(result);
}else{
onPostExecute(result);
}
mStatus=Status.FINISHED;
}

在这里，我们终于看到了onPostExecute方法的调用了，这说明了，onPostExecute就是在UI线程中干活的了。最后mStatus也被设计成FIINISHED了，这个异步任务也就结束了。
转载自：http://blog.csdn.net/u013889308/article/details/20372481

更多相关文章

随机推荐