AsyncTask异步任务总结以及源码分析

AsyncTask异步任务

上一篇文章中，介绍了Java与Android中线程与线程池的应用，具体可以参考连接：

同步与异步的概念

在文章开始，首先提一下同步与异步的概念。
同步，就是发出一个功能调用时，在没有得到结果之前，该调用就不返回或继续执行后续操作。
异步，就是当一个异步过程调用发出后，调用者在没有得到结果之前，就可以继续执行后续操作。当这个调用完成后，一般通过状态、通知和回调来通知调用者。体现在Android中，比如我们进行一项下载任务，在没有返回结果的时候，可以暂时先去做其他的任务，当这个下载任务完成后，回调通知我们，根据拿到的结果做相应的操作。AsyncTask就是Android中处理异步的一种方式。

主线程与子线程

我们都知道，在Android中，所有的耗时操作应该放到子线程中执行，而对UI的更新操作则只能在UI线程，即主线程中更新，那么当耗时操作执行完，我们怎么通知主线程并作出相应的响应呢？实际上在Android中，提供了以下几种机制来解决这个问题。
- activity的runOnUIThread(runnable)方法；
- view的post(runnable)方法；
- handler机制(会在后续的文章中主要介绍)；
- AsyncTask异步任务；

AsyncTask简介

举一个情景的例子，比如我们要从网上下载一张图片，下载完成后在一个ImageView中展示出来，如果使用最基本的Thread + activity.runOnUIThread(runnable)或者view.post(runnable)方法来完成这个业务逻辑，每次都需要写很多的代码，而使用Android中提供AsyncTask来完成，利用提供的响应的API处理起来则更加的方便。
AsyncTask的底层实际上也是有Handler以及Thread实现的。

AsyncTask的泛型参数

AsyncTask是一个抽象类，其中有3个泛型，当我们使用它的时候，需要自定义一个类来继承它，并为AsyncTask指定对应的泛型，下面我们首先来认识一下这3个参数。

public abstract class AsyncTask<Params, Progress, Result>

泛型	意义
Params	在执行AsyncTask时需要传入的参数，则使用这里指定相应的的泛型。
Progress	在任务执行时，如果需要在界面上显示当前的进度，则使用这里指定相应的的泛型。
Result	当任务执行完毕后，如果需要对结果进行返回，则使用这里指定的泛型作为返回值类型。

比如上面举得应用场景中，通过访问网络下载一张图片，最后显示在ImageView中，而不需要显示下载的进度，则我们就可以这样定义：

class MyAsyncTask extends AsyncTask<String, Void, Bitmap>

AsyncTask的源码分析：

在执行new MyAsyncTask().execute("xxxxx")方法中，首先执行构造方法，让我们看一下在构造方法中，都执行了哪些操作？

在构造方法中初始化了WorkerRunnable对象mWorker以及FutureTask对象mFuture。

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());
            } 
            //此处省略....
        }
    };
}

当执行execute()方法时，继续调用了executeOnExecutor()方法。

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

下面来看在executeOnExecutor()方法中做了什么，首先调用了onPreExecute()方法，然后将将传进来的参数赋给WorkerRunnable对象mWorker的mParams，然后调用sDefaultExecutor的execute()方法。

public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,
            Params... params) {
        //此处代码省略
        mStatus = Status.RUNNING;
        onPreExecute();//首先调用这个方法
        mWorker.mParams = params; // 将传进来的参数赋给WorkerRunnable对象mWorker
        exec.execute(mFuture); //exec是上面传进来的sDefaultExecutor，一个Executor的实现类

        return this;
    }

我们继续向下看，sDefaultExecutor的execute()中，执行了里面的runnable的run()方法，其中的r就是mFuture的run()方法。

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();//这个r就是传递进来的mWorker,即调用mWorker的run方法
                    } finally {
                        scheduleNext();
                    }
                }
            });

