从源码分析AsyncTask

AsyncTask是Android提供的一个异步处理的方式。该方式使用较为方便，与Handler相比在代码上显得更简洁。
先来看看使用AsyncTask常用到的几个方法：
1.execute(Params… params)，执行一个异步任务，需要我们在代码中调用此方法，触发异步任务的执行。（在UI线程调用）

2.onPreExecute()，在execute(Params… params)被调用后立即执行，一般用来在执行后台任务前对UI做一些标记。

3.doInBackground(Params… params)，在onPreExecute()完成后立即执行，用于执行较为费时的操作，此方法将接收输入参数和返回计算结果。在执行过程中可以调用publishProgress(Progress… values)来更新进度信息。

4.onProgressUpdate(Progress… values)，在调用publishProgress(Progress… values)时，此方法被执行，直接将进度信息更新到UI组件上。

5.onPostExecute(Result result)，当后台操作结束时，此方法将会被调用，计算结果将做为参数传递到此方法中，直接将结果显示到UI组件上。
详细的例子网上也很多了，此处不再列举，以上也是引用的别人的博客所述。
地址：http://blog.csdn.net/liuhe688/article/details/6532519 。
此篇主要是根据源码来分析AsyncTask的原理。

AsyncTask源码分析

老套路，先看看AsyncTask的构造函数。

/**
     * Creates a new asynchronous task. This constructor must be invoked on the UI thread.
     */
    public AsyncTask() {
    //WorkerRunnable 为一个继承Callable<Result>接口的虚类
        mWorker = new WorkerRunnable<Params, Result>() {
            public Result call() throws Exception {
                mTaskInvoked.set(true);

                Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
                //noinspection unchecked
                //调用doInBackground 但并不在这开始执行
                return postResult(doInBackground(mParams));
            }
        };

        mFuture = new FutureTask<Result>(mWorker) {//初始化mFuture 
            @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);
                }
            }
        };
    }

在构造函数中进行了一些初始化工作，并且最后都调用到了postResult，在postResultIfNotInvoked(get())中，其实最后也调用到了postResult。 这里用到了
Java并发编程：Callable、Future和FutureTask。有兴趣的可以看看。
在上面的代码中，当mWorker中定义的call方法被执行时，doInBackground就会开始执行，我们定义的后台任务也就真正开始了。实际上mFuture对象封装了call方法，当mFuture对象被提交到AsyncTask包含的线程池执行时，call方法就会被调用，我们定义的后台任务也就开始执行了。到此，我们先记住要使doInBackground（）方法执行，就需要mFuture被执行，但是执行的地方还没找到。回想我们使用AsyncTask的时候，需要调用execute()方法，让程序跑起来。拿我们就先看看这个方法。

 &emp;我们建立一个继承于一个public abstract class AsyncTask

 public final AsyncTask<Params, Progress, Result> execute(Params... params) {
        return executeOnExecutor(sDefaultExecutor, params);
    }

来看看executeOnExecutor方法 和sDefaultExecutor，params参数是一直传到doInBackground方法的。
sDefaultExecutor是什么呢?通过代码可以找到

public static final Executor SERIAL_EXECUTOR = Utils.hasHoneycomb() ? new SerialExecutor() :
            Executors.newSingleThreadExecutor(sThreadFactory);


private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;

sDefaultExecutor 要不是一个 SerialExecutor要不就是一个单线程池。来看看SerialExecutor到底是什么。

private static class SerialExecutor implements Executor {

        //mTasks  缓存队列
        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);// 执行任务
            }
        }
    }

从上面的代码，可以看出首先由一个缓存队列mTasks ，该队列通过offer添加任务，通过THREAD_POOL_EXECUTOR.execute(mActive)去执行任务。那么接下来就是THREAD_POOL_EXECUTOR了。

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

很明显了THREAD_POOL_EXECUTOR就是一个线程池，并且规定了CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,TimeUnit.SECONDS等。从源码中也可以看到

    private static final int CORE_POOL_SIZE = 5;线程池大小5
    private static final int MAXIMUM_POOL_SIZE = 128;最大线程数128
    private static final int KEEP_ALIVE = 1;存活时间1s

接下来就是executeOnExecutor方法了。

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

在代码的倒数第二行exec.execute(mFuture);这个方法。还记得之前mFuture对象么，这就是他被执行的地方了。从而doInBackground方法也就能够执行了，而且还由线程池进行控制。
以上为AsyncTask 调用流程的理解。