（九） AsyncTask 使用及源码分析

版权声明：本文为博主原创文章，未经博主允许不得转载。
本文纯个人学习笔记，由于水平有限，难免有所出错，有发现的可以交流一下。

一、AsyncTask 使用

在Android 开发中，我们经常使用 Handler 与子线程进行配合，子线程通过 Handler 发送 Message 到主线程，主线程接收到 Message 后，对 UI 进行相应的更新，从而实现子线程更新 UI 操作。

AsyncTask 是一个辅助类，其实就是对 Thread 和 Handler 进行一个封装，方便我们在后台线程中执行一些操作，然后主线程根据返回的结果进行 UI 更新。我们无需关注 Thread 和 Handler 是如何进行工作的，只需要处理好自己的业务逻辑即可。

1.AsyncTask 的使用

AsyncTask 是一个抽象类，使用时候需要进行继承，

AsyncTask 三个参数：
Params 是指调用 execute() 方法时传入的参数类型和 doInBackgound() 的参数类型
Progress 是指更新进度时传递的参数类型，即 publishProgress() 和 onProgressUpdate() 的参数类型
Result 是指 doInBackground() 的返回值类型

AsyncTask 主要方法：

 public class MyTask extends AsyncTask<Void, Integer, Integer>{

        /**
         * 在 UI 线程中运行，
         * 调用 doInBackground()之前执行
         */
        @Override
        protected void onPreExecute() {

        }
        /**
         * 后台运行，主要的逻辑处理
         */
        @Override
        protected Integer doInBackground(Void... params) {
                //更新进度，给 onProgressUpdate 传递进度参数
                publishProgress(0);
            return null;
        }

        /**
         * 在 UI 线程中运行，
         * 在 doInBackground() 执行完毕后执行
         */
        @Override
        protected void onPostExecute(Integer integer) {
        }

        /**
         * 在 publishProgress() 被调用以后执行，
         * publishProgress() 用于更新进度
         */
        @Override
        protected void onProgressUpdate(Integer... values) {
        }

2.多个 AsyncTask 串行运行

对于同一个 AsyncTask 类，有多个实例的话，他们的运行顺序是串行的，需要等待前一个任务执行完毕才会执行后一个任务。

onCreate：

    private static long start;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        MyTask myTask = new MyTask();
        MyTask myTask1 = new MyTask();
        start = System.currentTimeMillis();
        myTask.execute();
        myTask1.execute();

    }

在 doInBackground 中添加 sleep 即可。
doInBackground：

        protected Integer doInBackground(Void... params) {
            publishProgress(0);
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            Log.e("MyTask", "111 zx run time:" + (System.currentTimeMillis()-start) );
            return null;
        }

结果：

注：顺便提一下，Timer 也是串行运行的。

具体原因在下方源码分析中给出。

二、AsyncTask 源码分析

AsyncTask 是直接进行 new 出来的，我们先查看其构造函数。

