AsyncTask深度剖析

AsyncTask是Android SDK为我们所提供的一个封装好的可以在子线程中完成耗时任务并能与主线程进行交互的一个异步操作工具类。
下面先介绍AsyncTask的基本用法，再从使用过程中所涉及到的几个关键步骤深入源码进行解析。

AsyncTask基本使用

AsyncTask是一个抽象类，通常需要我们自己实现一个类来继承AsyncTask，并在对应的回调函数中编写响应的操作。


AsyncTask工作流程图.png

泛型类

使用AsyncTask需指定三个泛型类
public abstract class AsyncTask<Params, Progress, Result>

  1. Params
    指代启动该任务所需参数的类型，如String类可用于描述下载地址的url。
  2. Progress
    指代任务执行进度的数值类型，主要用于进度更新。
  3. Result
    指代任务执行完后返回的结果的类型。
回调方法

AsyncTask常用的回调函数有以下五个：

public class MyAsyncTask extends AsyncTask<String,Integer,Boolean> {

    // 运行在UI线程，非必须方法
    // 通常在任务正式开始前做一些准备工作
    @Override
    protected void onPreExecute() {
        
    }

    // 运行在工作线程中，必须实现的方法
    // 用来执行耗时操作，如网络传输等
    @Override
    protected Boolean doInBackground(String... strings) {
        //内置方法：发布进度
        publishProgress(进度值);
        //内置方法：取消任务
        cancel(布尔值)
        if (isCancelled()){
                //编写任务取消后的业务代码
            }
        return true or false;
    }

    // 运行在UI线程，非必须方法
    // 处于Running状态的任务，回调此方法执行显示进度等操作
    @Override
    protected void onProgressUpdate(Integer... values) {
        
    }

    // 运行在UI线程，非必须方法
    // 任务正常结束后回调此方法
    @Override
    protected void onPostExecute(Boolean aBoolean) {
        
    }

    // 运行在UI线程，非必须方法
    // 任务在执行过程中调用了cancel方法，则在结束后会回调此方法
    @Override
    protected void onCancelled(Boolean aBoolean) {

    }

}

以上五个回调方法，只有doInBackground方法是在工作线程中执行的，其余四个全部工作在主线程中，即代表我们可以在这四个回调方法内对UI进行操作。

控制方法

上述伪代码中，在doInBackground方法内我们还调用到了两个方法publishProgress和cancel。这俩方法都是AsyncTask内置的final方法，用来辅助我们对正在执行的任务进行控制管理。

  1. publishProgress：主动调用此方法能引起onProgressUpdate方法被回调，以实现进度更新的效果。传入的参数类型为AsyncTask指定的第二种泛型类<Progress>。

  2. cancel：主动调用此方法能使得正在被执行的任务被标识为“取消”，以使得
    onProgressUpdate和onPostExecute方法在后续过程中无法被回调，转而使得任务结束后会回调onCancelled方法。该方法接收一个boolean类型的参数，表示是否对工作线程进行一次中断。

需要注意的是，主动调用cancel方法并不会使得工作线程的任务立刻结束，它只会使得用来描述任务是否被取消的标识位被标识为true。
若想实现调用完cancel方法就能立刻结束任务，那么需要开发者在任务执行的逻辑中主动调用内置方法isCancelled来判断该任务是否被标识为“取消”，并添加对应的任务被取消后的相关处置代码才行。

使用

MyAsyncTask myAsyncTask = new MyAsyncTask()
myAsyncTask.execute("url");

AsyncTask的使用很简单，只需要实例化对象后调用execute方法传入指定的第一个泛型类<Params>参数即可。
有一点需要注意，一个AsyncTask对象只能执行一次execute方法，多次执行会抛出异常。至于原因，请继续看下一部分的源码解析。

AsyncTask源码解析

下面以 AsyncTask的构造函数为起点，逐步分析AsyncTask内部的工作原理。

    //我们常用的无参构造函数
    public AsyncTask() {
        this((Looper) null);
    }

    public AsyncTask(@Nullable Looper callbackLooper) {
    //由于传入的Looper为null，所以此处会调用getMainHandler()方法来构造一个Handler
        mHandler = callbackLooper == null || callbackLooper == Looper.getMainLooper()
            ? getMainHandler()
            : new Handler(callbackLooper);

        mWorker = new WorkerRunnable<Params, Result>() {
            public Result call() throws Exception {
                mTaskInvoked.set(true);
                Result result = null;
                try {
                    Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
                    //noinspection unchecked
                    //关键！！！！！！
                    //在worker中调用doInBackground(mParams)开始执行任务
                    result = doInBackground(mParams);
                    Binder.flushPendingCommands();
                } catch (Throwable tr) {
                    mCancelled.set(true);
                    throw tr;
                } finally {
                    //任务结束，发送结果
                    postResult(result);
                }
                return 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);
                }
            }
        };
    }

    private static Handler getMainHandler() {
        //单例模式
        synchronized (AsyncTask.class) {
            if (sHandler == null) {
                //关键！！！！！！！
                //该Handler传入的是主线程的Looper
                sHandler = new InternalHandler(Looper.getMainLooper());
            }
            return sHandler;
        }
    }

    //通过Handler来发送结果
    private Result postResult(Result result) {
        @SuppressWarnings("unchecked")
        Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
                new AsyncTaskResult<Result>(this, result));
        message.sendToTarget();
        return result;

    private Handler getHandler() {
        return mHandler;
    }

