一、概述

这篇文章中，让我们从源码的角度看一下AsyncTask的原理，最后会根据原理总结一下使用AsyncTask中需要注意的点。

二、源码解析

在AsyncTask中，有一个线程池 THREAD_POOL_EXECUTOR 和与这个线程池相关联的 Executor，它负责执行我们的任务Runnable：

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);

public static final Executor THREAD_POOL_EXECUTOR 
    = new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE, TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);

public static final Executor SERIAL_EXECUTOR = new SerialExecutor();

private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;

//这是执行Runnable的地方，调用execute会执行它，如果当前已经有一个任务在执行，那么就是把它放到队列当中。
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();                
                }            
             }        
        });
        //如果为null，那么立刻执行它；
        //如果不为null，说明当前队列中还有任务，那么等Runnable执行完之后，再由上面的scheduleNext()执行它。        
        if (mActive == null) {               
            scheduleNext();        
        }    
   }    

   protected synchronized void scheduleNext() {
        //第一次进来调用了offer方法，因此会走进去，执行上面Runnable的run()方法。        
        if ((mActive = mTasks.poll()) != null) {            
           THREAD_POOL_EXECUTOR.execute(mActive);        
        }    
    }
}

从上面可以看出，每次调用sDefaultExecutor.execute时就是执行一个任务，这个任务会被加入到ArrayDeque中串行执行，我们看一下当我们调用AsyncTask的execute方法时，任务是如何被创建并加入到这个队列当中的：

//这个静态方法，不会回调 loadInBackground 等方法。
public static void execute(Runnable runnable) {    
    sDefaultExecutor.execute(runnable);
}

//这是我们最常使用的方法，参数可以由调用者任意指定。
public final AsyncTask<Params, Progress, Result> execute(Params... params) {    
    return executeOnExecutor(sDefaultExecutor, params);
}

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();    
      mWorker.mParams = params;    
      exec.execute(mFuture);    
      return this;
}

在调用了executeOnExecutor之后，我们把传入的参数赋值给了mWorker，并把mFuture传入给Executor去执行，而从下面我们可以看到mFuture的构造函数中传入的参数正是mWorker，这两个东西其实才是AsyncTask的核心，它们是在AsyncTask的构造函数中被初始化的：

private final WorkerRunnable<Params, Result> mWorker;
private final FutureTask<Result> mFuture;

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);    
    }
};

mFuture = new FutureTask<Result>(mWorker) {    
    @Override    
    protected void done() {        
        try {
            //要求mWorker的call方法没有被调用，否则什么也不做。            
            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);        
       }    
   }
};

先看一下WorkerRunnable，实现了Callable<V>接口，增加了一个不定参数的成员变量用来传给 doInBackground，这个不定参数就是我们在execute时传入的，调用call时会执行器内部的函数，而call 时会调用doInBackground方法，这个方法执行完之后，调用postResult，注意到call和done都是在子线程当中执行的：

private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {    
    Params[] mParams;
}

我们主要看一下FutureTask，还记得最开始我们的Executor最终执行的是传入的Runnable的run方法，因此我们直接看一下它的run方法中做了什么：

public interface Runnable {
   public void run();
}

public interface Future<V> {
    boolean cancel(boolean mayInterruptIfRunning);
    boolean isCancelled();
    boolean isDone();
    V get() throws InterruptedException, ExecutionException;
    V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException;
}

public interface RunnableFuture<V> extends Runnable, Future<V> { 
    void run();
}

//我们只要关注run方法
public class FutureTask<V> implements RunnableFuture<V> {
    public void run() {
        Callable<V> c = callable;
        if (c != null && state == NEW) {
            result = c.call(); //mWorker.call()
            ran = true;
        }
        if (ran) {
            set(result);
        }
    }

    protected void set(V v) {
        finishCompletion();
    }

    private void finishCompletion() {
        done(); //mFuture.done()
        callable = null;
    }
}

