Android AsyncTask 源码分析

网上已经有太多的AsyncTask源码分析，而且大牛们都写的比我好，但是我还是决定尝试自己写一篇，因为这是我第一次尝试去阅读源码，写这篇blog的目的是为了巩固下。

正文

AsyncTask 需要传入三个泛型参数，分别是表示传入的参数Params， 用于表示进度的Progress，和返回结果Result。
一个简单的模版：

class DownloadTask extends AsyncTask<Void, Integer, Boolean> {  

    @Override  
    protected void onPreExecute() {  
        //用于任务执行前的UI操作 
    }  

    @Override  
    protected Boolean doInBackground(Void... params) {  

       //后台费时任务的 执行
    }  

    @Override  
    protected void onProgressUpdate(Integer... values) {  
      //用于后台任务的执行中反馈 进度到UI界面
    }  

    @Override  
    protected void onPostExecute(Boolean result) {  
       //任务结束后，对UI的操作
    }
} 

以下开始分析源码：

---

首先进入构造函数

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

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

必须在UI线程中构建，其中的WorkerRunnable 继承了CallBack，只不过多传一个参数进去。 再将WorkerRunnable 的对象mWorker以参数形式传给了FutureTask的对象mFuture.
在这里面，并没有进行任何操作，只是进行了赋值而已。

接着，要执行该任务的时候，需要调用execute()，这里的源码为：

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

再跳到其中的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();

        mWorker.mParams = params;
        exec.execute(mFuture);

        return this;
    }

这里我们能发现，调用了onPreExecute(),因为此时还没有进入子线程，还存于主线程UI 线程中，所以可以在onPreExecute()中处理一些UI 操作，如弹出一个进度条之类的。
然后，程序进入到exec.execute(mFuture); 其中的mFuture中包含了传进来的参数，和传出去的result。
这里的exec 为上图中的sDefaultExecutor， 而这个sDefaultExecutor在前面其实已经定义过了，看 一下定义的代码：

private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;

而其中的SERIAL_EXECUTOR 又已提前定义好了是：

public static final Executor SERIAL_EXECUTOR = new SerialExecutor();

所以exec其实为内部的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);
            }
        }
    }

代码也是很简单的，运行代码的部分就在r.run()中，接下来就一定会走到scheduleNext()函数中，而这个函数也很明显，就是单纯的指向下一个任务而已。
这里需要注意的是这两个方法都是用synchronized 修饰过的方法，这就说明如果每次只能响应一个任务，当任务池总有很多任务时，会一个任务接着一个任务的执行，并不会并发执行。
如果你需要并发执行的话，你需要传入一个自定义的Executor。
再回到刚才的说到的r.run()函数中，可以发现r是一个Runable型的参数，而这参数其实就是mFuture中的runable。
而mFuture是FutureTask的实例，那接下就是看FutureTask的run()的具体实现：

   public void run() {
        if (state != NEW ||
            !U.compareAndSwapObject(this, RUNNER, null, Thread.currentThread()))
            return;
        try {
            Callable<V> c = callable;
            if (c != null && state == NEW) {
                V result;
                boolean ran;
                try {
                    result = c.call();
                    ran = true;
                } catch (Throwable ex) {
                    result = null;
                    ran = false;
                    setException(ex);
                }
                if (ran)
                    set(result);
            }
        } finally {
            // runner must be non-null until state is settled to
            // prevent concurrent calls to run()
            runner = null;
            // state must be re-read after nulling runner to prevent
            // leaked interrupts
            int s = state;
            if (s >= INTERRUPTING)
                handlePossibleCancellationInterrupt(s);
        }
    }

看到result = c.call()这行，这个call 应该就是一开始初始化的mWork对象。
我们再去找其中的call()的实现部分。
这就又回到构造函数，构造函数中有一段：

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

如果程序运行到这里，将标志这个任务已经激活，在这里执行了doInBackground(),因为是执行在runnable中的，所以doInBackground()是运行在子线程的，所以可以放入一些费时操作
在接下看 postResult（）这个函数：

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

这里就是Handler发送了一条Message，看看其中的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());
        }

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

原来发送message的Handler是内部的InternalHandler()。这个内部也十分熟悉，就是根据标志位，分别处理对应的finishe()函数和其中的onProgressUpdate()函数。
而其中的finish()的内部为：

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

其中调用了onPostExecute()。
而之前提到过onPostExecute() 和onProgressUpdate()都是对UI的操作，所以操作必须回到主线程中。
这里注意到该函数是静态函数，而静态函数在类第一次加载时，就会调用，所以这就解释了为什么AsyncTask 一定要在主线程创建的原因。

到这里，AsyncTask 大致流程已经全部走了一遍。