大部分注释已添加到代码中，这里还是简要描述一下：
①调用AsyncTask无参的构造函数，会导致传递至有参构造函数的Looper为null，程序便会执行getMainHandler()方法，该方法用于实例化一个工作于主线程上的Handler。
②随后构造一个worker，该worker即是我们要在子线程中所执行的任务，在该worker中可以看到我们继承AsyncTask时所覆写的doInBackground(mParams)方法被调用。构造好的worker被封装到FutureTask中，以待后面交由线程池执行。
③当worker中的任务执行完毕后会执行finally{}中的postResult(result)方法，该方法通过第一步中所构造的Handler来传递任务执行完后的结果。

上面分析了AsyncTask构造函数所执行的一系列操作，无非就是对任务的封装以及相关辅助工具(如Handler)初始化的工作。下面开始走进execute()的源码来分析任务具体执行的原理。

    public static final Executor SERIAL_EXECUTOR = new SerialExecutor();

    private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;

    //任务初始状态就是PENDING
    private volatile Status mStatus = Status.PENDING;

    //任务执行所用到的线程池
    public static final Executor THREAD_POOL_EXECUTOR;

    static {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE_SECONDS, TimeUnit.SECONDS,
                sPoolWorkQueue, sThreadFactory);
        threadPoolExecutor.allowCoreThreadTimeOut(true);
        THREAD_POOL_EXECUTOR = threadPoolExecutor;
    }

    //AsyncTask的execute方法从这里开始
    public final AsyncTask<Params, Progress, Result> execute(Params... params) {
        //此处传入的默认的线程池即是SERIAL_EXECUTOR
        return executeOnExecutor(sDefaultExecutor, params);
    }

    public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,
            Params... params) {
        if (mStatus != Status.PENDING) {
            //关键！！！！！！
            //此处对当前AsyncTask所处状态进行判断，不管是RUNNING还是FINISHED都会抛出异常
            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)");
            }
        }

        //将任务状态由PENDING改为RUNNING
        mStatus = Status.RUNNING;
        //执行预备操作
        onPreExecute();

        mWorker.mParams = params;
        //线程池执行该FutureTask
        exec.execute(mFuture);

        return this;
    }

    private static class SerialExecutor implements Executor {
        final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
        Runnable mActive;

        //该SerialExecutor不具体执行任务的能力，
        //它的excute方法主要是为了将FutureTask放入Dequeue中，
        public synchronized void execute(final Runnable r) {
            mTasks.offer(new Runnable() {
                public void run() {
                    try {
                        r.run();
                    } finally {
                        //上一个FutureTask执行完，才调度执行下一个FutureTask，保证任务串行执行
                        scheduleNext();
                    }
                }
            });
            if (mActive == null) {
                scheduleNext();
            }
        }

        protected synchronized void scheduleNext() {
            if ((mActive = mTasks.poll()) != null) {
                //关键！！！！！！
                //FutureTask真正的运行起来
                THREAD_POOL_EXECUTOR.execute(mActive);
            }
        }
    }

    //AsyncTask生命周期的三种状态
    public enum Status {
        /**
         * Indicates that the task has not been executed yet.
         * 任务还未执行
         */
        PENDING,
        /**
         * Indicates that the task is running.
         * 任务正在执行
         */
        RUNNING,
        /**
         * Indicates that {@link AsyncTask#onPostExecute} has finished.
         * 任务结束
         */
        FINISHED,
    }
  1. 首先，execute方法会去调用executeOnExecutor方法，并将AsyncTask所提供的默认线程池SERIAL_EXECUTOR作为参数传入。
  2. 在executeOnExecutor方法中，会先对任务的状态进行判断。AsyncTask只存在三种状态PENDING、RUNNING、FINISHED，仅当当前任务状态为PENDING时才会执行后面的步骤，否则会抛出对应的异常，这也印证了为什么一个AsyncTask只能被执行一次。
  3. 当确定任务状态为PENDING后，就将任务状态改为RUNNING，并执行我们之前所覆写的方法onPreExecute()来完成一些任务开始前的准备工作，随后SERIAL_EXECUTOR就会执行该FutureTask。
  4. SERIAL_EXECUTOR是一个SerialExecutor类的静态对象，SerialExecutor内部维护了一个双向任务队列，该进程中所有AsyncTask所执行的任务都会暂存到该队列中。mActive是从该队列中所取出的任务，当且仅当mActive为null或者上一任务完成后才会调用scheduleNext()方法执行下一任务，而具体任务的执行则是交由线程池THREAD_POOL_EXECUTOR来执行的。
  5. THREAD_POOL_EXECUTOR是在AsyncTask类加载的时候就构造好了的线程池，是真正提供工作线程来执行任务的地方。

