AsyncTask 面试解析

[Toc]

基础认识

AsyncTask 是基于 Handler 进行封装的轻量级异步类，它是一个抽象类，我们要使用的时候需要实现其子类的以下 4 个方法

方法 描述
onPreExecute() 任务执行前被调用，执行在 UI 线程中，在这里我们做一些任务启动前的准备
doInBackground() 执行在新的子线程中的，做异步任务的处理
onProgressUpdate() 这个方法是在调用 publishProgress 的时候被调用的，是运行在 UI 线程的
onPostExecute() 这个方法是任务执行完毕之后被调用的，是运行在 UI 线程中的

作用

  • 实现多线程： 在工作线程中执行任务，如 耗时任务
  • 异步通信、消息传递： 实现工作线程 & 主线程（UI线程）之间的通信，即：将工作线程的执行结果传递给主线程，从而在主线程中执行相关的UI操作

AsyncTask 的三种状态

每个状态在一个任务的生命周期中只会被执行一次。

状态 描述
PENDING 等待（还没有开始执行任务）
RUNNING 执行中
FINSHED 完成

AsyncTask 的内部执行过程

AsyncTask 的对象调用 execute 方法，execute 内部又调用了 executeOnExecutor ，onPreExecute 方法就是在这里被回调，之后将 AsyncTask 的参数封装成一个并发类，然后将其添加到排队线程池（SerialExecutor）中进行排队，如果当前有任务正在执行，则等待，否则 THREAD_POOL_EXECUTOR 执行该任务。在任务的执行过程中，通过 InternalHandler 将进度 pos（MESSAGE_POST_GROGRESS）发送到主线程中，此时会调用 onProgressUpdate 方法，任务执行完毕之后，InternalHandler 将结果 post（MESSAGE_POST_RESULT) 发送到主线程中，此时 onPostExecute 或者 onCancle 会被调用，任务执行到这里就结束了。

基本使用

  • 举个栗子：在异步任务中每隔 1s 打印 1 ~ 10 的数值
    1. 我们不干预任务的执行过程，由任务执行完成，查看任务执行情况；
    2. 任务执行完成后，我们再点击开始，查看任务执行情况；
    3. 干预任务的执行过程，在任务执行期间点击取消，查看任务执行情况；
public class MainActivity extends AppCompatActivity {
    private TextView mText;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mText = findViewById(R.id.text);
        progressAsycn1 = new ProgressAsycn();
        findViewById(R.id.btn_start).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                progressAsycn1.execute(1);
            }
        });
         findViewById(R.id.btn_cancel).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                progressAsycn1.cancel(true);
                mText.append(String.format("取消任务%s\n",new Date().toString()));
            }
        });

    }


    private ProgressAsycn progressAsycn1;
    private class ProgressAsycn extends AsyncTask<Integer,Integer,String> {

        // 这个方法是在启动之前被调用的，执行在 UI 线程中，在这里我们做一些任务启动前的准备
        @Override
        protected void onPreExecute() {
            super.onPreExecute();
            mText.append(String.format("准备执行%s\n",new Date().toString()));
        }

        // 这个方法是执行在新的线程的中的
        @Override
        protected String doInBackground(Integer... params) {
            for (int i = params[0]; i <= 10; i++) {
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                publishProgress(i);
            }
            return "任务已经执行完毕";
        }

        // 这个方法是在调用 publishProgress 的时候被调用的,是运行在 UI 线程的
        @Override
        protected void onProgressUpdate(Integer... values) {
            mText.append(String.format("工作进度：%d\n",values[0]));
        }

        // 这个方法是任务执行完毕之后被调用的
        @Override
        protected void onPostExecute(String s) {
            super.onPostExecute(s);
            mText.append(String.format("任务执行完毕%s\n",new Date().toString()));
        }

        /**
         * 异步任务被取消时回调，即 AsyncTask 的对象调用了 cancel 方法
         * 这个方法和 onPostExecute 互斥
         * doInBackground 方法中的任务执行完毕，才会被回调
         */
        @Override
        protected void onCancelled() {
            mText.append(String.format("异步任务已取消%s\n",new Date().toString()));
        }
    }
}

  • 执行结果

    1. 不干预任务的执行过程，最后的执行结果如下
    asyncTask1.png
    1. 在 1 执行完之后，再点击开始，结果程序报如下错误
        java.lang.IllegalStateException: Cannot execute task: the task has already been executed (a task can be executed only once)
    1. 在任务的执行过程中，点击取消任务，调用 cancel() 方法，之后我们可以看到 onProgressUpdate() 和 onPostExecute() 方法不再被调用，但是我们取消任务的时候，任务还是没有停止的，等到任务真正停止的时候，onCancelled() 方法被调用，执行效果图如下：
    asyncTask2.png

  • 问题：从上面的执行结果中，我们可以看出两个问题

      1. AsyncTask 的对象只能被调用一次，再次调用的时候，会出错
      1. Asynctask 调用了 cancel() 方法取消任务，但是任务并没有真正的停止

