AsyncTask

基于android api27源码。

开始

AsyncTask将在异步线程进行计算，然后主线程发布结果进行了包装，免去了手动操作Thread和Handler类。
AsyncTask应该尽量用来计算耗时较短的操作（最多几秒钟）。如果你需要进行长时间的异步运算，推荐使用线程池技术。

下面是使用AsyncTask的一个例子：

 private class DownloadFilesTask extends AsyncTask<URL, Integer, Long> {
     protected Long doInBackground(URL... urls) {
         int count = urls.length;
         long totalSize = 0;
         for (int i = 0; i < count; i++) {
             totalSize += Downloader.downloadFile(urls[i]);
             //发布进度
             publishProgress((int) ((i / (float) count) * 100));
             // Escape early if cancel() is called
             if (isCancelled()) break;
         }
         return totalSize;
     }

     protected void onProgressUpdate(Integer... progress) {
         setProgressPercent(progress[0]);
     }

     protected void onPostExecute(Long result) {
         showDialog("Downloaded " + result + " bytes");
     }
 }

然后如下调用：

 new DownloadFilesTask().execute(url1, url2, url3);

AsyncTask的三个泛型参数如下：

1. Params：需要传递的参数。
2. Progress：进度的类型。
3. Result：运算结果的类型。

如果某个参数不需要，可以使用Void。

AsyncTask的运行步骤

1. onPreExecute()：UI线程执行，表示异步任务即将开始。该方法通常用来设置任务，比如展示一个进度条。
2. doInBackground(Params ...)：异步线程执行，在onPreExecute()之后执行。该方法执行具体的异步运算，运算结果传递给最后一步。该方法也可以通过调用publishProgress(Progress ...)方法来向UI线程发布进度。
3. onProgressUpdate(Progress ...)：接收publishProgress(Progress ...)方法发布的进度。可以通过该方法更新进度条。
4. onPostExecute(Result)：UI线程执行，接收异步运算的结果。

取消任务

可以在任意时间通过调用cancel(boolean)方法取消任务。
调用该方法后，isCancelled()方法会返回true。并且doInBackground(Object[])运行完毕后，会执行onCancelled(Object)而非onPostExecute(Object)。
为了保证尽快取消任务，需要尽可能多的检查isCancelled()方法是不是返回true。

线程规则

为了保证AsyncTask正常运行，需要遵循如下规则：

1. AsyncTask类必须在UI线程加载。
2. AsyncTask实例必须在UI线程创建。
3. execute(Params ...)方法必须在UI线程调用。
4. 不要手动调用onPreExecute()、onPostExecute(Result)、doInBackground(Params ...)、onProgressUpdate(Progress ...)。
5. 每个任务只能执行一次，第二次执行会抛出异常。

执行顺序

AsyncTask刚出现时，通过一个单一的异步线程串行执行；
api4开始，使用了线程池，可以并行运行；
api11开始，通过单一线程串行执行。