Tip：
该部分的难点主要在于AsyncTask内部有两个线程池，SerialExecutor的作用其实并不是执行线程操作，而是维护了一个任务队列。通过一个同步锁的形式不断往任务队列中添加任务，并且在执行完队列头的任务后才能再去执行下一个任务，这就导致了我们在执行多个异步任务的时候并非我们所想的是并行，而是串行。当然如果你想进行并行操作直接调用executeOnExecutor()方法传入自己所构造的线程池即可。

疑惑：
有一点我不理解的是，既然是为了提供串行执行任务的线程池，那为什么不直接使用SingleThreadExecutor，直接把任务都丢进SingleThreadExecutor不也是一样的效果吗？希望有缘看到我这篇文章的大佬能解答一下我这个疑问。

分析完execute方法，下面我们再看看cancel方法内做了些什么

   private final AtomicBoolean mCancelled = new AtomicBoolean();

   //AsyncTask的cancel方法
   public final boolean cancel(boolean mayInterruptIfRunning) {
       mCancelled.set(true);
       return mFuture.cancel(mayInterruptIfRunning);
   }

   //FutureTask的cancel方法
   public boolean cancel(boolean mayInterruptIfRunning) {
       if (!(state == NEW &&
             U.compareAndSwapInt(this, STATE, NEW,
                 mayInterruptIfRunning ? INTERRUPTING : CANCELLED)))
           return false;
       try {    // in case call to interrupt throws exception
           if (mayInterruptIfRunning) {
               try {
                   Thread t = runner;
                   if (t != null)
                       //中断线程
                       t.interrupt();
               } finally { // final state
                   U.putOrderedInt(this, STATE, INTERRUPTED);
               }
           }
       } finally {
           finishCompletion();
       }
       return true;
   }

AsyncTask的cancel方法接收一个boolean类型的参数mayInterruptIfRunning，从字面意思就可以推断出这个boolean参数可能代表着是否在运行时进行中断。在cancel方法内部，首先将mCancelled设置为true。mCancelled是一个AtomicBoolean类的变量，其标识了当前任务的状态是否为“取消”。随后调用了FutureTask的cancel方法，并将我们传入boolean参数mayInterruptIfRunning也传入其中。
在FutureTask的cancel方法中，可以看到对mayInterruptIfRunning进行判断，若为true，则对线程进行中断操作t.interrupt()。

如此，我们便了解了为什么AsyncTask的cancel方法并不能直接结束掉该任务，因为源码中确实没有相应的业务代码......（尴尬）

上面分析完了AsyncTask的构造函数以及execute方法和cancel方法所完成的操作，最后我们分析一下AsyncTask是如何与主线程进行交互的。

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

    //任务完成后会调用该方法，可回看构造函数源码解析部分
    private Result postResult(Result result) {
        @SuppressWarnings("unchecked")
        Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
                new AsyncTaskResult<Result>(this, result));
        message.sendToTarget();
        return result;
    }

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

    public final boolean isCancelled() {
        return mCancelled.get();
    }

    private static class InternalHandler extends Handler {
        public InternalHandler(Looper looper) {
            super(looper);
        }

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

上面这段代码涵盖了三个使用AsyncTask常见的回调方法：onCancelled、onPostExecute和onProgressUpdate。不难看出，AsyncTask与主线程间的交互还是完全依赖于Handler来实现的。
重点关注publishProgress和finish方法中对mCancelled的判断，可以看出，只要当前任务被设置成了“取消”，那么更新进度的操作将不会执行，并且任务结束后不会调用onPostExecute方法，而是调用onCancelled方法。

以上，基本上完成对AsyncTask源码的完整分析。在熟悉了AsyncTask原理的基础上，我们完全可以自己尝试着使用Handler加上Excutors的组合来自己实现一个异步任务框架。

若您觉得本文章对您有用，请您为我点上一颗小心心以表支持。感谢！

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 202,529评论 5赞 475
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 85,015评论 2赞 379
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 149,409评论 0赞 335
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 54,385评论 1赞 273
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 63,387评论 5赞 364
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 48,466评论 1赞 281
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 37,880评论 3赞 395
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 36,528评论 0赞 256
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 40,727评论 1赞 295
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 35,528评论 2赞 319
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 37,602评论 1赞 329
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 33,302评论 4赞 318
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 38,873评论 3赞 306
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 29,890评论 0赞 19
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,132评论 1赞 259
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 42,777评论 2赞 349
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 42,310评论 2赞 342