Android 异步任务：AsyncTask机制源码详细版解析------从入门到升天

最新推荐文章于 2019-09-19 13:21:47 发布

鸽一门

最新推荐文章于 2019-09-19 13:21:47 发布

阅读量2.2k

点赞数

分类专栏： Android 学习笔记 Android 源码分析文章标签： android asynctask 异步源码线程

本文链接：https://blog.csdn.net/ITermeng/article/details/52159831

版权

Android 学习笔记同时被 2 个专栏收录

54 篇文章 7 订阅

订阅专栏

Android 源码分析

10 篇文章 2 订阅

订阅专栏

转载注明出处 3x :) http://blog.csdn.net/itermeng/article/details/52159831

提示：对Android 异步任务，AsyncTask机制不太熟悉的建议先了解学习一下，这里有AsyncTask学习和基本使用：
http://blog.csdn.net/itermeng/article/details/52681493
熟悉用法之后再查看其源码，对异步任务理解才会更加透彻！

相信大家对AsyncTask机制都不陌生？基本的使用的方法和注意事项都清楚，编写一个类，继承AsyncTask类，必须重写doInBackground（）方法，运行在子线程，耗时的操作在此执行；onPostExecute（）方法在doInBackground（）执行完后被回调，运行在主线程，可进行UI更新；若需要显示更新的进度，可重写onProgressUpdate（）方法。

在一开始学习异步任务AsyncTask时，我们就在被各种教程传输这些理论知识，确实对于它已经了然于心，可是有考虑过底层是如何详细实现AsyncTask机制的吗？为何onPreExecute（）方法最先被调用？doInBackground（）如何封装到子线程中的？onPostExecute方法回调又是如何实现的？这些方法之间是如何被联系起来的？

虽然Android已为我们封装好AsyncTask类，只有从源代码的角度去剖析才能真正掌握。（以下讲解会一步步深入，剥茧抽丝，弄清楚详细实现方式，想要彻底剖析一定要有耐心，另配有逻辑图供大家整理AsyncTask机制的逻辑流程！）

一. AsyncTask机制

1. AsyncTask基本使用：

AsyncTask<String, Integer, Object> asyncTask = new AsyncTask<String, Integer, Object>() {

    protected void onPreExecute() {};

    @Override
    protected Object doInBackground(String... params) {
        return null;
    }

    protected void onPostExecute(Object result) {};

    protected void onProgressUpdate(Integer[] values) {};

};
asyncTask.execute("params")

问题：

onPreExecute（） 方法为何在主线程中执行？为何最先执行？
doInBackground（）方法为何在子线程中执行？如何实现该方法执行完就回调 onPostExecute（） 方法？
onPostExecute（） 方法为何在主线程中进行？

以上为AsyncTask的基本使用：new 一个AsyncTask类，重写需要逻辑实现的方法。调用execute方法，任务就开始执行了。所以，看源代码就从这个入口execute方法开始分析：

AsyncTask的execute方法

public final AsyncTask<Params, Progress, Result> execute(Params... params) {
    //(1)检测状态
    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)");         
        }
    }
    //(2)修改状态
    mStatus = Status.RUNNING;

    //（3）调用onPreExecute方法
    onPreExecute();

    //（4）把参数赋值给mWorker对象
    mWorker.mParams = params;

    //（5）线程池对象执行mFuture
    sExecutor.execute(mFuture);

    return this;
}

在此方法体中，开始执行异步任务，逐步骤分析：

(1)检测状态

若状态为RUNNING：顾名思义为正在执行，抛出异常“无法执行，该任务正在执行”。所以说一旦new 了一个AsyncTask，连续调用两次execute方法，肯定会报错。

若状态为FINISHED：顾名思义为已经执行过，抛出异常“无法执行，该任务已经执行过，一个任务只能执行一次”。相当于AsyncTask类中的doInBackground方法已经执行完，回调过onPostExecute方法了，再次调用execute方法，比如想再执行一次下载任务，就会报错！

由以上我们可以得出一个结论：execute方法只能调用一次，若想多次执行，多次的new一个AsyncTask类，再去调用对应的execute方法。

(2)修改状态

在进过步骤一后（代表状态判断未报错），即可修改状态为RUNNING（即该任务正在执行）。

（3）调用onPreExecute方法

