Android消息机制之五---AsyncTask

Android消息机制之异步（AsyncTask）

 

位置： /frameworks/base/core/java/android/os/AsyncTask.java

 AsyncTask的本质是一个线程池，所有提交的异步任务都会在这个线程池中的工作线程内执行，当工作线程需要跟UI线程交互时，工作线程会通过向在UI线程创建的Handler传递消息的方式，调用相关的回调函数，从而实现UI界面的更新。

private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors(); private static final int CORE_POOL_SIZE = CPU_COUNT + 1; private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1; private static final int KEEP_ALIVE = 1; private static final ThreadFactory sThreadFactory = new ThreadFactory() { private final AtomicInteger mCount = new AtomicInteger(1); public Thread newThread(Runnable r) { return new Thread(r, "AsyncTask #" + mCount.getAndIncrement()); } }; //等待队列 private static final BlockingQueue<Runnable> sPoolWorkQueue =             new LinkedBlockingQueue<Runnable>(128);    /**      * An {@link Executor} that can be used to execute tasks in parallel.     */ //线程池是静态变量所有的异步任务都在这个线程池的工作线程中执行 public static final Executor THREAD_POOL_EXECUTOR         = new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);   private static class SerialExecutor implements Executor {         final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();         Runnable mActive;           public synchronized void execute(final Runnable r) {             mTasks.offer(new Runnable() {                 public void run() {                     try {                         r.run();                     } finally {                         scheduleNext();                     }                 }             });             if (mActive == null) {                 scheduleNext();             }         }           protected synchronized void scheduleNext() {             if ((mActive = mTasks.poll()) != null) {                 THREAD_POOL_EXECUTOR.execute(mActive);             }         }     }

 

线程池补充：

private static final int CORE_POOL_SIZE = 10; // 线程池维护的最小线程数   private static final int MAX_POOL_SIZE = 21; // 线程池维护的最大线程数   private static final int KEEP_ACTIVE = 1; // 线程池维护线程所允许的空闲时间     // 线程池对拒绝服务的处理策略   private static final ThreadFactory mThreadFactory = new ThreadFactory() {      @Override      public Thread newThread(Runnable arg0) {        return new Thread(arg0);      }   };   // 线程池所使用的缓冲队列   private static final BlockingQueue<Runnable> sPoolWorkQueue = new LinkedBlockingQueue<Runnable>(128);     private static final Executor thread_pool_executor       = new ThreadPoolExecutor(CORE_POOL_SIZE,                     MAX_POOL_SIZE,                     KEEP_ACTIVE,                     TimeUnit.SECONDS,                     sPoolWorkQueue,                     mThreadFactory);

 

ThreadPoolExecutor:

位置：/libcore/luni/src/main/java/java/util/concurrent/ThreadPoolExecutor.java

 

默认拒绝策略：

private static final RejectedExecutionHandler defaultHandler =         new AbortPolicy();

 

默认构造函数：

public ThreadPoolExecutor(int corePoolSize,                           int maximumPoolSize,                           long keepAliveTime,                           TimeUnit unit,                           BlockingQueue<Runnable> workQueue) {    this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, Executors.defaultThreadFactory(), defaultHandler); }   public ThreadPoolExecutor(int corePoolSize,                               int maximumPoolSize,                               long keepAliveTime,                               TimeUnit unit,                               BlockingQueue<Runnable> workQueue,                               ThreadFactory threadFactory) {    this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory, defaultHandler);   }   public ThreadPoolExecutor(int corePoolSize,                               int maximumPoolSize,                               long keepAliveTime,                               TimeUnit unit,                               BlockingQueue<Runnable> workQueue,                               RejectedExecutionHandler handler) {    this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, Executors.defaultThreadFactory(), handler);    }   public ThreadPoolExecutor(int corePoolSize,                           int maximumPoolSize,                           long keepAliveTime,                          TimeUnit unit,                          BlockingQueue<Runnable> workQueue,                           ThreadFactory threadFactory,                           RejectedExecutionHandler handler) {      if (corePoolSize < 0 ||          maximumPoolSize <= 0 ||          maximumPoolSize < corePoolSize ||          keepAliveTime < 0)          throw new IllegalArgumentException();      if (workQueue == null || threadFactory == null || handler == null)          throw new NullPointerException();      this.corePoolSize = corePoolSize;      this.maximumPoolSize = maximumPoolSize;      this.workQueue = workQueue;      this.keepAliveTime = unit.toNanos(keepAliveTime);      this.threadFactory = threadFactory;      this.handler = handler; }

 

从上面的构造函数可以看出，AnyscTask显然使用的是默认的拒绝策略（RejectedExecutionHandler）：即AbortPolicy()；

 

线程池类为 java.util.concurrent.ThreadPoolExecutor，常用构造方法为：