如果确实想要并行运行，可以调用executeOnExecutor(Executor, Object[]方法。

---

静态变量

介绍两个公有静态常量，外部程序可以使用。

SERIAL_EXECUTOR

    /**
     * An {@link Executor} that executes tasks one at a time in serial
     * order.  This serialization is global to a particular process.
     */
    public static final Executor SERIAL_EXECUTOR = new SerialExecutor();

SERIAL_EXECUTOR是AsyncTask默认的异步任务执行者。SerialExecutor的实现如下：

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

由源码可知，SerialExecutor最终将任务交由THREAD_POOL_EXECUTOR执行。

THREAD_POOL_EXECUTOR

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

THREAD_POOL_EXECUTOR是一个自定义了参数的线程池，各个参数如下：

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

状态

    /**
     * Indicates the current status of the task. Each status will be set only once
     * during the lifetime of a task.
     */
    public enum Status {
        /**
         * Indicates that the task has not been executed yet.
         */
        PENDING,//等待
        /**
         * Indicates that the task is running.
         */
        RUNNING,//运行
        /**
         * Indicates that {@link AsyncTask#onPostExecute} has finished.
         */
        FINISHED,//结束
    }

指示当前任务的状态，每个状态只能设置一次。

AsyncTask中的状态变量定义如下：

    private volatile Status mStatus = Status.PENDING;

volatile变量，初始值为Status.PENDING。

    public final Status getStatus() {
        return mStatus;
    }

该方法获取当前任务的状态。

构造方法

在看构造方法之前，先看几个变量：

    private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
    //默认的向主线程发送消息的handler
    private static InternalHandler sHandler;

    private final WorkerRunnable<Params, Result> mWorker;
    private final FutureTask<Result> mFuture;
    
    //当前任务是否被取消
    private final AtomicBoolean mCancelled = new AtomicBoolean();
    //当前任务是否被执行
    private final AtomicBoolean mTaskInvoked = new AtomicBoolean();

    //当前异步任务使用的handler
    private final Handler mHandler;

InternalHandler是一个静态内部类：

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

该类用来将异步线程的进度和结果发送到主线程。

finish方法如下：

    private void finish(Result result) {
        if (isCancelled()) {
            onCancelled(result);
        } else {
            onPostExecute(result);
        }
        //状态置为结束态
        mStatus = Status.FINISHED;
    }

AsyncTaskResult也是一个静态内部类：

    @SuppressWarnings({"RawUseOfParameterizedType"})
    private static class AsyncTaskResult<Data> {
        final AsyncTask mTask;
        final Data[] mData;

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

该类用来传递异步任务的进度和结果。

WorkerRunnable是一个静态内部抽象类：

    private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {
        //用来传递参数
        Params[] mParams;
    }

有如下三个构造方法，但只有第一个是外部可用的，其他两个都有@hide注解：

    /**
     * Creates a new asynchronous task. This constructor must be invoked on the UI thread.
     */
    public AsyncTask() {
        this((Looper) null);
    }

    /**
     * Creates a new asynchronous task. This constructor must be invoked on the UI thread.
     *
     * @hide
     */
    public AsyncTask(@Nullable Handler handler) {
        this(handler != null ? handler.getLooper() : null);
    }

    /**
     * Creates a new asynchronous task. This constructor must be invoked on the UI thread.
     *
     * @hide
     */
    public AsyncTask(@Nullable Looper callbackLooper) {
        mHandler = callbackLooper == null || callbackLooper == Looper.getMainLooper()
            ? getMainHandler()//返回默认的向UI线程发送消息的sHandler
            : new Handler(callbackLooper);

        mWorker = new WorkerRunnable<Params, Result>() {
            public Result call() throws Exception {
                mTaskInvoked.set(true);//任务执行标记设为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;
            }
        };

        //将Callable包装成FutureTask，以便Executor执行。
        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);
                }
            }
        };
    }

    //任务未被调用时，发布结果
    private void postResultIfNotInvoked(Result result) {
        final boolean wasTaskInvoked = mTaskInvoked.get();
        if (!wasTaskInvoked) {
            postResult(result);
        }
    }

postResult(Result)方法负责向mHandler发送带有运算结果的消息。

可覆写的protected方法

    @MainThread
    protected void onPreExecute() {
    }

    @MainThread
    protected void onPostExecute(Result result) {
    }

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

    @MainThread
    protected void onCancelled(Result result) {
        onCancelled();
    }  

    @MainThread
    protected void onCancelled() {
    }

其他方法

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

用来发布进度

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

尝试取消任务。若任务已经结束，或者无法取消，则返回false。

    public final boolean isCancelled() {
        return mCancelled.get();
    }

判断任务是否已取消。

    public final Result get() throws InterruptedException, ExecutionException {
        return mFuture.get();
    }

    public final Result get(long timeout, TimeUnit unit) throws InterruptedException,
            ExecutionException, TimeoutException {
        return mFuture.get(timeout, unit);
    }

阻塞方法，获取执行结果。

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

执行任务。

    @MainThread
    public static void execute(Runnable runnable) {
        sDefaultExecutor.execute(runnable);
    }

静态方法，使用AsyncTask的默认的Executor执行任务，注意是串行执行。