看到onPreExecute方法是不是觉得倍感亲切，虽然我们在new一个AsyncTask类重写其方法时，很少会去重写该方法。现在我们知道此方法为何是在主线程中执行的了：

因为最开始new一个AsyncTask后，执行execute方法这些步骤本就是在主线程中执行的，而execute方法中又调用了onPreExecute方法，所以自然其运行在主线程，并且也是以上四个方法中最先执行的方法！

【AsyncTask机制逻辑流程图 v1】：
这里写图片描述

（4）把参数赋值给mWorker对象

mWorker.mParams = params;

以上代码中的params就是一开始调用AsyncTask的execute方法时传进来的参数，此参数被保存到mWorker对象中的mParams变量中，可是这个mWorker又是什么？首先来看它的声明：

privaet final WorkerRunnable<Params , Result> mWorker;

mWorker是一个WorkerRunnable类，继续深入，查看其具体实现：

private static class InternalHandler extends Handler{
    @Override
    public void handleMessage(MMessage msg){
        ...//我也很重要，后面再讲
    }

    //☆☆☆看我☆☆☆
    private static abstact class WorkerRunnable<Params, Result> implements Callable<Result>{
        Params[] mParams;
    }
    ...
}

以上可得知，WorkerRunnable是一个InternalHandler 类（重要的一个类）的内部类，有一个mParams数组，来保存了一开始调用AsyncTask的execute方法时传进来的参数！

【AsyncTask机制逻辑流程图 v2】：
这里写图片描述

继续分析，此类还实现了一个Callable接口，查看具体实现：

public interface Callable<V>{
        V call() throws Exception;
}

这个Callable接口中只有一个call()方法，方法作用？何时调用？先留下一个疑问，我们后文分解。既然”mWorker对象的声明“这一个线索已经挖到底了，就寻找下一个突破口，查看它的初始化：

public AsyncTask(){
    //☆☆☆看我☆☆☆
    mWorker = new WorkerRunnable<Params, Result>() {
        public Result call() throws Exception {
            Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
            return doInBackground(mParams);
        }
    };

    mFuture = new FutureTask<Result>(mWorker){
        ...//我也很重要，后面再讲
    }
}

mWorker的初始化部分在AsyncTask的构造方法中，代表最开始new 一个 AsyncTask时，mWorker对象就已经被初始化了。以上分析，其实mWorker就是一个Callable类型对象，它在初始化时new完后，覆盖了一个call方法，而call方法的返回值正是调用doInBackground（）方法的返回值，并且在调用的时候传递了参数mParams。

【AsyncTask机制逻辑流程图 v3】：
这里写图片描述

现在问题二就来了，这个doInBackground（）方法是如何运行在子线程中？也就是说这个call方法何时被一个子线程调用？

莫方！先意识到这个问题，保留疑问，继续往下走。以上就是步骤四的逻辑，我们继续回到execute方法中，依次执行步骤五，来解决疑问。

（5）线程池对象执行mFuture

sExecutor.execute(mFuture);

老样子！这一行代码看不懂，首先查找sExecutor对象的声明：

private static final ThreadPool Executor sExecutor = new ThreadPoolsExecutor(CORE_POOL_SIZE,MAXIMUN_POOL_SIZE,KEEP_ALIVE,TimeUnit.SECONDS,sWorkQueue,sThreadFactory);

真面目揭晓！所以说Asynctask能够执行多个任务，是因为类中有一个线程池。回到步骤五的那行代码中，sExecutor对象执行execute方法就是往线程池中取出来一个线程，去处理括号中的内容（即mFuture），mFuture又是何物？来查看声明：

FutureTask<Result> mFuture;

得知mFuture是一个FutureTask类型，继续深入，查看具体实现：

public class FutureTask<V> implements RunnableFuture<V>{
    public FutureTask(Callable<V> callable) {
    if (callable == null)
        throw new NullPointerException();
        sync = new Sync(callable);
    }
    ...
}

发现FutureTask类型又是实现了RunnableFuture，剥茧抽丝，继续深入查看具体实现：

public interface RunnableFuture<V> extends Runnable,Future<V>{
    void run();
}