ThreadPoolExecutor(int corePoolSize, intmaximumPoolSize,

long keepAliveTime, TimeUnit unit,

BlockingQueue<Runnable> workQueue,

RejectedExecutionHandler handler)

corePoolSize： 线程池维护线程的最少数量

maximumPoolSize：线程池维护线程的最大数量

keepAliveTime： 线程池维护线程所允许的空闲时间

unit： 线程池维护线程所允许的空闲时间的单位

workQueue： 线程池所使用的缓冲队列

handler： 线程池对拒绝任务的处理策略

一个任务通过 execute(Runnable)方法被添加到线程池，任务就是一个 Runnable类型的对象，任务的执行方法就是 Runnable类型对象的run()方法。

 

线程池关于线程的创建，阻塞和拒绝说明：

当一个任务通过execute(Runnable)方法欲添加到线程池时：

l 如果此时线程池中的数量小于corePoolSize，即使线程池中的线程都处于空闲状态，也要创建新的线程来处理被添加的任务。

l 如果此时线程池中的数量等于 corePoolSize，但是缓冲队列 workQueue未满，那么任务被放入缓冲队列。

l 如果此时线程池中的数量大于corePoolSize，缓冲队列workQueue满，并且线程池中的数量小于maximumPoolSize，建新的线程来处理被添加的任务。

l 如果此时线程池中的数量大于corePoolSize，缓冲队列workQueue满，并且线程池中的数量等于maximumPoolSize，那么通过 handler所指定的策略来处理此任务。也就是：处理任务的优先级为：核心线程corePoolSize、任务队列workQueue、最大线程maximumPoolSize，如果三者都满了，使用handler处理被拒绝的任务。

l 当线程池中的线程数量大于 corePoolSize时，如果某线程空闲时间超过keepAliveTime，线程将被终止。这样，线程池可以动态的调整池中的线程数。

 

 

线程池相关参数说明：

unit可选的参数为java.util.concurrent.TimeUnit中的几个静态属性：

NANOSECONDS、

MICROSECONDS、

MILLISECONDS、

SECONDS。

workQueue常用的是：java.util.concurrent.ArrayBlockingQueue

handler有四个选择：

ThreadPoolExecutor.AbortPolicy()

抛出java.util.concurrent.RejectedExecutionException异常

ThreadPoolExecutor.CallerRunsPolicy()

重试添加当前的任务，他会自动重复调用execute()方法

ThreadPoolExecutor.DiscardOldestPolicy()

抛弃旧的任务

ThreadPoolExecutor.DiscardPolicy()

抛弃当前的任务

 

 

AsyncTask的构造函数；

/**      * Creates a new asynchronous task. This constructor must be invoked on the UI thread.      */     public AsyncTask() {         mWorker = new WorkerRunnable<Params, Result>() {             public Result call() throws Exception {                 mTaskInvoked.set(true);                 Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);                 //noinspection unchecked                 Result result = doInBackground(mParams);                 Binder.flushPendingCommands();                 return postResult(result);             }         };   //在call方法中调用doInBackground(mParams);得到result，然后交由postResult（） //当Executor.execute()时会执行call（）函数。         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 occurred while executing doInBackground()",                             e.getCause());                 } catch (CancellationException e) {                     postResultIfNotInvoked(null); //取消任务                 }             }         };     }     private void postResultIfNotInvoked(Result result) {         final boolean wasTaskInvoked = mTaskInvoked.get();         if (!wasTaskInvoked) {             postResult(result);         }     }   //向Handler提交消息     private Result postResult(Result result) {         @SuppressWarnings("unchecked")         Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,                 new AsyncTaskResult<Result>(this, result));         message.sendToTarget();         return result;     }

WorkerRunnable类实现了callable接口的call()方法，该函数会调用我们在AsyncTask子类中实现的doInBackground(mParams)方法，由此可见，WorkerRunnable封装了我们要执行的异步任务。

由此可知，AsyncTask在构造的时候已经定义好要异步执行的方法doInBackground(mParams)和任务状态变化后的操作（包括失败和成功）。

 

getHandler（）：

private static Handler getHandler() {         synchronized (AsyncTask.class) {             if (sHandler == null) {                 sHandler = new InternalHandler();             }             return sHandler;         }     }       private static class InternalHandler extends Handler {         public InternalHandler() {             super(Looper.getMainLooper()); //获取主Looper,将Handler与MainLooper绑定         }           @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;             }         }     }

 

AsyncTask的执行：

 

@MainThread 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(); //运行在UI线程中，在提交任务之前；       mWorker.mParams = params;     exec.execute(mFuture); //运行提交任务到线程池；     return this; }     public final AsyncTask<Params, Progress, Result> execute(Params... params) {         return executeOnExecutor(sDefaultExecutor, params);     }

 

一般AsyncTask执行有两种：

async.execute(“”);//默认串行化执行

async.executeOnExecutor(AsyncTask. THREAD_POOL_EXECUTOR, “”);//并行化执行

 总结：