时间是一切财富中最宝贵的财富 — 德奥弗拉斯多

写在前面

趁着周日休息，研究一下AsyncTask，我相信大家对AsyncTask并不陌生，用来做下载任务最爽了，即能在子线程中做耗时任务，又可以随意的回到主线程更新UI。

用法

首先，让我们来认识一下AsyncTask，正如其名“异步任务”，它是用来做异步任务的，不同于线程等，AsyncTask是一个抽象类，必须创建一个子类继承自AsyncTask，并指定其参数类型。AsyncTask有五个回调函数，各司其职。

接下来还是通过一个小Demo认识它吧：

public class AsyncTaskActivity extends BaseAppCompatActivity {

    @BindView(R.id.bar_seek)
    protected SeekBar mSeekBar;
    @BindView(R.id.text_tips)
    protected AppCompatTextView mTextTips;

    private DownloadAsyncTask mDownloadAsyncTask;

    @Override
    public int getLayoutId() {
        return R.layout.activity_async_task;
    }

    @Override
    public void initViews() {

    }

    @Override
    public void initData() {

    }

    @OnClick(R.id.btn_start)
    protected void onStartClick() {
        if (mDownloadAsyncTask == null) {
            mDownloadAsyncTask = new DownloadAsyncTask();
        }
        // 调用execute()执行任务，每一个任务只能调用一次execute()，否则会抛出异常
        mDownloadAsyncTask.execute();
    }

    @OnClick(R.id.btn_cancel)
    protected void onCancelClick() {
        if (mDownloadAsyncTask == null) {
            return;
        }
        // 调用cancel()取消任务，其实它并不会真正的取消，本质上调用的是Thread.interrupt()
        mDownloadAsyncTask.cancel(true);
    }

    // 继承自AsyncTask的子类，指定传入的参数类型为Void（无参数类型），
    // 进度条参数类型为Integer，返回结果参数类型为String。
    private class DownloadAsyncTask extends AsyncTask<Void, Integer, String> {

        // 第一个回调，该回调运行在主线程中，
        // 在AsyncTask调用execute()之后和doInBackground()之前回调，
        // 用于前期的准备工作， 比如显示进度条，提示用户开始下载了
        @Override
        protected void onPreExecute() {
            super.onPreExecute();
            mSeekBar.setVisibility(View.VISIBLE);
            mSeekBar.setMax(100);
            mTextTips.setText("开始下载");
        }

        // 第二个回调，该回调是真正运行在子线程中的，不可以进行UI更新操作，
        // 该函数是AsyncTask的核心函数，异步任务就是在这里做的，比如下载
        // 若要更新进度，可以调用publishProgress()，然后在onProgressUpdate()中更新进度
        @Override
        protected String doInBackground(Void... voids) {
            for (int i = 0 ; i < 100 ; i ++) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    return "下载失败";
                }
                (new Integer[]{i});
            }
            return "下载成功";
        }

        // 更新进度回调，该函数运行在主线程中，
        // 通过在doInBackground()中调用publishProgress()函数，就会回调该函数，
        // 比如更新下载进度
        @Override
        protected void onProgressUpdate(Integer... values) {
            super.onProgressUpdate(values);
            mSeekBar.setProgress(values[0]);
        }
         
        // 请求结果回调，该函数运行在主线程中，
        // 该函数是在doInBackground()中return后回调，即doInBackground()做完了
        // 比如提示用户下载成功，隐藏进度条
        @Override
        protected void onPostExecute(String s) {
            super.onPostExecute(s);
            mSeekBar.setVisibility(View.GONE);
            mTextTips.setText(s);
        }

        // 任务取消回调，该函数运行在主线程中，
        // 在AsyncTask调用了cancel()后回调，并将当前doInBackground()的结果作为参数传入
        // 比如可以用来提示用户下载已取消
        @Override
        protected void onCancelled(String s) {
            super.onCancelled(s);
            mSeekBar.setVisibility(View.GONE);
            mTextTips.setText("取消下载");
        }
    }
}

