Android应用程序线程消息循环模型分析（6）

 我们可以通过mFuture对象来操作当前执行的任务，例如查询当前任务的状态，它是正在执行中，还是完成了，还是被取消了，如果是完成了，还可以通过它获得任务的执行结果，如果还没有完成，可以取消任务的执行。

        当工作任务mWorker执行完成的时候，mFuture对象中的done函数就会被被调用，根据任务的完成状况，执行相应的操作，例如，如果是因为异常而完成时，就会抛异常，如果是正常完成，就会把任务执行结果封装成一个AsyncTaskResult对象：

1. private static class AsyncTaskResult<Data> {   
2.     final AsyncTask mTask;   
3.     final Data[] mData;   
4.    
5.     AsyncTaskResult(AsyncTask task, Data... data) {   
6.         mTask = task;   
7.         mData = data;   
8.     }   
9. }   

 其中，成员变量mData保存的是任务执行结果，而成员变量mTask指向前面我们创建的AsyncTask对象。
        最后把这个AsyncTaskResult对象封装成一个消息，并且通过消息处理器sHandler加入到应用程序主线程的消息队列中：

1. message = sHandler.obtainMessage(MESSAGE_POST_RESULT,   
2.     new AsyncTaskResult<Result>(AsyncTask.this, result));   
3. message.sendToTarget();   

  这个消息最终就会在InternalHandler类的handleMessage函数中处理了：

1. private static class InternalHandler extends Handler {   
2.     @SuppressWarnings({"unchecked", "RawUseOfParameterizedType"})   
3.     @Override   
4.     public void handleMessage(Message msg) {   
5.         AsyncTaskResult result = (AsyncTaskResult) msg.obj;   
6.         switch (msg.what) {   
7.         case MESSAGE_POST_RESULT:   
8.             // There is only one result   
9.             result.mTask.finish(result.mData[0]);   
10.             break;   
11.         ......   
12.         }   
13.     }   
14. }   

   在这个函数里面，最终会调用前面创建的这个AsyncTask对象的finish函数来进一步处理：

1. private void finish(Result result) {   
2.        ......   
3.        onPostExecute(result);   
4.        ......   
5. }   

      这个函数调用AsyncTask类的onPostExecute函数来进一步处理，AsyncTask类的onPostExecute函数一般是要由其子类来重载的，注意，这个函数是在应用程序的主线程中执行的，因此，它可以操作应用程序的界面。
        在任务执行的过程当中，即执行doInBackground函数时候，可能通过调用publishProgress函数来将中间结果封装成一个消息发送到应用程序主线程中的消息队列中去：

1. protected final void publishProgress(Progress... values) {   
2.     sHandler.obtainMessage(MESSAGE_POST_PROGRESS,   
3.         new AsyncTaskResult<Progress>(this, values)).sendToTarget();   
4. }   

   这个消息最终也是由InternalHandler类的handleMessage函数来处理的：

1. private static class InternalHandler extends Handler {   
2.     @SuppressWarnings({"unchecked", "RawUseOfParameterizedType"})   
3.     @Override   
4.     public void handleMessage(Message msg) {   
5.         AsyncTaskResult result = (AsyncTaskResult) msg.obj;   
6.         switch (msg.what) {   
7.         ......   
8.         case MESSAGE_POST_PROGRESS:   
9.                  result.mTask.onProgressUpdate(result.mData);   
10.                  break;   
11.         ......   
12.         }   
13.     }   
14. }   

   这里它调用前面创建的AsyncTask对象的onPorgressUpdate函数来进一步处理，这个函数一般是由AsyncTask的子类来实现的，注意，这个函数是在应用程序的主线程中执行的，因此，它和前面的onPostExecute函数一样，可以操作应用程序的界面。

 

       这样，AsyncTask类的主要实现就介绍完了，结合前面开发的应用程序Counter来分析，会更好地理解它的实现原理。

       至此，Android应用程序线程消息循环模型就分析完成了，理解它有利于我们在开发Android应用程序时，能够充分利用多线程的并发性来提高应用程序的性能以及获得良好的用户体验。

本文转自 Luoshengyang 51CTO博客，原文链接：http://blog.51cto.com/shyluo/966891，如需转载请自行联系原作者