可以恍然大悟了！原来这个RunnableFuture接口是实现了Runnable，所以里面就有一个run方法，这跟我们所学习的理论知识“运行子线程时一般要在run方法中执行”是非常吻合的！理解之后，这一条“mFuture的声明”线索也到底了，注意需要明确一点：执行mFuture对象就是在执行run方法！现在问题就是这个run方法在哪里被调用了？或者说mFuture在哪里覆盖重写了run方法？寻找新线索，mFuture声明完后，来查找它初始化的地方：

public AsyncTask(){
    mWorker = new WorkerRunnable<Params, Result>() {
        public Result call() throws Exception {
            Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
            return doInBackground(mParams);
        }
    };

//☆☆☆看我☆☆☆
    mFuture = new FutureTask<Result>(mWorker){
    //此处重写done方法
    @Override
    protected void done() {
        ...
        //获取doInbackground方法返回的结果
        result = get();
        ...
        //创建一个消息
        message = sHandler.obtainMessage(MESSAGE_POST_RESULT,
                new AsyncTaskResult<Result>(AsyncTask.this, result));
        //把这条消息发送给创建这个消息的Handler：target.sendMessage(this)
        message.sendToTarget();
    }
    };
}

找到mFuture 的初始化地方，乍一看到步骤四中分析的mWorker对象也是在 AsyncTask的构造方法中（即AsyncTask一new出来的时候这两个对象就都实例化了！）。并且mFuture在new 一个 FutureTask时，传了一个参数mWorker。（这里简单回顾mWorker：是一个Callable对象，有一个call方法，方法中调用了doInBackground），代表将参数mWorker存储到FutureTask类的构造方法中了，继续深入，查看FutureTask实现：

public class FutureTask<V> implements RunnableFuture<V>{
    private final Sync sync;

    public FutureTask(Callable<V> callable) {
        if (callable == null)
            throw new NullPointerException();
            sync = new Sync(callable);
    }
}

查看FutureTask的构造方法，也可以证实之前对mWorker对象的回顾，就是一个Callable类型。sync = new Sync(callable);又把mWorker封装给Sync对象，Sync为何物？查看其具体实现：


Sync(Callable<V> callable) {
    //这里的callable就是mWorker
    this.callable = callable;
}

只看Sync的构造方法即可，可得知只是做了简单的保存。这条线索“FutureTask类的声明和实现”也挖到底了，

【AsyncTask机制逻辑流程图 v4】：
这里写图片描述

回到mFuture对象初始化时（在Asynctask的构造方法中），它在new 了一个FutureTask类中，覆盖重写了父类的done方法，先暂缓done方法具体实现的分析。

我们之前说过“执行mFuture对象就是在执行run方法”！那么现在查找run方法在何处被调用：

//FutureTask类中的方法
//mFuture的run方法被调用了
public void run() {
    sync.innerRun();
}

run方法中又调用了Sync对象的innerRun方法，深入，查看其具体实现：

void innerRun() {
    ...
        //调用mWorker的call()
        result = callable.call();
        ...
        set(result);
    ...
}

在innerRun方法中，调用了callable（也就是mWorker）的call方法，因为在sync被new出来的时候，在构造方法中就已经把mWorker赋值给了callable，所以实际上是调用mWorker的call方法！所以一大悬案—–问题二“为何doInBackground方法运行在子线程”已被侦破：

mFuture的run方法肯定执行在子线程中，run方法又调用了innerRun方法，其也在子线程中，innerRun方法又调用了mWorker的call方法！其call方法中又调用了 doInBackground方法，所以它必然执行在子线程！（这一系列的推理一定要掌握）

【AsyncTask机制逻辑流程图 v5】：
这里写图片描述

理解之后，新的问题又来了，doInBackground方法如何将其返回值传给onPostExecute方法中，它是如何被回调的？怎么又在主线程中运行的？莫方！回到上面代码继续往下:
result = callable.call();
调用了mWorker的call方法后有一个返回值result
set(result);
又调用了set方法（方法在Sync对象的innerRun方法里面），将其保存起来。查看set方法具体实现：

//FutureTask类中的方法
protected void set(V v) {
     sync.innerSet(v);
}

set方法（在FutureTask类中）中又调用了Sync对象的innerSet方法，继续深入查看：

void innerSet(V v){
    ...
    ...
     if (compareAndSetState(s, RAN)) {
                result = v;
                releaseShared(0);
                //关键的done方法
                done();
                return;
      }
  }

innerSet方法中调用了done方法，怎么有点眼熟？！查看其实现：

