面试的时候在问线程通讯的时候很多人都会说到 AsyncTask，但是问到具体实现原理的时候发现很多人都不清楚，甚至有很多都是工作好几年的，感觉也是挺有意思。这里大概介绍一下吧（怎么感觉这篇文章完全是在凑字数？）。

组成 & 目的

官网资料

先列一下官方资料：Android doc AsyncTask，源代码位于 AsyncTask.java，七百行多一点的代码（排除注释后只有不到三百行，我写的其实大多都是废话，看源码最清晰了）。

组成

AsyncTask 主要包含两部分，静态线程池 + handler。
静态线程池：因为耗时操作肯定要在子线程中处理（不然就阻塞 UI 线程啦），静态线程池就是用来干这个的。
Handler：负责子线程与 UI 线程的通讯。

目的

这个类的设计目的就是可以让开发者只关心业务，因为 Android 暂时跳不出线程这个框框，还没有让开发者完全不关心线程问题的能力（简而言之就是还需要区分主线程与子线程），但是在开发者使用时又会产生关于线程处理的多余代码，所以 google 搞了一个 AsyncTask，主要的目的就是让用户只聚焦自己业务，线程的事情交由 AsyncTask 内部处理（只不过我是使用不惯这货）。

使用方式

基本使用方式如下（实例化 AsyncTask，然后 execute）：

AsyncTask<String, Integer, Exception> asyncTask = new AsyncTask<String, Integer, Exception>() {

  @Override
  protected void onPreExecute() {
    super.onPreExecute();
  }

  @Override
  protected Exception doInBackground(String... params) {
    return null;
  }

  @Override
  protected void onProgressUpdate(Integer... values) {
  }

  @Override
  protected void onPostExecute(Exception e) {
  }

  @Override
  protected void onCancelled() {
  }
};
asyncTask.execute("");

这是 google 想让开发者关心的地方，总结就是三个参数，五个回调。

三个参数

参见上边的代码，三个参数主要是指<Params, Progress, Result>，对应上边的代码就是<String, Integer, Exception>(方便区分，专门用了三个不同的类型)，
Params 是传入的参数，即 doInBackground 中的 params。
Progress 传出参数，表示进度类型，即 onProgressUpdate 中的 values。
Exception 传出参数，表示返回值类型，即 onPostExecute 中的 e。

五个回调

五个回调也挨个说一下：
onPreExecute（主线程）：开始真正的任务（doInBackground）前会调用此回调，让开发者做一些准备工作。
doInBackground（子线程）：这就是真正的耗时任务了。
onProgressUpdate（主线程）：更新进度，当用户主动调用 publishProgress 后，AsyncTask 会通过 handler 通知到主线程，然后主线程调用 onProgressUpdate 来通知开发者。
onPostExecute（主线程）：耗时任务执行完以后，执行此回调。
onCancelled（主线程）：如果耗时任务被 cancel 的话，则调用此回调。

（发现写起来比预想的更难以解释，其实看源代码比看我解释清楚多了，源代码只有两百多行，为啥就这么多人不看呢）

好吧，我们还是来直接看代码吧（其实我是真不想这么干）。

源码（android-25）

public abstract class AsyncTask<Params, Progress, Result> {
    
