Android从源码分析二：AsyncTask异步任务

AsyncTask能够适当地、简单地用于 UI线程。这个类不需要操作线程(Thread)就可以完成后台操作将结果返回UI。
异步任务的定义是一个在后台线程上运行，其结果是在 UI线程上发布的计算。 异步任务被定义成三种泛型类型： Params，Progress和 Result；和四个步骤： begin , doInBackground，processProgress 和end。

简而言之，AsyncTask也是为了解决 “耗时操作过程中，UI经常需要更新”的问题。

基本用法：
AysncTask必须被继承使用。子类至少覆盖一个方法 (doInBackground(Params…))，最经常覆盖另一个(onPostExecute(Result).)下面是一个子类的例子：

 private class DownloadFilesTask extends AsyncTask<URL, Integer, Long> {
     protected Long doInBackground(URL... urls) {
         int count = urls.length;
         long totalSize = 0;
         for (int i = 0; i < count; i++) {
             totalSize += Downloader.downloadFile(urls[i]);
             publishProgress((int) ((i / (float) count) * 100));
             // Escape early if cancel() is called
             if (isCancelled()) break;
         }
         return totalSize;
     }
     protected void onProgressUpdate(Integer... progress) {
         setProgressPercent(progress[0]);
     }
     protected void onPostExecute(Long result) {
         showDialog("Downloaded " + result + " bytes");
     }
 }

一旦创建，一个任务执行起来就非常简单：

 new DownloadFilesTask().execute(url1, url2, url3);

AsyncTask的泛型类型
这三个类型被用于一个异步任务，如下：
1. Params，启动任务执行的输入参数
2. Progress，后台任务执行的百分比
3. Result，后台计算的结果类型
在一个异步任务里，不是所有的类型总被用。假如一个类型不被使用，可以简单地使用 Void类型：

 private class MyTask extends AsyncTask<Void, Void, Void> { ... }

4个步骤：

当一个异步任务被执行，任务经过四各步骤：
1．onPreExecute()，在UI线程上调用任务后立即执行。这步通常被用于设置任务，例如在用户界面显示一个进度条。
2．doInBackground(Params…)，后台线程执行onPreExecute()完后立即调用，这步被用于执行较长时间的后台计算。异步任务的参数也被传到这步。计算的结果必须在这步返回，将传回到上一步。在执行过程中可以调用publishProgress(Progress…)来更新任务的进度。
3．onProgressUpdate(Progress…),一次呼叫 publishProgress(Progress…)后调用 UI线程。执行时间是不确定的。这个方法用于当后台计算还在进行时在用户界面显示进度。例如：这个方法可以被用于一个进度条动画或在文本域显示记录。
4．onPostExecute(Result), 当后台计算结束时，调用 UI线程。后台计算结果作为一个参数传递到这步。

线程规则：
有一些线程规则必须去遵守，这个类才会正确的工作:
· 任务实例必须创建在 UI线程
· execute(Params…)必须在 UI线程上调用
· 不要手动调用onPreExecute(), onPostExecute(Result), doInBackground(Params…), onProgressUpdate(Progress…)
· 这个任务只执行一次（如果执行第二次将会抛出异常）

源码分析：
首先我们来看一下他的构造方法：

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

这段代码虽然看起来有点长，但实际上并没有任何具体的逻辑会得到执行，只是初始化了两个变量，mWorker和mFuture，并在初始化mWorker的时候将Params, Result作为参数传入，在初始化mFuture的时候将mWorker作为参数传入。mWorker是一个Callable对象，mFuture是一个FutureTask对象，这两个变量会暂时保存在内存中，稍后才会用到它们。

接着如果想要启动某一个任务，就需要调用该任务的execute()方法，因此现在我们来看一看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;
    }

首先，判断该异步任务还未启动，然后设置它的status为running，因为前面线程规则里面说了，这个任务只执行一次(如果执行第二次将会抛出异常)。
然后执行onPreExecute();因此证明了onPreExecute()方法会第一个得到执行。
接着就是把params通过mWorker传给mFuture执行Executor的execute()方法;
最后返回this。
可是execute怎么执行的呢？我们来看一下Executor：

public interface Executor {
    void execute(Runnable command);
}

Executor是一个接口，具体的执行是由他的实现类。我们在AsyncTask里找到之前传进来的参数sDefaultExecutor是这么定义的：
public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
我们看到SerialExecutor类是AsyncTask里面的内部类,代码如下：

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

从第9行我们看到调了r.run();方法，这里r对象就是是前面传过来的mFuture;所以我们找到 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);
        }
    }

从12行代码中的 result = c.call(); 我们看到调了callable对象的call()方法，这里callable对象就是AysncTask构造方法里面的传过来的mWorker；这里我们单独拿出来再看一下：

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

几经周转，我们终于从第6行代码中看到doInBackground()方法的执行，然后再把result交给postResult()处
；我们来看postResult()的代码如下：

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

这里使用getHandler()对象发出了一条消息，消息中携带了MESSAGE_POST_RESULT常量和一个表示任务执行结果的AsyncTaskResult对象。
我们来看一下getHandler（）的代码：

private static Handler getHandler() {
        synchronized (AsyncTask.class) {
            if (sHandler == null) {
                sHandler = new InternalHandler();
            }
            return sHandler;
        }
    }

这个getHandler()对象是InternalHandler类的一个实例，那么稍后这条消息肯定会在InternalHandler的handleMessage()方法中被处理。
InternalHandler的源码如下所示：

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_POST_RESULT消息，就会去执行finish()方法，如果这是一条MESSAGE_POST_PROGRESS消息，就会去执行onProgressUpdate()方法。
那么finish()方法的源码如下所示：

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

很简单，如果当前任务取消了，就会调用onCanceled()方法，没有取消就会调用onPostExecute()方法。这里一路传过来的都是MESSAGE_POST_RESULT消息，
那什么时候会传MESSAGE_POST_PROGRESS的消息呢？相信用过AsyncTask的童鞋们都猜到了，在publishProgress（）方法里面，源码如下：

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

如果当前任务还在的话，调用此方法就会向InternalHandler发送包含MESSAGE_POST_PROGRESS常量和AsyncTaskResult对象的消息。
正因如此，在doInBackground()方法中调用publishProgress()方法才可以从子线程切换到UI线程，从而完成对UI元素的更新操作。
其实也没有什么神秘的，因为说到底，AsyncTask也是使用的异步消息处理机制，只是做了非常好的封装而已。