提出问题

我们在阅读源码之前，先给自己提一些问题，然后我们在阅读源码的时候，带着问题来去找答案，这样我们的目标才会更加明确。

  1. 为什么AsyncTask 的对象只能被调用一次，否则会出错？（每个状态只能执行一次）
  2. AsyncTask 的类为什么必须在主线程加载
  3. AsyncTask 的对象为什么必须在主线程中创建
  4. AsyncTask 是串行执行任务还是并行执行任务？
  5. AsyncTask 调用 cancel() 任务是否立即停止执行？onPostExecute() 还会被调用吗？onCancelled() 什么时候被调用？

内部源码分析

构造函数中做了什么

首先，我们查看在 AsyncTask 的构造函数里面到底做了些什么

    /**
     * 该构造方法必须在 UI 线程中被调用
     */
    public AsyncTask() {
        this((Looper) null);
    }
    
    
    /**
     * 该构造方法必须在 UI 线程中被调用
     *
     * @hide
     */
    public AsyncTask(@Nullable Looper callbackLooper) {
        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);
                    // doInBackground 的调用时机
                    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);
                }
            }
        };
    }

从以上的代码中，我们可以看出 AsyncTask 做了以下几个工作：

  • 初始化 handler

    • 我们可以从默认调用的构造函数中传入的 callbackLooper 是为 null，那么 handler 初始化的时候是调用 getMainHandler() 方法的，getMainHandler() 方法的的具体代码如下：
    private static InternalHandler sHandler;
private static Handler getMainHandler() {
    synchronized (AsyncTask.class) {
        if (sHandler == null) {
            sHandler = new InternalHandler(Looper.getMainLooper());
        }
        return sHandler;
    }
}
    • 我们从上面的代码中可以知道，getMainHandler() 最后返回的值是 sHandler，而 sHandler 是个静态 InternalHandler 实例，而关于 InternalHandler 的实现，我们在下面再做分析。 我们在这里需要注意的点有两个
      • 为了能够将执行环境切换到主线程中，我们要求 sHandler 必须在主线程中创建，所以 AsyncTask 的构造函数必须在 UI 线程中调用
      • 我们知道静态成员会在加载类的时候进行初始化，由于 sHandler 是个静态变量，那么我们要求 AsyncTask 类必须在 UI 线程中进行加载，否则 AsyncTask 无法正常工作

  • 初始化 mWorker

    • mWorker 是一个 Callable 对象，并在之后初始化 mFutrue 的时候作为参数传入，我们在 mWorker 的代码实现这里可以看到 doInBackground() 在这里被调用了（但是真正的调用时机不不是在这里进行的，而是在 SerialExecutor 的 execute 的方法中），并将结果返回给 result，并在方法结束之前调用 postResult(result)。 方法

  • 初始化 mFuture

    • MFuture 是一个 FutureTask 对象

execute() 中做了什么

接着如果想要启动某一个任务，就需要调用该任务的 execute() 方法，因此现在我们来看一看 execute() 方法的源码

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

execute() 方法的比较简单，只是调用了 executeOnExecutor 方法，那么具体的逻辑是在 executeOnExecutor 里面，我们再接着看下去：

    @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;
    }
  • 首先，executeOnExecutor 先对当前的状态进行判断，由于 AsyncTask 中有三个状态（PENDING、RUNNING、FINISHED），并且每个状态在 AsyncTask 的生命周期中有且只能被执行一次，如果当前的状态不是 Status.PENDING（未执行），那么就抛出异常。在这里也解释了，我们 execute() 方法只能被执行一次，再次调用会报错的原因。
  • 接着，我们可以看到 onPreExecute() 方法被调用了
  • 紧接着，我们可以看到 exec.execute(mFuture) 这行代码，而 exec 又是什么，通过查找上面的 execute 方法，我们可以看到这个 exec 是一个 sDefaultExecutor 变量，sDefaultExecutor 变量的定义如下：
    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);
            }
        }
    }

从以上代码可以看到，在 executeOnExecutor 中的 exce 最终调用的是 SerialExecutor 中 execute() 方法。而 execute() 这个方法的逻辑是在子线程中执行的，而 execute 这个方法传入的 Runnable 正是 mFuture，在 run 方法中调用了， mFuture 对象的 run。我们再找到 FutureTask 中实现的 run 方法的代码，代码如下（有省略）：

    public void run() {
        try {
            Callable<V> c = callable;
            if (c != null && state == NEW) {
                try {
                    result = c.call();
                } catch (Throwable ex) {
                   
                }
            }
        } finally {
            // .....
        }
    }

从上面的代码中我们可以看出，最终调用了 Callable 中的 call ()，而这个 callball 就是我们在 executeOnExecutor 中传入 mFuture 的 mWorker 对象。现在我们又重新拿出 MWorker 的代码来看一下：

    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
                    result = doInBackground(mParams);
                    Binder.flushPendingCommands();
                } catch (Throwable tr) {
                    mCancelled.set(true);
                    throw tr;
                } finally {
                    postResult(result);
                }
                return result;
            }
        };

