AsyncTask源码笔记

AsyncTask源码笔记

AsyncTask在注释中建议只用来做短时间的异步操作，也就是只有几秒的操作；如果是长时间的操作，建议还是使用java.util.concurrent包中的工具类，例如Executor, ThreadPoolExecutor, FutureTask等。

使用

AsyncTask类中定义了三个重要的参数类型：Params, Progress, Result。还有四个重要的过程：onPreExecute, doInBackground, onProgressUpdate, onPostExecute。

使用AsyncTask的时候必须要实现AsyncTask<Params,Progress,Result>的子类。

这三个类型分别代表：

Params: 执行时传入的参数类型

Progress: 更新时的传入的参数类型

Result: 异步返回结果的参数类型。

如果某个类型不用，在继承的时候直接使用Void类。

四个过程分别代表：

onPreExecute: 异步执行前的回调，在UI线程调用，通常用来初始化。

doInBackground: 异步执行的内容，在后台线程调用。在执行过程中可以通过publishProgress发起更新回调。

onProgressUpdate: 异步执行过程中的通知，它就是publishProgress的回调方法。它的内容是在UI线程中执行。

onPostExecute: 异步执行结束后的回调方法，它在UI线程中执行。

可以看到除了doInBackground方法之外其它的回调都是在UI线程中执行的。

取消任务

可以随时使用cancel(boolean)方法来取消一个任务。一个任务被取消之后，系统会执行onCandelled(Object)作为结果回调接口，而不是使用onPostExecute(Object)。可以使用isCancelled(Object)方法判断一个任务是否被取消。如果一个任务可能被取消的话，就尽量在doInBackground()方法中定期的检查isCancel()方法，如果任务被取消可以提早结束任务，节约资源。

注意事项

1. AsyncTask类必须在主线程中加载。在Build.VERSION_CODES.JELLY_BEAN(API 16)版本以后自动完成。
2. AsyncTask类的实例必须在UI线程中被创建。
3. execute方法必须在UI线程中调用。
4. 不能手动调用onPreExecute(), onPostExecute, doInBackground, onProgressUpdate四个方法。
5. 一个任务实例只能执行一次。(第二次执行会被抛出异常)

变量赋值

如果一个变量是AsyncTask子类的成员变量，那么：

1. 在构造函数中赋值或者在onPreExecute方法中赋值，可以在所有的回调中获取该值；
2. 在doInBackground方法中赋值，可以在onProgressUpdate，onPostExecute，onCancel中获取该值。

执行顺序

AynsTask的执行顺序随系统版本有过巨大的改变。

1. API 4 以前，它是在一个后台线程中顺序执行的，由调用顺序决定了任务的执行顺序；
2. API 4 - 11 它是在一个线程池当中并发执行的
3. API 11- ～ 它又是在一个后台线程中顺序执行。但是，如果我们想让AsyncTask并发的执行，我们可以使用executeOnExecutor方法，为它指定一个Executor对象，控制它的执行顺序。

基本原理

想要了解这个工具，我们可以从它暴露出来的接口入手，了解执行的整个流程。我这里看的是6.0的源码，其它版本的源码可能会有所不同。

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

从构造函数看起。构造函数里面先是创建了一个WorkerCallable实例mWorker，并利用它构造了一个FutureTask实例mFuture。mWorker这个对象对doInBackground方法做了封装。它先标记此对象已经执行过，再设置线程优先级，再获取doInBackground返回结果，并通过postResult方法将结果返回给了mFuture对象。在mFuture对象中，我们看到它主要是做了异常处理，并将结果交给了postResultIfNotInvoked()方法。

下面我们就看看posResult方法与postResultIfNotInvoked()方法。

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

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

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

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

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

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

可以看到，postResultIfNotInvoked方法最终还是调用了postResult方法。postResult方法通过一个单例的InternalHandler类发出了一个Message。这个InternalHandler是用主线程(UI)线程的Looper构建的，所以Message被传到了UI线程中了。最后一番辗转，在UI线程中调用了自己的finish方法。在finish方法中我们看到了两个熟悉的回调方法。并对自己的状态做了处理。

所以，我们从构造方法中就能够看到AsyncTask大致的执行流程了。接下来通过我们调用的第二个方法execute来看一看，mWorker与mFuture触发的逻辑。

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

execute方法调用了executeOnExecutor方法。它使用了一个默认的Executor对象管理线程的执行顺序。在executoOnExecutor方法中，首先对状态进行了处理，非PENDING状态执行都会抛出异常，这里可以解释为什么不能执行两次。然后首先调用了onPreExecute()方法，然后利用传进来的Executor对象执行了mFuture任务，并将自己返回。

如果你使用了指定线程池的方式调用，那么多个任务之间的执行顺序由Executor对象来控制。这个执行顺序是可以自定义控制的。

如果使用默认的顺序，那么我们来看看它的逻辑：

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

    /**
     * An {@link Executor} that can be used to execute tasks in parallel.
     */
    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<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);
            }
        }
    }

这里设计的很巧妙。先看scheduleNext()方法，它就是从队列中取出首个元素并执行。再看execute方法，每次调用execute的时候都会将一个任务放到队尾，并且这个任务封装好了目标任务。这个封装的作用是任务执行结束（正常或者异常结束）的时候，就会调用scheduleNext()方法。这样就像链表一样，一个执行结束就触发下一个，达到了顺序执行的目的。每次插入任务的时候都会检查一次是否有任务执行，没有任务执行的时候才会执行队首的任务。

AsyncTask的主要流程就差不多了, 剩下的一些调用都比较简单。

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

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

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

这里可以看到cancel完全是通过FutureTask的cancel方法来实现的。publishProgress也是通过Message-Handler来实现的。

AsyncTask的源码分析就到这里了，有什么不对的地方还请大家指教。