Android应用程序线程消息循环模型分析(5)

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

  1. private static final BlockingQueue<Runnable> sWorkQueue =   
  2.     new LinkedBlockingQueue<Runnable>(10);   
  3.    
  4. private static final ThreadFactory sThreadFactory = new ThreadFactory() {   
  5.     private final AtomicInteger mCount = new AtomicInteger(1);   
  6.    
  7.     public Thread newThread(Runnable r) {   
  8.         return new Thread(r, "AsyncTask #" + mCount.getAndIncrement());   
  9.     }   
  10. };   
  11.    
  12. ......   
  13.    
  14. private static final ThreadPoolExecutor sExecutor = new ThreadPoolExecutor(CORE_POOL_SIZE,   
  15.     MAXIMUM_POOL_SIZE, KEEP_ALIVE, TimeUnit.SECONDS, sWorkQueue, sThreadFactory);   
这里的ThreadPoolExecutor是Java提供的多线程机制之一,这里用的构造函数原型为: 

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

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

  1. public AsyncTask() {   
  2.     mWorker = new WorkerRunnable<Params, Result>() {   
  3.         public Result call() throws Exception {   
  4.             ......   
  5.             return doInBackground(mParams);   
  6.         }   
  7.     };   
  8.    
  9.     mFuture = new FutureTask<Result>(mWorker) {   
  10.         @Override   
  11.         protected void done() {   
  12.             Message message;   
  13.             Result result = null;   
  14.    
  15.             try {   
  16.                 result = get();   
  17.             } catch (InterruptedException e) {   
  18.                 android.util.Log.w(LOG_TAG, e);   
  19.             } catch (ExecutionException e) {   
  20.                 throw new RuntimeException("An error occured while executing doInBackground()",   
  21.                     e.getCause());   
  22.             } catch (CancellationException e) {   
  23.                 message = sHandler.obtainMessage(MESSAGE_POST_CANCEL,   
  24.                     new AsyncTaskResult<Result>(AsyncTask.this, (Result[]) null));   
  25.                 message.sendToTarget();   
  26.                 return;   
  27.             } catch (Throwable t) {   
  28.                 throw new RuntimeException("An error occured while executing "   
  29.                     + "doInBackground()", t);   
  30.             }   
  31.    
  32.             message = sHandler.obtainMessage(MESSAGE_POST_RESULT,   
  33.                 new AsyncTaskResult<Result>(AsyncTask.this, result));   
  34.             message.sendToTarget();   
  35.         }   
  36.     };   
  37. }   
  在AsyncTask类的构造函数里面,主要是创建了两个对象,分别是一个WorkerRunnable对象mWorker和一个FutureTask对象mFuture。
 
        WorkerRunnable类实现了Runnable接口,此外,它的内部成员变量mParams用于保存从AsyncTask对象的execute函数传进来的参数列表:

  1. private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {   
  2.     Params[] mParams;   
  3. }   
 FutureTask类也实现了Runnable接口,所以它可以作为一个工作任务通过调用AsyncTask类的execute函数添加到sExecuto线程池中去:

  1. public final AsyncTask<Params, Progress, Result> execute(Params... params) {   
  2.     ......   
  3.    
  4.     mWorker.mParams = params;   
  5.     sExecutor.execute(mFuture);   
  6.    
  7.     return this;   
  8. }   
这里的FutureTask对象mFuture是用来封装前面的WorkerRunnable对象mWorker。当mFuture加入到线程池中执行时,它调用的是mWorker对象的call函数:

  1. mWorker = new WorkerRunnable<Params, Result>() {   
  2.     public Result call() throws Exception {   
  3.            ......   
  4.            return doInBackground(mParams);   
  5.         }   
  6. };   
在call函数里面,会调用AsyncTask类的doInBackground函数来执行真正的任务,这个函数是要由AsyncTask的子类来实现的,注意,这个函数是在应用程序的子线程中执行的,它不可以操作应用程序的界面。




本文转自 Luoshengyang 51CTO博客,原文链接:http://blog.51cto.com/shyluo/966888,如需转载请自行联系原作者
上一篇:html编辑及JS脚本过滤(转载)


下一篇:HTML基础-样式位置、背景、边框、内外边距、盒模型和结构、文本、常见样式