Android AsyncTask源码解析

AsyncTask是平时我们用于异步线程修改UI的一个类，我们需要继承这个抽象类，添加自己的实现

这个类本质上缩减我处理子线程和UI线程的交互过程，隐藏了handler。这里值得一提，我们所见到的，几乎所有异步线程更新UI，本质都是使用了hanlder和主线程进行信息交互，而大多数工具类只是对这个过程进行了封装。

为了更加好地理解AsyncTask，本篇文章对AsyncTask的源码进行解析说明，希望能给大家带来帮助。

我们知道AsyncTask使用时要先new出一个对象了，所以我们从其构造方法开始看起

/**
     * Creates a new asynchronous task. This constructor must be invoked on the UI thread.
     */
    public AsyncTask() {
        mWorker = new WorkerRunnable<Params, Result>() {
            public Result call() throws Exception {
                mTaskInvoked.set(true);

                Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
                //noinspection unchecked
                return postResult(doInBackground(mParams));
            }
        };

        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 occured while executing doInBackground()",
                            e.getCause());
                } catch (CancellationException e) {
                    postResultIfNotInvoked(null);
                }
            }
        };
    }

构造方法中创建了两个对象，一个是mWorker，它实现了Callable接口

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

一个是mFuture，它继承了FutureTask抽象类(匿名内部类的本质就是继承)，然后将mWworker当成参数传了进去
对于这两个接口和类可能不熟悉JAVA多线程的朋友不怎么熟悉，其实这个两类的对应者，分别是Runnable接口和Thread类，我们可以将两者进行对比

两者都是用于执行异步线程的，不同的是Callbale接口和FutureTask类在异步结束以后，会有一个返回值

我们一般使用Runnable接口和Thread类来创建的异步线程，是没有返回值的。

OK，暂时我们只需要了解我们创建了这个两个对象，至于他们具体做了什么，我们先不管。

接下来，我看AsyncTask的execute()方法

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

结果是调用了另外一个方法：

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

首先是调用了onPreExecute()，这里还是在主线程中执行的

我们注意到，这里讲params，也就是execute()方法的参数，赋给了mWorker，这样mWorker就持有这些参数了，还记得吗？它是一个Callable，如果理解不来，我们也可以把它当做是runnable对象(其实FutureTask类才是继承了runnable接口，而callbale没有)

然后就是调用了exec.execute(mFuture)，mFuture也是在构造方法中新建的对象

但是我们先来了解exec整个参数，追溯上文，我们知道它是sDefaultExecutor，应该是AasyncTask的一个私有属性，我们看看

public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;

OK，显然我们还要看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);
            }
        }
    }

这个类中有一个队列mTasks用于存储Runnable对象，然后有一个execute()方法，这个方法新建一个runnable对象，将这个对象添加入队列

还有一个scheduleNext()方法，可以从队列中取出一个runnable，交给THREAD_POOL_EXECUTOR，这是一个线程池，也就是异步线程真正开始执行的地方

我们注意到SerialExecutor是一个静态类，也就是所有AsyncTask共用的，在一个run()方法执行完毕以后，就会调用scheduleNext()去执行下一个AsyncTask

那么归根结底，就是调用了mFuture的run()方法了，而这个run()方法，会调用mWorker类的call()方法（不要问我怎么知道的，本质就是这样，这是java并发的内容）

我们来看call()方法

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

                Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
                //noinspection unchecked
                return postResult(doInBackground(mParams));
            }
        };

第一行是原子类，设置为true表明这个线程正在执行，防止一个asynctask被执行两次

然后就是调用我们熟悉的doInBackground()方法啦，并且将execute()方法传入的参数传了进入

那么我们来看postResult()做了什么

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

其实就是将执行的result，通过handler传递到主线程中，并且这里对result做了一个封装，成了AsyncTaskResult

private static class AsyncTaskResult<Data> {
        final AsyncTask mTask;
        final Data[] mData;

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

也就是持有AsyncTask对象本身，和doInbackGound()返回的结果

我们可以看看是怎么获得主线程的handler的

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

也就是new 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;
            }
        }
    }

很好，这里是我们熟悉的代码了，继承handler，然后重写handleMessage()方法

在这个方法中，有两个状态，对于MESSAFE_POST_RESULT,调用了asyncTask的finish()方法

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

也就是调用了onPostExecute()方法，所以这个方法是在主线程中执行的

直到这里为止，一个asynctask就执行结束了

可是我们好像忘了什么，我要更新进度怎么办呢？在asycntask中，要更新进度，就必须在doInBackground()方法中主动调用publishProgress()方法

另外我们还注意到，刚才handlerMessage()方法中，还有一种情况是MESSGAE_POST_PREOGREE

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

所以本质也是讲信息交给handler去处理，切换到主线程，然后就会调用onProgressUpdate()，我们就可以在这里更新进度了