在上面的Demo里我创建了一个DownloadAsyncTask内部类继承自AsyncTask，并指定参数类型分别为Void，Integer，String，这三个参数分别为传入的参数类型，进度的参数类型，返回结果的参数类型，若无参数则使用Void指定。

注意：

• 每一个AsyncTask对象只能调用一次execute()，否则会抛出异常，具体原因稍后会讲。
• 调用execute()函数一定要在主线程中，因为onPreExecute()函数是在调用execute()的线程中回调的，若要在onPreExecute()函数中更新UI，就要在主线程中调用execute()。
• 调用cancel()取消任务，其实就是调用的Thread.interrupt()，然后抛出异常，使其达到取消的效果。如果要做到真正的取消，就在doInBackground()中使用取消Thread相同的方式进行取消。
• 不可以直接调用onPreExecute()，doInBackground()，onPostExcute()，onProgressUpdate()，onCancelled()五个回调函数。直接调用没有任何意义，就更没有必要使用AsyncTask了。

源码

// AsyncTask是一个带有泛型参数的抽象类，子类需要继承它并指定参数类型
// Params是调用execute()时传入的参数
// Progress是更新进度时的参数
// Result是返回结果时的参数
public abstract class AsyncTask<Params, Progress, Result> {
    private static final String LOG_TAG = "AsyncTask";
    
    // CPU可用的处理器个数
    private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
    // We want at least 2 threads and at most 4 threads in the core pool,
    // preferring to have 1 less than the CPU count to avoid saturating
    // the CPU with background work
    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 ThreadFactory sThreadFactory = new ThreadFactory() {
        private final AtomicInteger mCount = new AtomicInteger(1);

        public Thread newThread(Runnable r) {
            return new Thread(r, "AsyncTask #" + mCount.getAndIncrement());
        }
    };
    
    // 阻塞任务队列
    private static final BlockingQueue<Runnable> sPoolWorkQueue =
            new LinkedBlockingQueue<Runnable>(128);

