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

从AsyncTask的实现可以看出，当我们第一次创建一个AsyncTask对象时，首先会执行下面静态初始化代码创建一个线程池sExecutor：

                               privatestaticfinalBlockingQueue<Runnable>sWorkQueue=     
                       newLinkedBlockingQueue<Runnable>(10);     
                            
                       privatestaticfinalThreadFactorysThreadFactory=newThreadFactory(){     
                       privatefinalAtomicIntegermCount=newAtomicInteger(1);     
                            
                       publicThreadnewThread(Runnabler){     
                       returnnewThread(r,"AsyncTask#"+mCount.getAndIncrement());     
                       }     
                       };     
                            
                       ......     
                            
                       privatestaticfinalThreadPoolExecutorsExecutor=newThreadPoolExecutor(CORE_POOL_SIZE,     
                       MAXIMUM_POOL_SIZE,KEEP_ALIVE,TimeUnit.SECONDS,sWorkQueue,sThreadFactory);

这里的ThreadPoolExecutor是Java提供的多线程机制之一，这里用的构造函数原型为：

                               ThreadPoolExecutor(intcorePoolSize,intmaximumPoolSize,longkeepAliveTime,TimeUnitunit,     
                       BlockingQueue<Runnable>workQueue,ThreadFactorythreadFactory)

各个参数的意义如下： corePoolSize -- 线程池的核心线程数量 maximumPoolSize -- 线程池的最大线程数量 keepAliveTime -- 若线程池的线程数数量大于核心线程数量，那么空闲时间超过keepAliveTime的线程将被回收 unit -- 参数keepAliveTime使用的时间单位 workerQueue -- 工作任务队列 threadFactory -- 用来创建线程池中的线程
简单来说，ThreadPoolExecutor的运行机制是这样的：每一个工作任务用一个Runnable对象来表示，当我们要把一个工作任务交给这个线程池来执行的时候，就通过调用ThreadPoolExecutor的execute函数来把这个工作任务加入到线程池中去。此时，如果线程池中的线程数量小于corePoolSize，那么就会调用threadFactory接口来创建一个新的线程并且加入到线程池中去，再执行这个工作任务；如果线程池中的线程数量等于corePoolSize，但是工作任务队列workerQueue未满，则把这个工作任务加入到工作任务队列中去等待执行；如果线程池中的线程数量大于corePoolSize，但是小于maximumPoolSize，并且工作任务队列workerQueue已经满了，那么就会调用threadFactory接口来创建一个新的线程并且加入到线程池中去，再执行这个工作任务；如果线程池中的线程量已经等于maximumPoolSize了，并且工作任务队列workerQueue也已经满了，这个工作任务就被拒绝执行了。创建好了线程池后，再创建一个消息处理器：

                               privatestaticfinalInternalHandlersHandler=newInternalHandler();

注意，这行代码是在应用程序的主线程中执行的，因此，这个消息处理器sHandler内部引用的消息循环对象looper是应用程序主线程的消息循环对象，消息处理器的实现机制具体可以参考前面一篇文章 Android应用程序消息处理机制（Looper、Handler）分析。 AsyncTask类的静态初始化代码执行完成之后，才开始创建AsyncTask对象，即执行AsyncTask类的构造函数：

                               publicAsyncTask(){     
                       mWorker=newWorkerRunnable<Params,Result>(){     
                       publicResultcall()throwsException{     
                       ......     
                       returndoInBackground(mParams);     
                       }     
                       };     
                            
                       mFuture=newFutureTask<Result>(mWorker){     
                       @Override     
                       protectedvoiddone(){     
                       Messagemessage;     
                       Resultresult=null;     
                            
                       try{     
                       result=get();     
                       }catch(InterruptedExceptione){     
                       android.util.Log.w(LOG_TAG,e);     
                       }catch(ExecutionExceptione){     
                       thrownewRuntimeException("AnerroroccuredwhileexecutingdoInBackground()",     
                       e.getCause());     
                       }catch(CancellationExceptione){     
                       message=sHandler.obtainMessage(MESSAGE_POST_CANCEL,     
                       newAsyncTaskResult<Result>(AsyncTask.this,(Result[])null));     
                       message.sendToTarget();     
                       return;     
                       }catch(Throwablet){     
                       thrownewRuntimeException("Anerroroccuredwhileexecuting"     
                       +"doInBackground()",t);     
                       }     
                            
                       message=sHandler.obtainMessage(MESSAGE_POST_RESULT,     
                       newAsyncTaskResult<Result>(AsyncTask.this,result));     
                       message.sendToTarget();     
                       }     
                       };     
                       }

在AsyncTask类的构造函数里面，主要是创建了两个对象，分别是一个WorkerRunnable对象mWorker和一个FutureTask对象mFuture。 WorkerRunnable类实现了Runnable接口，此外，它的内部成员变量mParams用于保存从AsyncTask对象的execute函数传进来的参数列表：

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

FutureTask类也实现了Runnable接口，所以它可以作为一个工作任务通过调用AsyncTask类的execute函数添加到sExecuto线程池中去：

                               publicfinalAsyncTask<Params,Progress,Result>execute(Params...params){     
                       ......     
                            
                       mWorker.mParams=params;     
                       sExecutor.execute(mFuture);     
                            
                       returnthis;     
                       }

这里的FutureTask对象mFuture是用来封装前面的WorkerRunnable对象mWorker。当mFuture加入到线程池中执行时，它调用的是mWorker对象的call函数：

                               mWorker=newWorkerRunnable<Params,Result>(){     
                       publicResultcall()throwsException{     
                       ......     
                       returndoInBackground(mParams);     
                       }     
                       };

在call函数里面，会调用AsyncTask类的doInBackground函数来执行真正的任务，这个函数是要由AsyncTask的子类来实现的，注意，这个函数是在应用程序的子线程中执行的，它不可以操作应用程序的界面。

更多相关文章

随机推荐