【源码分析】AsyncTask源码分析

AsyncTask类在早期的开发中占的比重很是重，由于它能够方便的将耗时工做与UI线程链接在一块儿，随着android版本的更新、业务的复杂度增长AsyncTask的愈来愈不能知足业务的需求，好比它不能取消一个正在执行的任务。可是AsyncTask中将耗时线程和UI线程工做组合在一块儿的思想仍是值得咱们好好学习借鉴一下的，那么咱们就来分析一下AsyncTask这个经典类的源码。

按照AsyncTask的功能咱们从两个方面来分析一下源码：耗时线程如何工做、UI线程如何工做。

耗时线程

public AsyncTask() {
        mWorker = new WorkerRunnable<Params, Result>() {
            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<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 static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {
        Params[] mParams;
    }

WorkerRunnbale是个抽象类实现了Callable接口，同时添加mParams变量用来接收参数，mWorker实现了一个匿名的WorkerRunnable类，而且把全部须要处理的任务都封装在call方法中，doInBackground方法表示咱们须要的耗时任务，postResult方法表示更新UI的操做。mFuture变量则是一个FutureTask的变量，咱们把上面定义的mWorker封装在mFuture中，这样就方便咱们的线程池调用。因此在构造方法中，封装了全部的任务到一个mFuture变量中。接着往下看executor方法。

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

在executor方法中，调用了executeOnExecutor方法，而且传递了一个Executor变量sDefaultExecutor，这个变量实际上是一个线程池变量，后面咱们介绍。在executeOnExecutor方法中首先判断了一下当前AsyncTask的状态，若是是RUNNING或者是FINISHED则说明当前的状态不对，不能执行新增的任务。检查以后，首先设置状态为RUNNING状态，而后执行onPreExecute方法，因此这个方法也是在UI线程中执行的一样不能作一些耗时操做。 紧接着用mWorker.mParams变量来接收exexutor传递过来的参数，最后一步就是用调用了线程池的execute方法把mFuture添加到了线程池中。终上所述，调用exexutor方法以后，会把mFuture这个咱们定义好的任务添加到sDefaultExexutor这个预先定义好的线程池中。

UI线程

调用executor方法以后，任务会在线程池中获得执行。也就是doBackground方法会在线程池中执行，那么在任务执行完成以后，如何调用到了UI线程呢？mWorker的call方法最后返回的是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;
    }
    ...
    private static Handler getHandler() {
    synchronized (AsyncTask.class) {
        if (sHandler == null) {
            sHandler = new InternalHandler();
        }
        return sHandler;
    }
}

...

在postResult方法中，首先经过getHandler方法获取到了一个Handler对象，从getHandler中能够看到这个Handler是一个InternalHandler的实例。获取handler以后，经过obtainMessage方法获取一个关联到InternalHandler类的Message对象，而后将AsyncTask和doBackground计算的结果封装到AsyncTaskResult中，发送给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;
            }
        }
    }

从InternalHandler的定义中能够看到，它在构造方法中关联了UI线程的mainLooper，那么这个Handler也就是在UI线程中处理事务。因此在postResult中将result结果发送给了一个关联UI线程的Handler来处理。若是是任务完成，传递的message.what就是MESSAGE_POST_RESULT，它最后会调用AsyncTask的finish方法。

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

最后也就是调用到了onPostExecute这个方法上来了。

最后说说sDefaultExecutor这个线程池。其实sDefaultExecutor并非一个线程池，它只是实现了Executor接口的一个类SerialExecutor ，看源码

public static final Executor THREAD_POOL_EXECUTOR
            = new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,
                    TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);
     ...
    public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
     ...
    private static volatile Executor sDefaultExecutor = SERIAL_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);
            }
        }
    }

调用execute方法时，会从新封装一下runnbale，而且将封装后的runnbale添加到阻塞队列ArrayDeque中，同时检查mActive是否为空，若是为空的话，从ArrayDeque中取出一个runnable，放到线程池THREAD_POOL_EXECUTOR中执行这个runnable。