而mFuture的run方法中中，执行了call方法，其中的callable是构造方法中传递进来的mWorker，最终执行了mWorker的call方法postResult(doInBackground(mParams))，在这里执行了doInBackground()方法。

 public void run() {
         //省略...
        try {
            Callable<V> c = callable; //构造方法中传进来的mWorker
            if (c != null && state == NEW) {
                V result;
                boolean ran;
                try {
                    result = c.call();
                    ran = true;
                } catch (Throwable ex) {
                    result = null;
                    ran = false;
                    setException(ex);
                }

在postResult方法中，创建了message对象，将结果赋值给message.obj，然后执行message.sendToTarget()方法，里面又执行了target.sendMessage(this)，target是一个handler对象，就是这个message绑定的handler。

 private Result postResult(Result result) {
        @SuppressWarnings("unchecked")
        Message message = sHandler.obtainMessage(MESSAGE_POST_RESULT,
                new AsyncTaskResult<Result>(this, result)); //里面调用Message.obtain(this, what, obj);
        message.sendToTarget(); //调用target.sendMessage(),即InternalHandler 对象sHandler，发送之后回调handleMessage方法
        return result;
    }

public static Message obtain(Handler h, int what, Object obj) {
    Message m = obtain();
    m.target = h; //message.target就是上面的sHandler
    m.what = what;
    m.obj = obj;

    return m;
}

上面sHandler是一个InternalHandler对象，继承了Handler，发送消息后，就会回调它的handlerMessage方法，拿到刚才doInBackground方法返回的结果。

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

finish()方法源码如下，我们可以看到如果未取消的话，最终调用onPostExecute()方法，onPostExecute()就是在创建InternalHandler的线程，即主线程执行，因此可以在这个方法中进行更新UI的操作。

private void finish(Result result) {
        if (isCancelled()) {
            onCancelled(result);
        } else {
            onPostExecute(result);//在主线中执行，可以进行UI操作或与用户交互
        }
        mStatus = Status.FINISHED;
    }

演示Demo

下面贴出一段代码，来验证上面源码分析中的几个方法所在的线程以及执行的顺序。

package com.csdn.lhy;

import java.io.IOException;
import java.net.HttpURLConnection;

import android.app.Activity;
import android.graphics.Bitmap;
import android.os.AsyncTask;
import android.os.Bundle;
import android.os.SystemClock;
import android.util.Log;
import android.view.View;

/**
 * @author lhy
 * @Date 2016-9-7
 */
public class MainActivity extends Activity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

    }

    public void downImg(View view) {
        new MyAsyncTask().execute();
    }

}

class MyAsyncTask extends AsyncTask<Void, Integer, Bitmap> {

    public static final String TAG = "lhy";

    @Override
    protected void onPreExecute() {
        debugLog("onPreExecute");
    }

    @Override
    protected Bitmap doInBackground(Void... params) {
        debugLog("doInBackground");
        for (int i = 0; i <10; i++) {
            SystemClock.sleep(500);//模拟耗时操作
            publishProgress((i+1)*10);
        }

        return null;
    }

    @Override
    protected void onProgressUpdate(Integer... values) {
        debugLog("onProgressUpdate,任务完成度"+values[0]+"%");
    }

    @Override
    protected void onPostExecute(Bitmap result) {
        debugLog("onPostExecute");
    }

    public void debugLog(String msg) {
        Log.d(TAG, msg + "在线程：" + Thread.currentThread().getName() + "中执行");
    }


}

开启异步任务,结果如下：

09-07 22:16:10.566: D/lhy(1961): onPreExecute在线程：main中执行
09-07 22:16:10.566: D/lhy(1961): doInBackground在线程：AsyncTask #1中执行
09-07 22:16:11.066: D/lhy(1961): onProgressUpdate,任务完成度10%在线程：main中执行
09-07 22:16:11.566: D/lhy(1961): onProgressUpdate,任务完成度20%在线程：main中执行
09-07 22:16:12.066: D/lhy(1961): onProgressUpdate,任务完成度30%在线程：main中执行
09-07 22:16:12.566: D/lhy(1961): onProgressUpdate,任务完成度40%在线程：main中执行
09-07 22:16:13.070: D/lhy(1961): onProgressUpdate,任务完成度50%在线程：main中执行
09-07 22:16:13.570: D/lhy(1961): onProgressUpdate,任务完成度60%在线程：main中执行
09-07 22:16:14.070: D/lhy(1961): onProgressUpdate,任务完成度70%在线程：main中执行
09-07 22:16:14.570: D/lhy(1961): onProgressUpdate,任务完成度80%在线程：main中执行
09-07 22:16:15.070: D/lhy(1961): onProgressUpdate,任务完成度90%在线程：main中执行
09-07 22:16:15.570: D/lhy(1961): onProgressUpdate,任务完成度100%在线程：main中执行
09-07 22:16:15.570: D/lhy(1961): onPostExecute在线程：main中执行

AsyncTask的方法总结

根据上面的流程源码分析，使用AsyncTask，对下面的几个方法的调度线程以及功能进行总结。

onPreExecute():

根据上面的源码分析，这个方法会在子线程执行异步任务前调用，是在主线程中执行的，可以进行UI操作。

doInBackground(Params):

 protected abstract Result doInBackground(Params... params);

抽象方法，必须要子类重写的方法。

这个方法中的代码都会在子线程中执行，因此是不能进行UI更新操作的，我们所有的耗时操作都放在这个方法中执行，这个方法中的Params中就是第一个泛型中传递进来的参数。

onProgressUpdate(Progress)：

这个方法用可以用来异步任务进行中的时候，更新当前的处理进度，也是在主线程中执行。

onPostExecute(Result)：

当异步任务执行完毕后调用，最终的处理结果即Result泛型代表的结果，这个方法在主线程中执行，因此可以进行UI界面的更新。

演示Demo下载地址

Demo下载地址，欢迎下载

本篇文章暂时就介绍到这里，欢迎大家评论与分享，谢谢。

参考文章：郭霖的文章