    // 顾名思义，CPU 的数量，主要是用来计算线程池默认包含线程的数量（最小值）
    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 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);

    // ThreadPoolExecutor 的引用（关于 ThreadPoolExecutor，就是线程池，这里不做过多介绍）
    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;
    }

    // 顾名思义，串行的执行器，至于其细节，请看 SerialExecutor 的注释
    public static final Executor SERIAL_EXECUTOR = new SerialExecutor();

    // 线程间通讯的标记，这个是用来标记传递的 Message 其中的内容为结果
    private static final int MESSAGE_POST_RESULT = 0x1;

    // 线程间通讯的标记，这个是用来标记传递的 Message 其中的内容为进度
    private static final int MESSAGE_POST_PROGRESS = 0x2;

    // 默认的执行器，默认值为串行，可通过 setDefaultExecutor 函数设置
    private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;

    // AsyncTask 中全局的、单例的、主线程的 handler，这个 handler 主要用来子线程往主线程通讯使用
    private static InternalHandler sHandler;

    // 一个 WorkerRunnable 的实例（成员变量，具体 WorkerRunnable 是干嘛的，可以看 WorkerRunnable 的注释）
    private final WorkerRunnable<Params, Result> mWorker;

    // 一个 FutureTask 的实例（成员变量，同样，具体 FutureTask 是干嘛的请看 FutureTask 的注释）
    private final FutureTask<Result> mFuture;

    // 当前 AsyncTask 的状态
    private volatile Status mStatus = Status.PENDING;
    
    // 标记是否已经被取消了
    private final AtomicBoolean mCancelled = new AtomicBoolean();
    private final AtomicBoolean mTaskInvoked = new AtomicBoolean();

    // 这也是比较坑的东西，串行控制器，所以现在 AsyncTask 没有做其他设置的话，默认是串行的
    // 但是这货却只负责将具体的 Runnable 包装了一下，然后再扔给 THREAD_POOL_EXECUTOR，并且 THREAD_POOL_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);
            }
        }
    }

    // 三种状态
    public enum Status {
        PENDING,
        RUNNING,
        FINISHED,
    }

    // 单例获取 Handler（主线程的 Handler）
    private static Handler getHandler() {
        synchronized (AsyncTask.class) {
            if (sHandler == null) {
                sHandler = new InternalHandler();
            }
            return sHandler;
        }
    }

    // 可以让开发者主动调用来设置执行器
    public static void setDefaultExecutor(Executor exec) {
        sDefaultExecutor = exec;
    }

    // 构造函数，而且注释明确写着，这个函数必须要在主线程中调用
    // 构造函数就干了两件事，初始化 mWorker 与 mFuture
    public AsyncTask() {
        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;
            }
        };

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

    // 如果 mWorker call 没有被执行的话，这通过此函数讲结果返回给开发者
    private void postResultIfNotInvoked(Result result) {
        final boolean wasTaskInvoked = mTaskInvoked.get();
        if (!wasTaskInvoked) {
            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;
    }

    // 获取当前 AsyncTask 状态
    public final Status getStatus() {
        return mStatus;
    }

    // 需要开发者必须实现的任务执行函数，此函数在工作线程执行
    @WorkerThread
    protected abstract Result doInBackground(Params... params);

    // 在执行 doInBackground 前，给用户一个回调，让开发者做一些准备工作，此函数在主线程执行
    @MainThread
    protected void onPreExecute() {
    }

    // 回调接口，可以将 doInBackground 返回的结果通过此回调返回给开发者（其实主要还是一个跨线程的问题）
    @SuppressWarnings({"UnusedDeclaration"})
    @MainThread
    protected void onPostExecute(Result result) {
    }

    // 回调接口，将进度通过此回调返回给开发者，当开发者调用 publishProgress 才会执行此回调（主要也还是因为跨线程的问题，让 sHandler 来将运行在子线程的数据传送到主线程）
    @SuppressWarnings({"UnusedDeclaration"})
    @MainThread
    protected void onProgressUpdate(Progress... values) {
    }

    // 回调接口，当开发者主动调用 cancel 时会通过此回调通知开发者
    @SuppressWarnings({"UnusedParameters"})
    @MainThread
    protected void onCancelled(Result result) {
        onCancelled();
    }    
    
    // 回调接口，当开发者主动调用 cancel 时会通过此回调通知开发者
    @MainThread
    protected void onCancelled() {
    }

    // 获取当前 AsyncTask 是否被 cancel
    public final boolean isCancelled() {
        return mCancelled.get();
    }

    // 主动 cancel 当前执行的任务
    public final boolean cancel(boolean mayInterruptIfRunning) {
        mCancelled.set(true);
        return mFuture.cancel(mayInterruptIfRunning);
    }

    // 获取执行结果，注意这是一个同步函数，只有运算结束后，此函数才会继续执行
    public final Result get() throws InterruptedException, ExecutionException {
        return mFuture.get();
    }

    // 获取执行结果，这也是同步函数，当设置的时间后如果执行仍未结束，则通过 TimeoutException 来告诉开发者
    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;
    }

    // 开发者调用的执行函数，将 runnable 传给 sDefaultExecutor
    @MainThread
    public static void execute(Runnable runnable) {
        sDefaultExecutor.execute(runnable);
    }

    // 更新进度函数，会通过 InternalHandler 把进度传递给主线程
    @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;
    }

    // 主线程的 Handler，用于工作线程与主线程之间的通讯
    private static class InternalHandler extends Handler {
        public InternalHandler() {
            super(Looper.getMainLooper());
        }

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

    // 虽然这货不是一个 Runnable，但是其实就是把一些逻辑封装到一起，可以让其他线程直接调用一个函数就可以执行了
    // 具体肯以看 AsyncTask 构造函数中 WorkerRunnable 的实例化代码，主要就是把 doInBackground 等函数包装了一下
    private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {
        Params[] mParams;
    }

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

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

注意

需要注意的是 AsyncTask 不同版本的实现是不同的，这也是比较坑的地方。