AsyncTask源码阅读

　　AsyncTask是Android系统封装的多线程工具类。它管理着线程池，控制着合理的执行中的线程的个数。同时，它还提供了，执行前，执行中，执行后的接口，方便线程的管理与使用。

　　下面，我们来阅读一下AsyncTask的源码，才疏学浅，不能多么深刻的理解，但相信在阅读过程中，能有一些意想不到的收获。

　　

public abstract class AsyncTask<Params, Progress, Result> {
    private static final String LOG_TAG = "AsyncTask";

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

　　首先，我们可以看到，AsyncTask是一个虚类。成员变量非常多，我们一个一个来认识。

　　LOG_TAG没什么好说的。

　　CPU_COUNT顾名思义就是当前设备的CPU数量。其中Runtime是让app获取虚拟机运行环境的类，不能直接创建，但可以获取它的引用。我们从中取得可用的处理器有多少。

　　接下来的CORE_POOL_SIZE和MAXIMUM_POOL_SIZE即是核心线程数和最大线程数。

　　KEEP_ALIVE在ThreadPoolExecutor中有所描述：keepAliveTime when the number of threads is greater than the core, this is the maximum time that excess idle threads will wait for new tasks before terminating。

　　然后，是一个静态私有的线程工厂。它负责新建线程，其中mCount 是一个原子Integer。虽然没看后面，但我猜想，由于线程工厂sThreadFactory是静态的，可能会有多个线程来读写这个sThreadFactory.mCount因此，它需要是一个线程安全的原子数。getAndIncrement()是后置递增的方法，效果类似于i++，但它本身是线程安全的，而i++不是线程安全的。通过newThread方法，sThreadFactory即新建了以当前已有线程数为名字的新线程。

　　sPoolWorkQueue是一个BlockingQueue（阻塞队列）。即如果队列为空，我的取操作将会被阻塞，直到有元素进入队列为止；如果队列为满，我的写入操作将会被阻塞，直接有元素被取走留出空位为止。其他的则和基本队列一样，遵循FIFO原则。而LinkedBlockingQueue则是在构造方法中可以很方便的确定它的长度。这个作为正在工作的线程队列是一个很合适的数据结构。

　

    public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
    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);
            }
        }
    }

　　接下来，AsyncTask定义了一个特殊的Executor并创建了它的实例。看看这个类，我们就会发现，其中有一个容器叫ArrayDeque，用来存放我们的任务。

　   它是一个可以调整大小的双端队列

　　数组双端队列没有容量限制，使他们增长为必要支持使用。

　　它们不是线程安全的;如果没有外部同步。

　　不支持多线程并发访问。

　　null元素被禁止使用在数组deques。

　　它们要比堆栈Stack和LinkedList快。mTasks.offe()的主要作用是从双端队列的尾部insert元素，而mTasks.poll()的作用是从双端队列头部取出元素。

　　有了以上补充知识，现在我们来看看这个类到底是如何工作的。当执行器执行任务时，首先，我们将一个新的Runnable推入任务队列中。如果任务当前活动任务为空则执行scheduleNext()方法，执行队列中的下一个任务。在scheduleNext()方法中，我们可以看到代码先从mTasks中poll出队首的任务，如果不为空，则让线程池去执行它。执行的过程是先执行任务本身的工作（即r.run()），执行完成后，执行scheduleNext()去寻找下一个任务。

    private static final int MESSAGE_POST_RESULT = 0x1;
    private static final int MESSAGE_POST_PROGRESS = 0x2;

    private static final InternalHandler sHandler = new InternalHandler();

    private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
    private static class InternalHandler extends Handler {
        @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;
            }
        }
    }

　　这里定义了一个handler，用于接收进行中的线程发回来的消息。主要接收其他线程完成，和其他线程进度通知两类消息。

　　我们先来看看AsyncTaskResult类

    @SuppressWarnings({"RawUseOfParameterizedType"})
    private static class AsyncTaskResult<Data> {
        final AsyncTask mTask;
        final Data[] mData;

        AsyncTaskResult(AsyncTask task, Data... data) {
            mTask = task;
            mData = data;
        }
    }

　　AsyncTaskResult中有两个成员，一个是AsyncTaskResult封装的任务，另一个Data应该是任务的进度。

　　result.mTask.finish(result.mData[0])的代码：

　　

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

　　任务在取消或结束时会有这样两个方法。方法本身内容是空的，我们可以继承AsyncTask，重写这两个方法满足业务逻辑。

　　 private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
    private final WorkerRunnable<Params, Result> mWorker;
    private final FutureTask<Result> mFuture;

　　FutureTask　

　　一个可取消的异步运算，这个类实现了Fututre的接口，可以开始和取消一个运算操作，判断这个操作是否已经完成了，和重新得到运算操作的结果。运算的结果仅仅在运算结束完成后被恢复，get的方法将会阻塞程序，如果这个运算操作还没有完成的话。一旦运算操作完成了，这个操作就不能重新开始或者取消了。

