源码解读 | AsyncTask

AsyncTask 是 Android 中实现多线程方式之一，我们通常用 AsyncTask 来实现在耗时操作中对 UI 界面的更新。AsyncTask 提供了 onPreEcecute()、onProgressUpdate()、onPostExecute() 方法用于更新 UI，doInBackground() 方法用于实现耗时操作，如网络请求、I/O操作。

1. execute()

我们在使用 AsyncTask 时通常开启任务执行的入口就是 execute()，进入到 execute() 中，调用了 executeOnEcecutor() 方法开始执行任务，注意这两个方法都是在主线程调用的。

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

    @MainThread
    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;
    }
    //状态标识
    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,
    }
  • 任务的状态信息

PENDING 表示任务未被执行
RUNNING 表示任务正在执行
FINISHED 表示任务已执行

1）判断当前 AsyncTask 状态：
当开启一个 AsyncTask，如果当前任务正在执行或被执行过，程序会抛出异常，这表明:

一个 AsyncTask 在主线程中只能调用 execute() 或 ececuteOnExecutor() 一次。

2）更行状态信息，调用 onPreExecute() 方法处理任务执行前的准备工作；
3）exec.execute(mFuture) 开始执行任务，这里的 exec 是 AsyncTask 的一个线程池 sDefaultExecutor，AsyncTask 里 sDefaultExecutor 是由 SerialExecutor 的对象 SERIAL_EXECUTOR 赋值而来，用于顺序存储任务，同时并串行执行任务，看看 SerialExecutor 的具体实现：

2. SerialExecutor

SerialExecutor 是一个线程池，其中有一个队列用于存储任务，在 execute() 方法中还实现了任务串行执行。

    public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
    private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;

    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); //执行任务
            }
        }
    }

1）mTasks 是一个存储任务的队列，基于队列先进先出原则保证了任务按进入队列的顺序可以被顺序执行，一个任务即是一个 Runnable 对象；
2）execute() 方法，首先将传入的 Runnable 对象 r 封装成 Runnable 对象加入任务队列，封装的 Runnable 对象实现了 run() 方法用于执行传入的任务，即 r.run()，接着调用 scheduleNext() 执行下一个任务；
3）mActivie == null，当前没有任务在执行，调用 scheduleNext() 执行任务队列中的下一个任务，按照步骤2中的逻辑，执行完当前任务后调用 scheduleNext() 继续执行任务队列中下一个任务，直到任务队列为空，这里可以看出来 AsyncTask 是默认串行执行任务；
4）scheduleNext() 方法，任务队列取出队头任务，不为空则通过 THREAD_POOL_EXECUTOR 调用 ececute() 执行任务。

3. THREAD_POOL_EXECUTOR

THREAD_POOL_EXECUTOR 也是一个线程池，它的作用是执行任务，来看看它的实现：

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

这里主要是初始化了 THREAD_POOL_EXECUTOR 的相关参数，参数如下：

    private static final int CORE_POOL_SIZE = Math.max(2, Math.min(CPU_COUNT - 1, 4));
    private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;
    private static final int KEEP_ALIVE_SECONDS = 30;

1）CORE_POOL_SIZE 线程池最大核心线程数最小为2，最大为4且比 CPU 数少1；
2）MAXIMUM_POOL_SIZE 线程池最大线程数为 CPU 数的 2倍加1；
3）KEEP_ALIVE_SECONDS 线程数大于核心线程数是，线程终止之前最大等待时长 30s，大于了这个时间，等待中的线程则终止。

4. 构造方法

从 execute() 一路追踪下来，我们了解了一个任务是如何被放入任务队列中并执行的，AsyncTask 中的关键方法 doInBackground() 、onProgressUpdate()、onPostEcexute() 又是在哪儿调用的呢？回到最初调用 execute() 的地方，进入 AsyncTask 的构造方法来看看。

    public AsyncTask() {
        this((Looper) null);
    }
    public AsyncTask(@Nullable Handler handler) {
        this(handler != null ? handler.getLooper() : null);
    }
    public AsyncTask(@Nullable Looper callbackLooper) {
        mHandler =...;
        mWorker = new WorkerRunnable<Params, Result>() {
            ...
        };
        mFuture = new FutureTask<Result>(mWorker) {
            ...
        };
    }

1）构造函数中传入了 Looper，这里使用 Looper 是因为在 AsyncTask 中创建了 Handler，创建 Handler 时必须在有 Looper 的线程中创建；
2）接着在构造函数中依次实例化对象 mHandler、mWorker、mFuture，我们依次来看这三个对象的具体实现。

  • mHandler
        mHandler = callbackLooper == null || callbackLooper == Looper.getMainLooper()
            ? getMainHandler()
            : new Handler(callbackLooper);

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

1）判断 callbackLooper 是否为空且是否是主线程的 Looper，为空则使用 调用 getMainHandler() 返回一个 Handler，否则调用 new Handler(callbackLooper) 新建一个 Handler。注意这里调用的是 Looper.getMainLooper()，这表明我们在 AsyncTask 中创建 Handler 时必须使用主线程的 Looper，即创建 Handler 的线程必须在主线程， 同理 AsyncTask 必须在主线程创建；
2）getMainHandler() ，mHandler 为空则在主线程为其创建一个 InternalHandler，InternalHandler 我们后面来看它的实现。

  • mWorker
        mWorker = new WorkerRunnable<Params, Result>() {
            public Result call() throws Exception {
                mTaskInvoked.set(true);
                Result result = null;
                try {
                    Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
                    result = doInBackground(mParams);
                    Binder.flushPendingCommands();
                } catch (Throwable tr) {
                    mCancelled.set(true);
                    throw tr;
                } finally {
                    postResult(result);
                }
                return result;
            }
        };

    private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {
        Params[] mParams;
    }

