【Android】深入解析 AsyncTask 源码

作者 : 开心源码 本文共8699个字,预计阅读时间需要22分钟 发布时间: 2022-05-13 共294人阅读

前言:AsyncTask 是 Android SDK 中提供的一个用于执行异步任务的框架,在 Android 兴起的早期被广泛使用,但如今在 API 30 被弃用,取而代之的是 java.util.concurrent 或者 Kotlin 协程。尽管它存在着少量不足,但是我们还是可以尝试理解一下它的实现原理以及存在的不足。

注:本文以 API 29 的 AsyncTask 源码进行解析。

功能概述

首先,让我们来简单地理解一下它的设计初衷:

AsyncTask的设计初衷是能够帮助客户方便地完成异步任务的线程调度,它对客户提供了如下几个接口:

public abstract class AsyncTask<Params, Progress, Result> {    @WorkerThread    protected abstract Result doInBackground(Params... params);    @MainThread    protected void onPreExecute() {    }    @MainThread    protected void onPostExecute(Result result) {    }    @MainThread    protected void onProgressUpdate(Progress... values) {    }    @MainThread    protected void onCancelled(Result result) {        onCancelled();    }}

首先看到它的三个范型参数:

  • Params:代表传递给它的参数类型
  • Progress:代表用于反馈进度的数据类型
  • Result:代表异步执行的结果类型

客户可以通过实现doInBackground方法来编写在异步线程所要进行的解决;通过onPostExecute方法的重写实现对异步请求结果的获取;通过onPreExecute实现了在doInBackground之前进行少量预解决;通过onProgressUpdate实现对进度的监听;通过onCancelled实现对任务中断的监听。

当我们编写一个AsyncTask后,只要要调用它的execute方法就可,而背后的线程调度的过程都会由它替我们完成,看上去是十分美好的。

同时从上面的代码中可以看到,每个方法都有被@MainThread的注解标注,这些注解主要的作用是用来标注这个方法运行所处的线程。可以看出,只有doInBackground是在异步线程进行执行。


创立

让我们看看它的创立过程,来到它的构造函数:

public AsyncTask() {    this((Looper) null);}

它的无参构造函数转调到了它的有参构造函数,这个构造函数需要以Looper作为一个参数:

public AsyncTask(@Nullable Looper callbackLooper) {    // 根据传递进来的 Looper 来构建了一个 Handler,若没有指定 Looper 或者指定的 Looper 是主线程的 Looper,    // 则指定内置的 InternalHandler 对消息进行解决(见附1),否则构造一个对应的 Handler。    // 可以看出 AsyncTask 不是肯定回到主线程的。    mHandler = callbackLooper == null || callbackLooper == Looper.getMainLooper()           ? getMainHandler()           : new Handler(callbackLooper);      // 构建了一个 WorkerRunnable,WorkerRunnable 实际上是对 Callable 的简单包装(见附2),    // 区别仅仅在于可以传入参数。    mWorker = new WorkerRunnable<Params, Result>() {        // 当 mWorker 被执行时        public Result call() throws Exception {            // 将当前 Task 设置为被执行            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 {                // 看来这个 WorkerRunnable 是在异步线程中执行的。                // 不管成功与否,它最后都会调用 postResult 进行结果的交付。                postResult(result);            }            // 返回结果            return(result);        }    };    // 基于前面的 mWorker 构建了一个 FutureTask    mFuture = new FutureTask<Result>(mWorker) {        @Override        protected void done() {            try {                // 当执行完成或者被取消时,会调用 postResultIfNotInvoked 方法传入 mWorker 的执行结果。                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 方法传入 mWorker 的执行结果。                postResultIfNotInvoked(null);            }        }    };}
附1private static Handler getMainHandler() {    synchronized (AsyncTask.class) {        if (sHandler == null) {            sHandler = new InternalHandler(Looper.getMainLooper());        }        return(sHandler);    }}
附2private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {    Params[] mParams;}

总的来说,其构造过程主要是对 Handler、WorkerRunnable 以及 FutureTask 进行了构建。


执行

让我们看看当调用execute之后它做了什么:

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

可以看到,它转调到了executeOnExecutor方法,并且传入了一个Executor对象sDefaultExecutor,我们先不去关注这个Executor的设计,让我们先看看executeOnExecutor方法:

@MainThreadpublic final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,                                    Params...params) {    // 首先,它对当前 Task 的状态进行了检查,AsyncTask 共有三种状态(见附1)    // 只有 PENDING 的 Task 才能被 execute。    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)");        }    }    // 改变当前 Task 的状态    mStatus = Status.RUNNING;    // 调用 onPreExecute 方法进行了客户实现的预解决    onPreExecute();    // 将客户的参数交给 mWorker    mWorker.mParams = params;    // 将 mFuture 交给了传入的线程池进行解决    exec.execute(mFuture);    return(this);}
附1public enum Status {    // 待执行    PENDING,    // 正在执行    RUNNING,    // 已执行    FINISHED,}

FutureTask执行后,会使得mWorker被执行,它执行后会将mTaskInvoked.set(true),并调用postResult进行结果的交付:

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

这里实际上就是把结果包装成了AsyncTaskResult类并放入了消息队列,这样就实现了线程的切换,将消息通过Handler由子线程发送给了主线程(指AsyncTask被指定的线程),当Handler收到消息后,就会对消息进行解决。

回到AsyncTask创立的时候,我们可以看到在构造时没有指定Looper的情况下,默认的InternalHandler是如何进行解决的:

private static Handler getMainHandler() {    synchronized (AsyncTask.class) {        if (sHandler == null) {            sHandler = new InternalHandler(Looper.getMainLooper());        }        return(sHandler);    }}
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) {                // 在 MESSAGE_POST_RESULT 消息下,它在收到 AsyncTaskResult 后会调用 finish 方法进行整个任务                // 的完成解决(见附1)                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;        }    }}
附1private void finish(Result result) {    // 若任务已取消,它会调用 onCancelled 方法进行回调    if (isCancelled()) {        onCancelled(result);    }     // 若任务正常完成,它会调用 onPostExecute 方法    else {        onPostExecute(result);    }      // 设置状态为 FINISHED    mStatus = Status.FINISHED;}

当 FutureTask 执行完成后,会调用postResultIfNotInvoked方法,并传入mWorker的执行结果:

private void postResultIfNotInvoked(Result result) {    final boolean wasTaskInvoked = mTaskInvoked.get();    if (!wasTaskInvoked) {        postResult(result);    }}

可以看到,这里实际上是在Task没有被Invoke的情况下才会调用到,因为mWorker在被执行时首先就会将wasTaskInvoked置为 true,因而实际上这里很少能被调用到。

我们再看看onProgressUpdated何时会被调用到,我们可以找到MESSAGE_POST_PROGRESS的消息是何时被发出的:

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

它是在publishProgress方法中被调用的,这个方法是提供给客户的,因而进度的升级需要客户自行在doInBackground中调用publishProgress从而实现。


取消

我们看看任务的取消,看到cancel方法:

public final boolean cancel(boolean mayInterruptIfRunning) {    mCancelled.set(true);    // cancel 方法最后会调用到 mFuture 的 cancel,并且它需要传递一个参数 mayInterruptIfRunning,    // 见附1    return(mFuture.cancel(mayInterruptIfRunning));}
附1public boolean cancel(boolean mayInterruptIfRunning) {    if (!(state == NEW &&           U.compareAndSwapInt(this, STATE, NEW,                    mayInterruptIfRunning ? INTERRUPTING : CANCELLED)))            return(false);    try {            // 当 mayInterruptIfRunning 为 true 时,即便任务在运行时也会被打断。            // 而假如为 false,则 doInBackground 依然会一直执行到结束。            if (mayInterruptIfRunning) {                    try {                            Thread t = runner;                            if (t != null)                                    t.interrupt();                    } finally {                            U.putOrderedInt(this, STATE, INTERRUPTED);                    }            }    } finally {        finishCompletion();    }    return(true);}

这个设计非常奇怪,按道理来说取消的场景只有任务正在执行时需要取消,完全可以提供一个这个参数默认为 true 的方法供外部调用。并且这个方法只能尽量让任务尽快结束,假如执行的过程中有少量不可打断的操作,则这个方法调用后依然不会使得任务中止。


线程池

对于AsyncTask,我们还有最后一个问题没有研究,那就是它执行任务的sDefaultExecutor:

private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;

可以看到它的默认值为SERIAL_EXECUTOR。

public static final Executor SERIAL_EXECUTOR = new SerialExecutor();

SERIAL_EXECUTOR是SerialExecutor的实例。

private static class SerialExecutor implements Executor {    // Executor 内部维护了一个 ArrayDeque 队列,这个队列是一个任务缓存队列,    // 里面存放了对真正要执行的 Runnable 进行包装的 Runnable。    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();                      }        }    } );        // 当 mActive 为 null,它会调用 scheduleNext 方法。        if (mActive == null) {            scheduleNext();        }    }    // 在 scheduleNext 方法中会从 mTasks 队首取出任务赋值给 mActive,    // 之后通过 THREAD_POOL_EXECUTOR 这个线程池对该任务进行执行。    protected synchronized void scheduleNext() {        if ((mActive = mTasks.poll()) != null) {            THREAD_POOL_EXECUTOR.execute(mActive);        }    }}

当任务执行完成后,会继续调用scheduleNext对队列中的下一个任务进行执行。通过这样的设计,Runnable的执行变成了一种按序执行,只有前一个执行结束,才会进行下一个任务的执行,因而AsyncTask的执行顺序实际上是一种串行执行。

那么THREAD_POOL_EXECUTOR又是一个怎么的线程池呢?让我们看看它的公告:

private static final int CORE_POOL_SIZE = 1;private static final int MAXIMUM_POOL_SIZE = 20;private static final int KEEP_ALIVE_SECONDS = 3;public static final Executor THREAD_POOL_EXECUTOR;static {  ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(                CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE_SECONDS, TimeUnit.SECONDS,          new SynchronousQueue<Runnable>(), sThreadFactory);  threadPoolExecutor.setRejectedExecutionHandler(sRunOnSerialPolicy);  THREAD_POOL_EXECUTOR = threadPoolExecutor;}

可以看到,THREAD_POOL_EXECUTOR的配置如下:

  • CORE_POOL_SIZE:内部核心线程个数
  • MAXIMUM_POOL_SIZE:最大线程数量
  • KEEP_ALIVE_SECONDS:每一个线程空闲后等待的时间,时间到了就会被中止

只保留一个池线程。假如需要,让池增长到相当多的线程,但让他们很快超时。 在不太可能发生线程用尽的情况下,退回到一个简单的无界队列执行程序。

这种组合可确保:

  • 保持一些的线程
  • 仅在启动显著更大,但仍有限的线程集之后才进行排队
  • 将线程总数限制为有界,但依然允许无限制的任务集排队。

不足之处

AsyncTask看似十分美好,但实际上存在着非常多的不足,这些不足使得它在 API 30被废弃:

  • 生命周期:AsyncTask没有与Activity、Fragment的生命周期绑定,即便Activity被销毁,它的doInBackground任务依然会继续执行。
  • 取消任务:AsyncTask的cancel方法的参数mayInterruptIfRunning存在的意义不大,并且它无法保证任务肯定能取消,只能尽快让任务取消(比方,假如正在进行少量无法打断的操作时,任务就依然会执行)
  • 内存泄漏:因为它没有与Activity等生命周期进行绑定,因而它的生命周期依然可能比Activity长,假如将它作为Activity的非static内部类,则它会持有Activity的引用,导致Activity的内存无法释放。

总结

本文基本上对AsyncTask的实现原理有一个大致的理解了,它的原理实际上还是挺简单的:通过Executor与FutureTask配合,从而实现任务的异步执行,最后在任务结束后通过Handler进行线程的切换从而实现了整个线程调度的功能。在Android 3.0之后,默认情况下AsyncTask的执行顺序是串行进行的。


© 2020 Tyhoo Wu, All rights reserved.

说明
1. 本站所有资源来源于用户上传和网络,如有侵权请邮件联系站长!
2. 分享目的仅供大家学习和交流,您必须在下载后24小时内删除!
3. 不得使用于非法商业用途,不得违反国家法律。否则后果自负!
4. 本站提供的源码、模板、插件等等其他资源,都不包含技术服务请大家谅解!
5. 如有链接无法下载、失效或广告,请联系管理员处理!
6. 本站资源售价只是摆设,本站源码仅提供给会员学习使用!
7. 如遇到加密压缩包,请使用360解压,如遇到无法解压的请联系管理员
开心源码网 » 【Android】深入解析 AsyncTask 源码

发表回复