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

本文主要是介绍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 calledif (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 uncheckedResult result = doInBackground(mParams);Binder.flushPendingCommands();return postResult(result);}};mFuture = new FutureTask<Result>(mWorker) {@Overrideprotected 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 interruptsint 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 uncheckedResult 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"})@Overridepublic void handleMessage(Message msg) {AsyncTaskResult<?> result = (AsyncTaskResult<?>) msg.obj;switch (msg.what) {case MESSAGE_POST_RESULT:// There is only one resultresult.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也是使用的异步消息处理机制，只是做了非常好的封装而已。

这篇关于Android从源码分析二：AsyncTask异步任务的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！

---