AsyncTask 面试解析

3,591 阅读12分钟

[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
    2. 在 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 是不会被调用的