AsyncTask 构造函数：

   public AsyncTask() {
        this((Looper) null);
    }

    public AsyncTask(@Nullable Handler handler) {
        this(handler != null ? handler.getLooper() : null);
    }

    public AsyncTask(@Nullable Looper callbackLooper) {
        mHandler = callbackLooper == null || callbackLooper == Looper.getMainLooper()
            ? getMainHandler()
            : new Handler(callbackLooper);

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

在这里面出现两个类，WorkerRunnable 和 FutureTask，我们先分析这两个类，都比较简单。

1.WorkerRunnable

WorkerRunnable 是一个实现了 Callable 接口的抽象类，Callable 有一个 call 方法接口。
WorkerRunnable：

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

Callable：

public interface Callable<V> {
    /**
     * Computes a result, or throws an exception if unable to do so.
     *
     * @return computed result
     * @throws Exception if unable to compute a result
     */
    V call() throws Exception;
}

2.FutureTask

**作用：**FutureTask 会先执行 WorkerRunnable 中的 call 方法，执行完毕之后，调用 done 方法进行回调。

FutureTask 实现了接口 RunnableFuture，接口 RunnableFuture 继承 Runnable 和 Future，其实，本质上就是 FutureTask 实现了对 Runnable 的一个封装。我们查看 FutureTask 的 run 方法。

* FutureTask 的 run：*

    public void run() {
        if (state != NEW ||
            !U.compareAndSwapObject(this, RUNNER, null, Thread.currentThread()))
            return;
        try {
            Callable<V> c = callable;
            if (c != null && state == NEW) {
                V result;
                boolean ran;
                try {
                    //调用 WorkerRunnable 的 call 方法。
                    result = c.call();
                    ran = true;
                } catch (Throwable ex) {
                    result = null;
                    ran = false;
                    setException(ex);
                }
                if (ran)
                    //会调到自身的 done 方法，该方法被重写
                    set(result);
            }
        } finally {
            // runner must be non-null until state is settled to
            // prevent concurrent calls to run()
            runner = null;
            // state must be re-read after nulling runner to prevent
            // leaked interrupts
            int s = state;
            if (s >= INTERRUPTING)
                handlePossibleCancellationInterrupt(s);
        }
    }

FutureTask 的 run 中会调用到 WorkerRunnable 的 call 方法，WorkerRunnable 是在初始化时候传递进来的，执行完毕之后，调用到自身方法 set(result)，set 调用到 finishCompletion 方法，finishCompletion 方法会调用到 done ，这个方法在实现的时候被重写，从而实现回调。

set 和 finishCompletion 方法：

    protected void set(V v) {
        if (U.compareAndSwapInt(this, STATE, NEW, COMPLETING)) {
            outcome = v;
            U.putOrderedInt(this, STATE, NORMAL); // final state
            finishCompletion();
        }
    }

    private void finishCompletion() {
        // assert state > COMPLETING;
        for (WaitNode q; (q = waiters) != null;) {
            if (U.compareAndSwapObject(this, WAITERS, q, null)) {
                for (;;) {
                    Thread t = q.thread;
                    if (t != null) {
                        q.thread = null;
                        LockSupport.unpark(t);
                    }
                    WaitNode next = q.next;
                    if (next == null)
                        break;
                    q.next = null; // unlink to help gc
                    q = next;
                }
                break;
            }
        }

        done();

        callable = null;        // to reduce footprint
    }

3.AsyncTask

AsyncTask 的执行是通过调用 execute 方法开始的，我们从 execute 方法开始分析。

AsyncTask 的 execute：

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

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

execute 调用了 executeOnExecutor 方法，先执行了 onPreExecute 方法，然后在通过 exec （即 sDefaultExecutor ）进行执行 mFuture。这是 onPreExecute 在 doInBackground 之前执行的原因。

sDefaultExecutor 中包含一个 AsyncTask 实现的内部线程池 THREAD_POOL_EXECUTOR，通过这个线程池进行运行 AsyncTask ，代码也相对比较简单。

不过要注意的是，在 SerialExecutor 中，调用 execute 方法，只是把 Runnable 添加到任务队列中进行排队，而不是马上执行，只有当一个 Runnable 执行完毕之后，才会继续执行后一个 Runnable。由于 sDefaultExecutor 在 AsyncTask 中是静态的，所以对于同一个 AsyncTask，如果有多个实例，他们的执行是串行的。

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

在 SerialExecutor 中通过线程池执行了 Runnable 的 run 方法，这个 Runnable 就是上面 executeOnExecutor 传递进来的全局变量 mFuture。这个是在构造函数中进行初始化。

AsyncTask 构造函数：

   public AsyncTask() {
        this((Looper) null);
    }

    public AsyncTask(@Nullable Handler handler) {
        this(handler != null ? handler.getLooper() : null);
    }

    public AsyncTask(@Nullable Looper callbackLooper) {
        mHandler = callbackLooper == null || callbackLooper == Looper.getMainLooper()
            ? getMainHandler()
            : new Handler(callbackLooper);

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

我们前面分析过，执行 mFuture，会先执行 mWorker 的 call 方法，当执行完毕后，会回调 mFuture 的 done 方法。在 mWorker 的 call 中调用到了 doInBackground 方法。执行完毕之后，mFuture 的 done 方法调用了 postResultIfNotInvoked。

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

postResultIfNotInvoked 调用了 postResult 方法，在 postResult 中，通过 Handler 发送消息 MESSAGE_POST_RESULT。

getHandler 获取的 mHandler 是在构造函数中初始化的。
AsyncTask 的 getHandler：

    private Handler getHandler() {
        return mHandler;
    }

mHandler 在初始化的时候，是通过 getMainHandler 进行初始化的 InternalHandler。
AsyncTask 的 getMainHandler：

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

我们进行查看 InternalHandler 代码，查看消息 MESSAGE_POST_RESULT，直接调用的是 AsyncTask 的 finish 方法。
AsyncTask 的 InternalHandler ：

    private static class InternalHandler extends Handler {
        public InternalHandler(Looper looper) {
            super(looper);
        }

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

继续查看 AsyncTask 的 finish 方法，如果不是取消的话，进行调用 onPostExecute 进行回调。这是 onPostExecute 在 doInBackground 执行完毕之后执行的原因。
AsyncTask 的 finish：

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

流程至此结束。

三、AsyncTask 并行运行

有时候由于需求的原因，我们要求多个 AsyncTask 任务并行执行。可以直接使用 AsyncTask 的 executeOnExecutor 方法，这个方法需要传递一个线程池下去，只要线程池中没有排队这个逻辑，就可以并行运行。

我们前面分析可以发现，AsyncTask 中有一个自带的线程池 THREAD_POOL_EXECUTOR，可以直接使用这个即可。

onCreate：

    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        MyTask myTask = new MyTask();
        MyTask myTask1 = new MyTask();
        start = System.currentTimeMillis();
        myTask.executeOnExecutor(MyTask.THREAD_POOL_EXECUTOR);
        myTask1.executeOnExecutor(MyTask.THREAD_POOL_EXECUTOR);

    }

结果：

当然，也可以使用自己实现的线程池进行任务的执行。