AsyncTask 源码解析

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/qq_31876841/article/details/80753427

Introduction

AsyncTask 是一个简易方便使用的异步组件，它结合了 ThreadPool & Handler 使得我们能够更方便的处理异步任务，和更新UI

Usage

public abstract class AsyncTask<Params, Progress, Result>

AsyncTask 是一个抽象方法，所以我们需要创建一个新类继承 AsyncTask 且至少实现 doInBackground(Params…) 方法。

Generic type

AsyncTask 中还带有三种泛型类型

• Params
  执行时发送给任务的参数类型
• Progress
  进度单位类型
• Result
  返回结果的类型

不需要设定具体参数类型时，可以设置为 Void

Other method

当然，它还提供了其他默认方法，供我们重写以扩展其功能（按执行顺序排序）。
1. onPreExecute()
在任务执行前，在 UI 线程中执行，通常用于初始化任务，如显示进度条
2. doInBackground(Params…)
在后台线程中运行，用于处理一些需要长时间的任务。在这个步骤，我们可以调用 publishProgress(Progress…) 去发布当前进度。
3. onProgressUpdate(Progress…)
在UI线程中运行，只有当调用了 publishProgress(Progress..) 后，才会执行。
4. onPostExecute(Result)
在UI线程中运行。会把异步处理完的结果返回。

Canceling a task

只要调用了 cancel(boolean) 方法，就可以取消当前任务，isCancelled() 方法会返回 true.但是 doInBackground() 方法任然会继续运行，只不过完成后，会调用 onCancelled() 方法，而不是 onPostExecute() 方法。为了确保 doInBackground() 方法能够及时停止，应该在 doInBackground() 中定时检查 isCancelled() 方法返回的值。

Threading rules

• AsyncTask 必须在 UI 线程中加载
• 任务的实例必须在 UI 线程中创建
• execute() 方法必须在 UI 线程中调用
• 不要手动调用 onPreExecute(),onPostExecute(),doInBackgroud(),onProgressUpdate()
• 每个任务只能调用一次，不然会抛出异常的

Source

Constructor

public AsyncTask(@Nullable Looper callbackLooper) {
        //初始化 Handler
        mHandler = callbackLooper == null || callbackLooper == Looper.getMainLooper()
            ? getMainHandler()
            : new Handler(callbackLooper);

        mWorker = new WorkerRunnable<Params, Result>() {
            public Result call() throws Exception {
               ...
            }
        };

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

Init Handler

首先初始化 Handler ，毕竟想要与主线程通信还是要靠 Handler.

Init WorkerRunnable

接着初始化 mWorker，其本质是一个 Callback，类似 Runnable 接口但是 Runnable 不能返回值也不能抛出异常。

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

具体实现

                //更新当前状态为以调用，注意，这里的布尔值采用的是 AtomicBoolean 
                //原子布尔值，能确保多线程的情况下安全运行
                mTaskInvoked.set(true);
                Result result = null;
                try {

                    //设置当前线程优先级为 *Process.THREATE_PRIORITY_BACKGROUND* 标准后台线程有优先级，
                    //让你的线程优先级略微低于正常的线程，降低对用户界面响应的可能性。
                    Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);

                    //noinspection unchecked
                    //执行上述介绍过的 *doInBackground()* 方法，获取返回值
                    result = doInBackground(mParams);

                    //清理当前线程中待执行的 Binder commands
                    //确保对象的引用被释放，防止进程长时间占用这些对象
                    Binder.flushPendingCommands();
                } catch (Throwable tr) {

                    //更新状态
                    mCancelled.set(true);
                    throw tr;
                } finally {

                    //把结果发布到主线程
                    postResult(result);
                }
                return result;

Init FutureTask

FutureTask 是一个可取消的异步计算，且能够这里我们就可以猜测 AsyncTask 的取消操作就是通过 FutureTask 实现的。

具体实现

            try {
                    //发布结果 
                    //get() 是 FutureTask 中获取结果的方法
                    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 void postResultIfNotInvoked(Result result) {
        final boolean wasTaskInvoked = mTaskInvoked.get();
        //没调用 mWorker 中的任务
        if (!wasTaskInvoked) {
            postResult(result);
        }
    }

execute

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

    private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
    public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
    //静态实体类，所有 AsyncTask 共有
    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);
            }
        }
    }
    public static final Executor THREAD_POOL_EXECUTOR;
    private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
    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;
    private static final BlockingQueue<Runnable> sPoolWorkQueue =
            new LinkedBlockingQueue<Runnable>(128);
    //静态实体类，所有 AsyncTask 共有
    private static final ThreadFactory sThreadFactory = new ThreadFactory() {
        private final AtomicInteger mCount = new AtomicInteger(1);
        public Thread newThread(Runnable r) {
            return new Thread(r, "AsyncTask #" + mCount.getAndIncrement());
        }
    };
    static {
        //根据cpu数量计算，但保证至少有2个核心线程数，且有30秒TimeOut时间
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE_SECONDS, TimeUnit.SECONDS,
                sPoolWorkQueue, sThreadFactory);
        threadPoolExecutor.allowCoreThreadTimeOut(true);
        THREAD_POOL_EXECUTOR = threadPoolExecutor;
    }

在这里我们可以知道，所有的任务最后都是由全局的一个线程池执行的，而且在进入线程池前会经由一个自定义的 Executor 再提交到线程池中，以确保任务是串行执行的。但是这样每次只会有一个任务在线程池中运行，不会很浪费吗？不过幸运的是，我们还是可以通过把 execute替换成executeOnExecutor()来跳过 SerialExecutor 的。

AsyncTask.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);

也可以自己扩展新的 Executor 来加快 AsyncTask.

Post To UI Thread

看完如何执行，我们再来看一下如何把结果发送回主线程中去。具体和主线程相关的方法有 onPostExecute() 和 onProgressUpdate ，我们根据这两个方法，向上找，看一下是如何把结果发送会主线程的。

    @SuppressWarnings({"UnusedDeclaration"})
    @MainThread
    protected void onPostExecute(Result result) {
    }

    @SuppressWarnings({"UnusedDeclaration"})
    @MainThread
    protected void onProgressUpdate(Progress... values) {
    }

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

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

    @WorkerThread
    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 static class AsyncTaskResult<Data> {
        final AsyncTask mTask;
        final Data[] mData;

        AsyncTaskResult(AsyncTask task, Data... data) {
            mTask = task;
            mData = data;
        }
    }

    //在构造方法中执行过
    private static Handler getMainHandler() {
        synchronized (AsyncTask.class) {
            if (sHandler == null) {
                sHandler = new InternalHandler(Looper.getMainLooper());
            }
            return sHandler;
        }
    }

    private Handler getHandler() {
        return mHandler;
    }

可以看出，AsyncTask 是通过 Handler 与主线程进行通信的。而且，为了和主线程通信 Handler 需要通过主线程的 Looper 来进行构造。这也解释了为什么需要在主线程中使用 AsyncTask ，因为，只有这样才能获取到主线程的 Looper ，才能和主线程进行通信。

Cancel

    public final boolean cancel(boolean mayInterruptIfRunning) {
        mCancelled.set(true);
        return mFuture.cancel(mayInterruptIfRunning);
    }

如我们刚开始时猜想，AsyncTask 的 cancel 方法确实是调用了 Future 的 cancel 方法。

Reference

• https://developer.android.com/reference/android/os/AsyncTask