AsyncTask源码分析

开始分析

从最常调用的 execute(Params... params) 方法开始

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

先回调onPreExecute()，将任务params封装进mWorker，再以mFuture作为参数，调用exec的execute()方法。

ok..mWorker是啥，mFuture是什么，参数sDefaultExecutor又是什么？
别着急，一个一个地看

mWorker

private final WorkerRunnable<Params, Result> mWorker;
    
public AsyncTask() {
    mWorker = new WorkerRunnable<Params, Result>() {
        public Result call() throws Exception {
            mTaskInvoked.set(true);

            Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
            //noinspection unchecked
            return postResult(doInBackground(mParams));
        }
    };
    //...
}
private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {
    Params[] mParams;
}    

WorkerRunnable类型的mWorker封装了Params，并且实现了Callable接口。在call()方法中回调doInBackground()方法，并将结果作为参数调用postResult()方法。

postResult()其实是通过handle调用finish()方法，而finish()方法则回调我们实现的onCancelled()或onPostExecute()方法。

mFuture

private final FutureTask<Result> mFuture;

public AsyncTask() {
    //...
    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 occured while executing doInBackground()",
                        e.getCause());
            } catch (CancellationException e) {
                postResultIfNotInvoked(null);
            }
        }
    };
}

public class FutureTask<V> implements RunnableFuture<V> {
    //...
    public void run() {
        //...
        V result;
        result = c.call();
        //...
        }
    }
    //...
}

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

很简单，mFuture其实是一个Runable对象，它的run()方法调用mWorker的call()方法。

SERIAL_EXECUTOR、sDefaultExecutor和THREAD_POOL_EXECUTOR

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;

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

它们都是静态的。

THREAD_POOL_EXECUTOR是一个线程池对象，用于处理AsyncTask的异步任务

sDefaultExecutor是一个Executor对象，内部管理一个名为mTasks的队列，这个对象有两个方法，分别是scheduleNext()和实现接口的execute(Runnable r)方法。

• scheduleNext()方法是从mTasks队头取出一个Runnable任务赋值给mActive，并交由THREAD_POOL_EXECUTOR线程池处理。

• execute(Runnable r)作了以下几件事：

  1. 把传入Runnable型的参数进一步封装，执行完任务后调用scheduleNext()
  2. 将封装后的Runnable对象放入mTasks队尾
  3. 如果当前mActive为空，则调用scheduleNext()

几个问题

考虑首次调用sDefaultExecutor的execute()方法会出现什么情况？

一个任务还没执行完，再次调用sDefaultExecutor的execute()方法呢？

执行完队列的任务后，再次调用execute()方法呢？

至此，AsyncTask的基本实现原理已经了解，也弄清了几个常见方法是何时被回调的了，那么对AsyncTask的源码分析就可以告一段落了。

分析要点

1. 带着问题。常用回调是何时进行的，例如onPreExecute()、doInBackground()、onPostExecute()等。
2. 不要过多纠结细节。比如FutureTask这个类这么多方法都有什么用，我们的目的是分析AsyncTask实现原理，只要关心它是Runable类型的，以及它在run()方法中调用mWorker的call()方法就行了。
3. 注意分析顺序，比如从我们调用的execute(Params... params)方法开始，查看它的实现。
4. 弄清楚其中关键语句所涉及到的对象是怎么作用的。如：
   1. mWorker封装任务Params，在call()方法中回调doInBackground()和onPostExecute()；
   2. exec是类的对象（静态）sDefaultExecutor，它负责管理所有任务的执行顺序；
   3. mFuture封装mWorker，并作为Runnable对象被exec管理。
5. 多使用快捷键进行代码跳转，比如点击鼠标中键进入方法体；用鼠标大拇指两个健控制前进和后退。
6. 还有什么姿势，希望大家也能参与总结。