　　这个类过去常常用于包装一个Callable or Runnable 类的。因为FutureTask实现了runnable借口，一个FutureTask可以实现线程池中的execution方法。

除了是一个单独的类之外，这个类还提供了可能有之用途定制任务classed的保护功能.

　　

    private final AtomicBoolean mCancelled = new AtomicBoolean();
    private final AtomicBoolean mTaskInvoked = new AtomicBoolean();

　　接下面就是两个线程安全的Boolean型，记录任务是否已被取消和任务是否已被调用，两个状态。

    /**
     * Indicates the current status of the task. Each status will be set only once
     * during the lifetime of a task.
     */
    public enum Status {
        /**
         * Indicates that the task has not been executed yet.
         */
        PENDING,
        /**
         * Indicates that the task is running.
         */
        RUNNING,
        /**
         * Indicates that {@link AsyncTask#onPostExecute} has finished.
         */
        FINISHED,
    }

　　这里一个枚举型，用来区分任务的状态，未开始、已开始、已完成。

　　

　　以上AsyncTask的成员变量就阅读完毕。接下来，开始看AsyncTask中的方法。

　

    /** @hide Used to force static handler to be created. */
    public static void init() {
        sHandler.getLooper();
    }

    /** @hide */
    public static void setDefaultExecutor(Executor exec) {
        sDefaultExecutor = exec;
    }

　　前两个方法比较简单易懂。用@hide做了标记，即外部不可调用，只在内部进行的一些初始化。

　　接下来，我们将开始阅读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
                return postResult(doInBackground(mParams));
            }
        };

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

　　这个方法从整体上来看，就是创建了WorkerRunnable和FutureTask两个类的对象。我们先来看WorkerRunnable类的创建：　　

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

　　上面提到WorkerRunnable类满足了Callable的接口，程序在这里实现了它的call方法。先将任务被调用的标志位设为true，然后将当前线程设为后台线程。doInBackground是个虚方法，没有具体实现，交由子类去实现，使用过AsyncTask的都无需多说这一点，将doInBackground的结果给处理结果的方法postResult(Result r)，我们来看看postResult(Result r)的实现。　　

    private Result postResult(Result result) {
        @SuppressWarnings("unchecked")
        Message message = sHandler.obtainMessage(MESSAGE_POST_RESULT,
                new AsyncTaskResult<Result>(this, result));
        message.sendToTarget();
        return result;
    }

 　　代码会用Result建一个AsyncTaskResult对象，将任务和数据保存在一起，然后作为结果用message发送给sHandler。sHandler前面介绍过是一个将任务执行的进度或结果返回的类。以上WorkerRunnable就创建完成了。接下来再看FutureTask的创建过程。

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

 　　postResultIfNotInvoked()方法和postResult()方法几乎一样，只是在调用前，检查了mTaskInvoked的值。如果任务被取消，则会将result设为null。

　　接下来看到一个常用的方法

    public final boolean cancel(boolean mayInterruptIfRunning) {
        mCancelled.set(true);
        return mFuture.cancel(mayInterruptIfRunning);
    }

　　由于语义化命名，我们非常容易理解，这个方法，即是取消任务。需要传入一个boolean值，表示，如果它正在运行，是否需要中断。

　　后面有一些简单的方法比如isCancelled()，就是取前面介绍的mCancelled的值，在此就不赘述了。我们接下来看最核心的方法。execute();

　　

     /* <p>This method must be invoked on the UI thread.
     *
     * @param params The parameters of the task.
     *
     * @return This instance of AsyncTask.
     *
     * @throws IllegalStateException If {@link #getStatus()} returns either
     *         {@link AsyncTask.Status#RUNNING} or {@link AsyncTask.Status#FINISHED}.
     *
     * @see #executeOnExecutor(java.util.concurrent.Executor, Object[])
     * @see #execute(Runnable)
     */
    public final AsyncTask<Params, Progress, Result> execute(Params... params) {
        return executeOnExecutor(sDefaultExecutor, params);
    }

　　

　　

     /* <p>This method must be invoked on the UI thread.
     *
     * @param exec The executor to use.  {@link #THREAD_POOL_EXECUTOR} is available as a
     *              convenient process-wide thread pool for tasks that are loosely coupled.
     * @param params The parameters of the task.
     *
     * @return This instance of AsyncTask.
     *
     * @throws IllegalStateException If {@link #getStatus()} returns either
     *         {@link AsyncTask.Status#RUNNING} or {@link AsyncTask.Status#FINISHED}.
     *
     * @see #execute(Object[])
     */
    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();这个空方法，并将参数传给mWorker，由默认的执行器执行。默认执行器SerialExecutor执行这个任务。这又回到了SerialExecutor的初始化，里面包含了执行任务的方法，这个在前面已经介绍过了。

　　到这里，AsyncTask类的基本流程就阅读完毕了。但是里面还有一些类的工作原理不是特别清楚如FutureTask等，有待探究。

　　Done！