    // 真正执行具体任务的线程池
    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;
    }

    // 任务队列线程池，即任务调度
    public static final Executor SERIAL_EXECUTOR = new SerialExecutor();

    // 任务完成的消息
    private static final int MESSAGE_POST_RESULT = 0x1;
    // 更新进度的消息
    private static final int MESSAGE_POST_PROGRESS = 0x2;

    // 默认的线程池，默认线程池是任务队列线程池，
    // 也可以通过setDefaultExecutor(Executor exec)自定义线程池
    private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
    // 该Handler用于切换到主线程
    private static InternalHandler sHandler;

    // 真正执行任务的地方，即doInBackground()
    private final WorkerRunnable<Params, Result> mWorker;
    private final FutureTask<Result> mFuture;
    
    // 任务的当前状态，使用volatile修饰，表示该变量是可变的，
    // 但是同一时间只允许一个线程修改它，是线程安全的
    private volatile Status mStatus = Status.PENDING;
    
    // 任务是否已经取消
    private final AtomicBoolean mCancelled = new AtomicBoolean();
    // 任务是否已经执行
    private final AtomicBoolean mTaskInvoked = new AtomicBoolean();

    private final Handler mHandler;

    // 任务调度线程池，使用了ArrayDeque维护了一个任务队列，
    // 使任务能够有序执行，同一时间只能执行一个任务，按照时间顺序依次执行
    private static class SerialExecutor implements Executor {
        // 任务队列
        final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
        // 当前正在执行的任务
        Runnable mActive;

        // 使用synchronized修饰该函数，同一时刻只有一个线程能够执行，保证线程安全
        public synchronized void execute(final Runnable r) {
            // 向任务队列加入新的任务
            mTasks.offer(new Runnable()) {
                public void run() {
                   try {
                        // 执行具体任务
                        r.run();
                    } finally {
                        // 任务执行完成，就会调用scheduleNext()去执行下一个任务
                        scheduleNext();
                    }
                }
            });
            // 第一次会走该case
            if (mActive == null) {
                scheduleNext();
            }
        }

        // 使用synchronized修饰该函数，同一时刻只有一个线程能够执行，保证线程安全
        protected synchronized void scheduleNext() {
            // 从任务队列取出任务，并放到执行具体任务的线程池中执行
            if ((mActive = mTasks.poll()) != null) {
                THREAD_POOL_EXECUTOR.execute(mActive);
            }
        }
    }

    // 任务状态
    public enum Status {
        // 等待        
        PENDING,
        // 执行中      
        RUNNING,
        // 完成
        FINISHED,
    }

    // 获取主线程的Handler，用于切换线程，更新UI
    private static Handler getMainHandler() {
        // 使用同步代码块保证线程安全
        synchronized (AsyncTask.class) {
            // 使用主线程Looper创建Handler
            if (sHandler == null) {
                sHandler = new InternalHandler(Looper.getMainLooper());
            }
            return sHandler;
        }
    }

    private Handler getHandler() {
        return mHandler;
    }

    // 设置默认的线程池
    public static void setDefaultExecutor(Executor exec) {
        sDefaultExecutor = exec;
    }

    // 空参数的构造函数，实际是调用带有Looper参数的构造函数
    public AsyncTask() {
        this((Looper) null);
    }

    // 带有Handler的构造函数，实际是调用带有Looper参数的构造函数
    public AsyncTask(@Nullable Handler handler) {
        this(handler != null ? handler.getLooper() : null);
    }

    // 带有Looper的构造函数，即核心构造函数，该函数中没有执行具体的任务，
    // 只是初始化了几个变量，一个mHandler，一个mWorker和一个mFuture
    // mWorker和mFuture是为执行具体任务做准备的变量，初始化好等待使用
    public AsyncTask(@Nullable Looper callbackLooper) {
        mHandler = callbackLooper == null || callbackLooper == Looper.getMainLooper()
            ? getMainHandler()
            : new Handler(callbackLooper);
        
        // 新建一个WorkerRunable()对象
        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;
            }
        };
        
        // 新建一个Future对象，将mWorker传入
        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);
                }
            }
        };
    }

    // 任务取消后会被调用，即执行到mFuture.done()函数
    private void postResultIfNotInvoked(Result result) {
        final boolean wasTaskInvoked = mTaskInvoked.get();
        // 任务没有执行则调用postResult(result)通知任务执行完成，
        // 即没有执行到mWorker.call()函数，因为mTaskInvoked是在mWorker.call()中设置为true的。
        if (!wasTaskInvoked) {
            // 任务还没有开始就取消了
            postResult(result);
        }
    }

    // 任务执行完会调用该函数
    private Result postResult(Result result) {
        @SuppressWarnings("unchecked")
        // 通过Handler切换至主线程执行
        Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
                new AsyncTaskResult<Result>(this, result));
        message.sendToTarget();
        return result;
    }

    // 获取当前任务状态
    public final Status getStatus() {
        return mStatus;
    }
    
    // 该函数是抽象的，一定会被子类重写，运行在工作线程中，处理具体任务
    @WorkerThread
    protected abstract Result doInBackground(Params... params);

    // 该函数可根据需求重写，运行在主线程中，在doInBackground()之前会调用
    // 可做UI的前期准备工作
    @MainThread
    protected void onPreExecute() {
    }

    // 该函数可根据需求重写，运行在主线程中，在doInBackground()执行完会被调用
    // 可处理结果，更新UI；任务做完就会回调
    @SuppressWarnings({"UnusedDeclaration"})
    @MainThread
    protected void onPostExecute(Result result) {
    }

    // 该函数可根据需求重写，运行在主线程中，
    // 在doInBackground()中调用publishProgress()方可执行到该函数，
    // 可在UI中实时更新任务进度
    @SuppressWarnings({"UnusedDeclaration"})
    @MainThread
    protected void onProgressUpdate(Progress... values) {
    }

    // 该函数可根据需求重写，运行在主线程中，调用AsyncTask.cancel()后会被调用，
    // 可更新UI
    @SuppressWarnings({"UnusedParameters"})
    @MainThread
    protected void onCancelled(Result result) {
        onCancelled();
    }    
    
     // 该函数可根据需求重写，运行在主线程中，调用AsyncTask.cancel()后会被调用，
    // 可更新UI
    @MainThread
    protected void onCancelled() {
    }

    // 当前任务是否已取消
    public final boolean isCancelled() {
        return mCancelled.get();
    }
    
     // 取消任务
     public final boolean cancel(boolean mayInterruptIfRunning) {
        // 设置当前取消状态
        mCancelled.set(true);
        // mFuture.cancel()内部是调用的Thread.interrupt()
        return mFuture.cancel(mayInterruptIfRunning);
    }

    /**
     * Waits if necessary for the computation to complete, and then
     * retrieves its result.
     *
     * @return The computed result.
     *
     * @throws CancellationException If the computation was cancelled.
     * @throws ExecutionException If the computation threw an exception.
     * @throws InterruptedException If the current thread was interrupted
     *         while waiting.
     */
    public final Result get() throws InterruptedException, ExecutionException {
        return mFuture.get();
    }

    // 该函数开始执行任务了，传入的参数类型则是该类上泛型的第一个参数类型
    // 运行在主线程中，会返回一个具体AsyncTask对象
    @MainThread
    public final AsyncTask<Params, Progress, Result> execute(Params... params) {
        return executeOnExecutor(sDefaultExecutor, params);
    }

    // 该函数传入一个线程池和具体的参数，AsyncTask可以直接调用该函数传入自定义的线程池
    @MainThread
    public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,
            Params... params) {
        // 如果当前任务不是等待状态就会抛出异常，也就是为什么一个AsyncTask不能调用两次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)");
            }
        }
        
        // 设置任务正在执行中
        mStatus = Status.RUNNING;
        
        // 调用onPreExecute()，可在UI线程中做任务开始前的准备工作
        onPreExecute();
        
        // 将参数传给mWorker
        mWorker.mParams = params;
        // 若没有自定义线程池，则使用默认的线程池，将mFuture加入到任务队列执行，
        // 若有自定义线程池，则根据自定义线程池的规则去执行
        exec.execute(mFuture);

        return this;
    }

    // 该函数也可以直接调用，但是要传入具体的任务，加入到任务队列等待执行，
    // 即不需要使用AsyncTask的mFuture
    @MainThread
    public static void execute(Runnable runnable) {
        sDefaultExecutor.execute(runnable);
    }

    // 该函数用于更新进度，在doInBackground()中调用
    @WorkerThread
    protected final void publishProgress(Progress... values) {
        // 任务没有取消，则使用Handler切换至主线程
        if (!isCancelled()) {
            getHandler().obtainMessage(MESSAGE_POST_PROGRESS,
                    new AsyncTaskResult<Progress>(this, values)).sendToTarget();
        }
    }
    
    // 该函数是在InternalHandler中收到MESSAGE_POST_RESULT消息时调用
    private void finish(Result result) {
        // 如果任务已经取消了，则回调onCancelled()函数，
        // 否则回调onPostExecute()函数
        if (isCancelled()) {
            onCancelled(result);
        } else {
            onPostExecute(result);
        }
        // 设置任务执行完成
        mStatus = Status.FINISHED;
    }
    
    // 内部Handler，该Handler运行在主线程中
    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;
            }
        }
    }

    // 实现了Callable接口，并保存一个参数，用于doInBackground()做任务时需使用的参数
    private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {
        Params[] mParams;
    }
    
     // 结果实体类
     // 第一个函数是当前AsysncTask对象
    // 第二个函数是任务结果
    @SuppressWarnings({"RawUseOfParameterizedType"})
    private static class AsyncTaskResult<Data> {
        final AsyncTask mTask;
        final Data[] mData;

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

总结

分析了AsyncTask的源码后，是不是就有了更深的了解呢，我想是的，反正我对它的了解是更深了。

• AsyncTask是抽象类，必须创建其子类并继承AsyncTask，指定其泛型参数类型方可使用；doInBackground()是抽象函数，其子类一定会重写，它是执行具体任务的函数；onPreExecute()，onProgressUpdate()，onPostExecute()，onCancelled()四个函数可根据实际项目需求进行重写。
• AsyncTask会提供两个线程池和一个Handler；线程池THREAD_POOL_EXECUTOR用来执行具体任务；线程池SERIAL_EXECUTOR用来任务调度，其内部使用了ArrayDeque维护了一个任务队列，当调用execute(Runnable r)函数时，会将任务r添加到任务队列中，如果是第一个任务，则直接调用scheduleNext()从任务队列中取出任务，作为参数调用THREAD_POOL_EXECUTOR的execute()函数执行；Handler是运行在主线程的，因为它是通过getMainLooper()创建的，在主线程进行消息循环，主要作用就是从工作线程切换至主线程，方便主线程通过回调直接更新UI。
• 创建一个AsyncTask子类，无论使用哪个构造函数，最终都会调到带有Looper参数的构造函数，在该构造函数内部，只初始化了两个变量，没有执行具体的任务，首先通过new WorkerRunnable<Params, Result>()初始化了mWorker变量，由于WorkerRunable实现了Callable接口，所以实现其call()函数；然后通过new FutureTask<Result>(mWorker)初始化了mFutue变量，并重写了done()函数，由此可见，创建FutureTask时将mWorker作为参数传入，因为FutureTask实现了RunnableFuture，而RunnableFuture又继承自Runnble，所以WorkRunnable的call()函数就是由FutureTask的run()函数触发的；调用execute(Params... params)传入doInBackground()函数所使用的参数开始执行任务，execute(Params... params)内部会返回executeOnExecutor(sDefaultExecutor, params)；executeOnExecutor(sDefaultExecutor, params)函数会传入默认的线程池，默认的线程池可以通过setDefaultExecutor(Executor exec)函数指定一个自定义的线程池，否则使用的是线程池SERIAL_EXECUTOR，首先该函数内部会判断当前状态，如果不是等待中则抛出异常，否则会先回调onPreExecute()函数，因为doInBackground()函数是在WorkRunnbale的call()函数中执行的，然后将params设置给mWoker.mParams，然后调用exec.execute(mFuture)，若该线程池是SERIAL_EXECUTOR，则按照SERIAL_EXECUTOR的规则去执行任务，若该线程池是自定义的，则按照自定义线程池的规则去执行任务，最后返回this。
• executeOnExecutor(sDefaultExecutor, params)函数内部最终调用了exec.execute(mFuture)，这里只讲默认线程池SERIAL_EXECUTOR，实则是调用了SerialExecutor的execute(Runnable r)函数，首先将当前的mFuture加入到了任务队列，然后从消息队列取出任务通过线程池THREAD_POOL_EXECUTOR去执行具体任务，终于使用到了mFuture，之前说过mWorker的call()函数是在mFuture的run()函数中触发的，没错，call()函数触发了，doInBackground()函数执行了；若在执行过程中调用cancel()取消任务了，则call()函数中会捕获异常，因为调用cancel()取消任务，内部调用的是mFutere.cancel()，最终调用Thread.interrupt()函数，所以通过捕获异常来达到取消任务的目的；若任务执行正常，在doInBackground()函数执行完，会调用postResult(result)返回结果。
• mFuture.done()在什么时候执行呢？在FutureRunnable.finishCompletion()内部执行的；FutureRunnable.finishCompletion()又在什么时候执行呢？线程执行完或者取消线程时执行；现在来看一下done()函数，内部调用了postResultIfNotInvoked(get())，若捕获到了CancellationException异常，则调用postResultIfNotInvoked(null)，postResultIfNotInvoked()函数内部会判断mTaskInvoked的状态是否已经开始执行，若没有开始则调用postResult(result)函数。