mWorker 其实是一个 Callback，call() 方法中拿到 doInBackground() 方法的返回结果并传给了 posResult() 方法。

  • mFuture
        mFuture = new FutureTask<Result>(mWorker) {
            @Override
            protected void done() {
                try {
                    postResultIfNotInvoked(get());
                }
                ...
            }
        };

mFuture 传入了 mWorker，在 execute() 方法中参数 params 存入了mWorker 中， mFuture 作为一个 Runnable 对象在线程池 sDefaultExecutor 中被保存在任务队列中，所以 mFuture 就是一个携带参数的任务。任务队列执行任务时调用 mFuture 的 run() 方法，run() 方法在 FutureTask 内部调用 mWorker 的 call()，call() 方法里调用了 doInBackground()，这里就实现了任务执行时对 AsyncTask 关键方法 doInBackground() 的调用。

  • postResult()

最后我们来看 mWorker 的 call() 中调用的 postResult() 方法：

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

postResult() 方法很简单，拿到我们在 doInBackground() 中返回的结果后，通过 Handler 发送了一条 MESSAGE_POST_RESULT 消息，InternalHandler 实现了消息的接受。

注意：我们在 execute() 中调用 exec.execute(mFuture) 执行任务时，线程池 THREAD_POOL_EXECUTOR 中的核心线程（也有可能是非核心线程）开始执行任务，这时候我们已经不是在主线程（UI线程了）所以可以很明显的知道这里调用的 doInBackground() 也是在我们的线程池中执行的，即 doInBackground() 里的耗时任务放入子线程中执行。 同样在子线程中使用 Handler 发送消息，在创建 Handler 的主线程（UI线程）中接受子线程发来的消息，实现了线程的切换。

5. InternalHandler

我们在构造方法中实例化的 mHandler 对象就是 InternalHandler 的一个对象。

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

InternalHandler 中接受两种类型的消息，一种是 MESSAGE_POST_RESULT，任务执行完成后会收到，收到后调用 finish() 处理消息；一种是 MESSAGE_POST_RESULT，任务在执行过程中调用了 publishProgress() 方法时会收到，用于接受当前任务执行的进度，收到后调用 onProgressUpdate() 处理消息。

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

    @MainThread
    protected void onCancelled(Result result) {
        onCancelled();
    }

    @MainThread
    protected void onCancelled() {
    }

isCancelled() 当前任务若是在执行完成前被取消了，则调用 onCancelled() 取消任务，取消任务的具体实现需要我们自己在 UI 线程实现；任务没有在执行过程中被取消则返回任务执行结果给 onPostExecute()。

到这里 AsyncTask 调用 execute() 执行一次任务的完整流程就走完了，附上完整流程：

execute()
→ executeOnExecutor() → onPreExecute()
→ SerialExecutor.execute()
→ SerialExecutor.scheduleNext()
→ THREAD_POOL_EXECUTOR.execute()
→ FutureTask.run()
→ WorkerRunnable.call() → doInBackground() → publishProgress()
→ postResult()
→ InternalHandler.handleMessage()
① → finish() → onCancelled() / onPostExecute()
② → onProgressUpdate()

6. 总结

1）AsyncTask 是一个抽象泛型类，泛型 Params、Progress、Result 分别表示 doInBackground(Params ...) 的参数类型，onProgressUpdate(Progress ...)的参数类型，doInBackground()返回结果类型和 onPostExecute(Result result) 的参数类型；
2）AsyncTask 只能在主线程（UI线程）创建，execute() 和 executeOnExecutor() 方法同样也只能在主线程（UI线程）调用，即任务的开启只能在主线程。这里很好理解，我们实现 onPreExecute()、onProgressUpdate()、onPostExecute() 这些方法时基本都会更新我们的 UI，而要更新 UI 只能在主线程，所以 AsyncTask 的创建必然是只能在主线程；
3）AsyncTask 的 execute() 或 executeOnExecutor() 只能在主线程中被调用一次；
4）AsyncTask 有两个线程池和一个 Handler，线程池 SerialExecutor 用于按序存储任务（因为有一个队列）；线程池 THREAD_POOL_EXECUTOR 用于执行任务；InternalHandler 则用于接受来自子线程的消息，消息包括任务结束的消息和任务进度更新的消息；
5）运行在主线程（UI线程）的方法有 onPreEcecute()、onProgressUpdate()、onPostExecute()，运行在子线程的方法有 doInBackground()、publishProgress()；
6）onPostExecute() 方法不再被调用之后，我们应当手动调用 cancel() 结束当前任务。

疑问：

1）AsyncTask 也支持并行执行任务吗？怎么实现？
2）AsyncTask 是否会内存泄漏，为什么？怎么解决？

参考：

《Android 开发艺术探索》

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