//FutureTask类中的方法
protected void done(){}

done方法（在FutureTask类中）没有方法体，那调用此方法有何意义？但存在即合理！这个方法肯定是在new 一个FutureTask类时，将其覆盖重写了！这条线索“执行mFuture对象就是在执行run方法”已完毕，带着我们的猜测回到mFuture的初始化（AsyncTask构造方法）代码中，上面有代码，再次粘贴主要部分：

mFuture = new FutureTask<Result>(mWorker){
    //此处重写done方法
    @Override
    protected void done() {
        ...
        //获取doInbackground方法返回的结果
        result = get();
        ...
        //创建一个消息
        message = sHandler.obtainMessage(MESSAGE_POST_RESULT,
                new AsyncTaskResult<Result>(AsyncTask.this, result));
        //把这条消息发送给创建这个消息的Handler：target.sendMessage(this)
        message.sendToTarget();
    }
    };

首先是get方法，之前在FutureTask中，Sync变量保存了doInBackground的返回值！所以这里取出结果，取出来后创建了一个消息，传入了两个参数：MESSAGE_POST_RESULT（是post的一个结果）、new了一个AsyncTaskresult类，并将doInBackground的返回值传入到new 的AsyncTaskresult的参数中。

【AsyncTask机制逻辑流程图 v6】：
这里写图片描述

其实创建消息时接受的两个参数，一个是post结果，一个是Message里面的Object，用Object保存了一个AsyncTaskresult对象，这个对象就保存有返回值。最后调用了message 的 sendToTarget方法，这个方法感觉很陌生，继续深入，查找其实现：

public void sendToTarget(){
    target.sendMessage(this);
}

target调用了sendMessage方法，其实这个target就是一个hanlder，来发送消息，由于sendToTarget方法在Message内部，所以传入参数this，就是自身。一发消息就会发到Handler中，查找Handler何处声明：

private static final InternalHandler sHandler =  new InternalHandler();

Handler在这里new 出来了，是一个InternalHandler 类，里面一定有一个hanlderMessage方法来处理接收的消息：

private static class InternalHandler extends Handler{
    public void handleMessage(Message msg) {
        AsyncTaskResult result = (AsyncTaskResult) msg.obj;
        switch (msg.what) {
            case MESSAGE_POST_RESULT:
                //调用finish方法
                result.mTask.finish(result.mData[0]);
                break;
             ...
             ...
        }
    }
}

果然如此，声明了一个内部类继承于Handler，重写了父类的handleMessage方法，所以之前mFuture对象重写的done**方法**中发送的消息会发送至此！

之前创建消息的时候将doInBackground的返回值作为参数传入到AsyncTaskresult类中（也就是Message的Object类），现在将result取出来，执行了：

result.mTask.finish(result.mData[0]);

这个mTask就是之前创建消息时传入的第一个参数，也就是AsyncTask本身，mData[0]就是doInBackground的返回值。再看AsyncTask对象的finish的方法体：

private void finish(Result result) {
 if (isCancelled()) result = null;
    //调用onPostExecute方法，并传入结果
    onPostExecute(result);
    mStatus = Status.FINISHED;
}

首先看方法体中的参数result就是doInBackground的返回值，注意注意！此处就回调了onPostExecute方法，并传入结果！所以又一大悬案“onPostExecute如何在doInBackground执行完后实行回调并得到结果？”已侦破！

可是最后一大悬案“onPostExecute方法为何运行在主线程？”

是因为通过Handler发送消息实现的！通过InternalHandler发消息，一发就跑到主线程了呀！

二. AsyncTask机制逻辑流程图【最终版】

这里写图片描述

三. AsyncTask机制归纳

AsyncTask 异步任务, 主要包含两个关键类:

（1）InternalHandler : 消息处理器, 用于处理线程之间消息.

（2）ThreadPoolExecutor : 线程池, 用于处理耗时任务.

归纳：

结合源代码分析之后，我们会发现主要是InternalHandler和ThreadPoolExecutor这两个类起着重要作用！

所以，Android 原生的 AsyncTask机制 就是对线程池（也就是ThreadPoolExecutor）的一个封装，使用其自定义的 Executor来调度线程的执行方式（并发还是串行），最后使用 Handler（也就是InternalHandler）来完成子线程和主线程的数据共享。