那么结论就清晰了，整个的执行过程是下面这样的：

• 首先调用excuter.execute(mFuture)，把mFuture加入到队列当中
• 当mFuture得到执行时，会回调mFuture的run方法
• mFuture#run是运行在子线程当中的，它在它所在的线程中执行的mWorker#call方法
• mWorkder#call调用了doInBackground，用户通过实现这个抽象方法来进行耗时操作
• mFuture#call执行完后调用mFuture#done

在上面的过程当中，有两个地方都调用了postResult，一个是mWorkder#call的最后，另一个是mFuture#done，但是区别在于后者在调用之前会判断mTaskInvoked为false时才会去执行，也就是在mWorkder#call没有执行的情况下，这是为了避免call方法没有被执行时（提前取消了任务），postResult没有被执行，导致使用者收不到任何回调。
postResult会通过InternalHandler把当前的AsyncTask和FutureTask的结果回调到主线程当中，之后调用finish方法，它会根据调用者是否执行过cancel方法来回调不同的函数：

private void finish(Result result) {    
    if (isCancelled()) {        
        onCancelled(result);     
    } else {        
        onPostExecute(result); 
    }    
    mStatus = Status.FINISHED;
}

调用者通过重写onProgressUpdate就可以得到当前的最新进度，AsyncTask最终会把结果回调到主线程当中：

protected final void publishProgress(Progress... values) {    
    if (!isCancelled()) {          
        getHandler().obtainMessage(MESSAGE_POST_PROGRESS, new AsyncTaskResult<Progress>(this, values)).sendToTarget();    
    }
}

private static class InternalHandler extends Handler {
    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;
        }
    }
}

三、结论

经过上面的源码分析，我们有这么几个结论：

• 静态方法execute(Runnable runnable)和AsyncTask其实没什么太大关系，只是用到了里面一个静态的线程池而已，AsyncTask内部的状态都和它无关。
• 当我们对同一个AsyncTask实例调用execute(..)时，如果此时已经有任务正在执行，或者已经执行过任务，那么会抛出异常。
• 在onPreExecute()执行时，任务还没有被加入到队列当中。
• doInBackground是在子线程当中执行的，我们调用cancel后，并不一定会立即得到onCancel的回调，这是因为cancel只保证了mFuture的done方法被执行，有这么几种情况：

• 如果mWorker的call函数没有执行，那么这时mFuture的done方法被调用时，postResultIfNotInvoked是满足条件的，调用者可以立即得到onCancel回调。
• 如果mWorker的call调用了，虽然mFuture的done执行了，但是它不满足条件(!mTaskInvoked.get())，那么会一直等到doInBackground执行完所有的操作才通过return postResult返回，所以我们需要在doInBackground中通过isCancel()来判断是否需要提早返回，避免无用的等待。

• 在postResult完毕之后， onCancel和onPostExecute只会调用一个。
• 任务是和AsyncTask实例绑定的，而如果AsyncTask又和Activity绑定了，如果在执行过程中这个 AsyncTask实例被销毁了（例如Activity被重新创建），那么调用者在新的Activity中是无法收到任何回调的，因为那已经是另外一个AsyncTask了。
• 关于AsyncTask最大的问题其实是内存泄漏，因为把它作为Activity的内部类时，会默认持有Activity的引用，那么这时候如果有任务正在执行，那么 Activity 是无法被销毁的，这其实和Handler的泄漏类似，可以有以下这么一些用法：

• 不让它持有Activity的引用或者持有弱引用。
• 保证在Activity在需要销毁时cancel了所有的任务。
• 使AsyncTask的执行与Activity的生命周期无关，可以考虑通过建立一个没有UI的fragment来实现，因为在Activity重启时，会自动保存有之前add进去的Fragment的实例，Fragment持有的还是先前的 AsyncTask。
• 使用LoaderManager，把管理的活交给系统来执行。