AsyncTask使用总结和源码分析

简介

当android应用启动的时候会启动一条主线程，这个主线程负责向UI组件分发事件（包括绘制事件），随意当在主线程你都会阻塞UI线程，导致事件停止分发（包括绘制事件），如果UI线程blocked的时间太长（大约超过5秒），用户就会看到ANR（application not responding）的对话框，所以当我们执行耗时任务的时候要在子线程来做（访问网络、数据库查询等等），所以主线程和子线程的通信就成为了关键，android提供了handler可以让主线程和子线程通信，其中AsyncTask是通过handler和线程池来实现的轻量化异步任务的工具。（以下所有源码来自23版本）

用法

可以看下AsyncTask类的简化代码

public abstract class AsyncTask {


   abstract Result doInBackground(Params... params);


    void onPreExecute() {}


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


    protected void onPostExecute(Result result) {}
}

可以看到AsyncTask是个抽象类，有个唯一的抽象方法是doInBackground和三个泛型Params, Progress, Result，三个泛型分别是doInBackground，onProgressUpdate，onPostExecute方法的形参类型。实现AsyncTask一般要实现代码中的那几个方法，现在让我们看看这几个方法的用处。
- doInBackground(Params… params)：
就像它的名字那样，是在子线程执行的，所以耗时任务写这里面
- onPreExecute()：
在execute(Params… params)被调用后立即执行，一般用来在执行后台任务前对UI做一些标记，在主线程执行
- onProgressUpdate(Progress… values)：
在调用publishProgress(Progress… values)时，此方法被执行，直接将耗时任务进度信息更新到UI组件上，在主线程执行
- onPostExecute(Result result)：
当后台异步任务结束，此方法将会被调用，result为doInBackground返回的结果，在主线程执行

在实现完AsyncTask抽象类后调用execute(Params… params)方法来执行异步任务。

注意事项

• 当AsyncTask为非静态内部类时，AsyncTask实例会带有activity的引用，当activity销毁时AsyncTask后台线程还在执行，会导致Activity无法被回收，引起内存泄露。
• AsyncTask的版本差异问题，版本实现AsyncTask的线程池会有所不一样，这样导致版本之中执行AsyncTask的效果不同，可能需要因为这个做版本兼容。
  在Android 1.6到2.3是并行的，有5个核心线程的线程池（ThreadPoolExecutor）负责调度任务。但Android 3.0开始，AsyncTask改成了串行，默认的Executor被指定为SERIAL_EXECUTOR。不过可以通过executeOnExecutor()方法自己传入线程池来实现并行，也可以调用executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR,…)利用AsyncTask.THREAD_POOL_EXECUTOR这个AsyncTask自己实现的线程池来实现并行任务。

public final AsyncTask executeOnExecutor(Executor exec,        Params... params){...}

源码分析

因为调用execute方法来执行异步任务，我们先从execute方法来分析。

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


public final AsyncTask execute(Params... params) {
    return executeOnExecutor(sDefaultExecutor, params);
}


public final AsyncTask 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;
}

看到execute实际是调用了executeOnExecutor()传进去了sDefaultExecutor的默认线程池，当调用了executeOnExecutor时，mStatus （默认是PENDING）如果不是PENDING就会抛出异常，而且在这个方法里面mStatus会赋值成RUNNING（所以execute方法只能执行一次）。
然后就执行onPreExecute方法（上面讲过这是执行前做的准备工作），最后调用exec.execute(mFuture);执行线程任务。
要知道怎么执行线程池任务要看sDefaultExecutor代码。

public static final Executor SERIAL_EXECUTOR = new SerialExecutor();


private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;


public static final Executor THREAD_POOL_EXECUTOR
        = new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE, 
               TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);


private static class SerialExecutor implements Executor {
    final ArrayDeque mTasks = new ArrayDeque();
    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);
        }
    }
}

sDefaultExecutor 实际上就是SerialExecutor ，SerialExecutor 实现了Executor 接口，在执行execute，任务加入了ArrayDeque数组，mActive是当前在执行的任务，执行的任务会加入THREAD_POOL_EXECUTOR线程池里执行，可以看到当前有任务执行时，不会执行这个任务，而且mTasks会循环的把加入的任务串行的一个一个的执行完。
那么一个异步任务是如果个个步骤的一次调用的？首先回到构造方法来看下：

public AsyncTask() {
    mWorker = new WorkerRunnable() {
        public Result call() throws Exception {
            mTaskInvoked.set(true);
            Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
            //noinspection unchecked
            Result result = doInBackground(mParams);
            Binder.flushPendingCommands();
            return postResult(result);
        }
    };
    mFuture = new FutureTask(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就是上面看到的线程池执行的任务（future基本用处可以看这里Future），当mFuture被SerialExecutor执行时，会执行其mWorker。它在调用的时候，先把mTaskInvoked设置为true表示已调用，设置线程优先级，然后才执行doInBackground()方法，并执行postResult发送其返回的结果。postResult代码如下：

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


private static Handler getHandler() {
    synchronized (AsyncTask.class) {
        if (sHandler == null) {
            sHandler = new InternalHandler();
        }
        return sHandler;
    }
}

postResult利用getHandler获取到Handler 然后发标记为MESSAGE_POST_RESULT的消息和doInBackground返回的Result给InternalHandler，
InternalHandler代码如下：

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

可以看到InternalHandler 有两种消息，一种是MESSAGE_POST_PROGRESS用来调用onProgressUpdate方法的，也就是之前说的更新进度方法，另外是MESSAGE_POST_RESULT，调用了finish方法。

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

isCancelled是判断当前task是否取消了，取消了就调用onCancelled方法来回调result，没取消就调用onPostExecute返回result。
整个流程就到这里了。