我们从上面的代码可以看到两个主要的点，首先是 doInBackground() 方法的调用，并将结果给到 result，最后在方法结束之前调用了 postResult(result);

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

而在 postResult 中使用了 sHandler 对象发送了一条消息，消息中携带了 MESSAGE_POST_RESULT 常量和一个表示任务执行结果的 AsyncTaskResult 对象。这个 sHandler 对象是 InternalHandler 类的一个实例，那么稍后这条消息肯定会在 InternalHandler 的 handleMessage() 方法中被处理。InternalHandler 的源码如下所示：

    private static class InternalHandler extends Handler {
       
        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;
            }
        }
    }

在 handleMessage 这里对消息的类型进行了判断，如果这是一条 MESSAGE_POST_RESULT 消息，就会去执行 finish() 方法，如果这是一条 MESSAGE_POST_PROGRESS 消息，就会去执行 onProgressUpdate() 方法。那么 finish() 方法的源码如下所示：

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

可以看到，如果当前任务被取消掉了，就会调用 onCancelled() 方法，如果没有被取消，则调用 onPostExecute() 方法，这样当前任务的执行就全部结束了。

我们注意到，在刚才 InternalHandler 的handleMessage() 方法里，还有一种 MESSAGE_POST_PROGRESS 的消息类型，这种消息是用于当前进度的，调用的正是 onProgressUpdate() 方法，那么什么时候才会发出这样一条消息呢？相信你已经猜到了，查看publishProgress()方法的源码，如下所示：

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

最后我们来理一下 executeOnExecutor 中的任务启动到结束，关键方法的调用顺序：

executeOnExecutor() -> sDefaultExecutor.execute() -> mFuture.run() -> mWorker.call() -> doInBackground() -> postResult() -> sHandler.sendMessage() -> sHandler.handleMessage() -> onPostExecute()

问题解决

  1. 为什么 AsyncTask 的对象只能被调用一次，否则会出错？（每个状态只能执行一次）


    从上面我们知道，AsyncTask 有 3 个状态，分别为 PENDING、RUNNING、FINSHED，而且每个状态在 AsyncTask 的生命周期中有且只执行一次。由于在执行完 execute 方法的时候会先对 AsyncTask 的状态进行判断，如果是 PENDING（等待中）的状态，就会往下执行并将 AsyncTask 的状态设置为 RUNNING（运行中）的状态；否则会抛出错误。AsyncTask finish 的时候，AsyncTask 的状态会被设置为 FINSHED 状态。
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)");
            }
        }

  1. AsyncTask 的类为什么必须在主线程加载


    由于 sHandler 是一个静态的 Handler 对象，为了能够将执行环境切换到主线程中，这就要求 sHandler 必须在主线程中创建，也即是 AsyncTask 必须在主线程中创建。由于静态成员会在加载类的时候进行初始化，因此也要求 AsyncTask 的类必须在主线程中加载，否则 AsyncTask 无法正常工作。

  2. AsyncTask 的对象为什么必须在主线程中创建


    因为在 AsyncTask 的构造函数中对 handler 进行了初始化的操作，所以 AsyncTask 必须在主线程中进行创建，否则 AsyncTask 无法进行线程切换的工作

  3. AsyncTask 是串行执行任务还是并行执行任务？


    在 Android 1.6 之前，AsyncTask 是串行执行任务的，Android 1.6的时候 AsyncTask 是并行执行任务的，Android 3.0 之后，为了避免并行错误，AsyncTask 又采用一个线程来串行执行任务。

  4. AsyncTask 调用 cancel() 任务是否立即停止执行？onPostExecute() 还会被调用吗？onCancelled() 什么时候被调用？


    任务不会立即停止的，我们调用 cancel 的时候，只是将 AsyncTask 设置为 canceled（可取消）状态，我们从以下代码可以看出，AsyncTask 设置为已取消的状态，那么之后 onProgressUpdate 和 onPostExecute 都不会被调用，而是调用了 onCancelled() 方法。onCancelled() 方法是在异步任务结束的时候才调用的。时机是和 onPostExecute 方法一样的，只是这两个方法是互斥的，不能同时出现。

@WorkerThread
    protected final void publishProgress(Progress... values) {
        if (!isCancelled()) {
            getHandler().obtainMessage(MESSAGE_POST_PROGRESS,
                    new AsyncTaskResult<Progress>(this, values)).sendToTarget();
        }
    }
    
// 线程执行完之后才会被调用
private void finish(Result result) {
        if (isCancelled()) {
            onCancelled(result);
        } else {
            onPostExecute(result);
        }
        mStatus = Status.FINISHED;
    }

AsyncTask 在使用的过程中的一些限制总结

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

推荐阅读更多精彩内容