异步任务----AsyncTask解析

一.前言

AsyncTask 异步任务，是 Android 中用于异步执行耗时任务的类，封装了 Hanlder ，Message 和线程池。AsyncTask 的封装使得开发者在开发过程中不用再自己编写相应的 Handler 或者线程执行的方法。

二.简介

public abstract class AsyncTask<Params, Progress, Result> {
     ...
    @WorkerThread
    protected abstract Result doInBackground(Params... params);
     ...
}

AsyncTask 是一个抽象类,使用的时候需要实现 doInBackground 这个方法，同时需要指三个泛型参数，从名字就基本可以看出这三个参数的作用：

Params，用于指定传递给 AsyncTask 的参数类型。
Progress ，用于在任务进行中返回的任务进度的类型。
Result，用于指定任务执行完成后返回的类型。

AsyncTask 的执行从开始到结束主要有下面的几个方法：

execute，传递这个 Params 参数并开始执行任务，注意每一个 AsyncTask 对象只能执行一次，如果需要重复的任务就需要重复的创建这个对象。

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

onPreExecute，在任务执行之前调用（Pre 之前），运行在主线程，可以对 UI 做一些任务前的处理比如提示加载框等。
1
2
3
@MainThread
protected void onPreExecute() {
}
doInBackground，在工作线程执行，也就是在子线程执行，接收参数 Params 执行完成后就将 Result 类型的结果返回。

1 2	@WorkerThread protected abstract Result doInBackground(Params... params);

publishProgress,在工作线程执行，可以在 doInBackground 方法中调用，用于在任务进行的过程中不断更新 UI ,传入的参数就是之前指定的 Progress 类型。

@WorkerThread
protected final void publishProgress(Progress... values) {
    if (!isCancelled()) {
       ....
    }
}

onProgressUpdate 工作在主线程，在 publishProgress 调后，具体的 UI 的更新操作就是在 onProgressUpdate 这里执行，接收从 publishProgress 传过来的参数并执行相应的更新操作。

1
2
3

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

onPostExecute，运行在主线程，在任务执行完成后（Post 之后），任务完成后会返回一个 Result 类型的值，可以在这里获取并执行 Ui 操作。
1
2
3
@MainThread
protected void onPostExecute(Result result) {
}

onCancelled，取消任务的时候会执行，运行在住线程，对 UI 做一些状态的恢复工作。

@MainThread
protected void onCancelled(Result result) {
    onCancelled();
}    
@MainThread
protected void onCancelled() {
}

三.原理

AsyncTask 暴露出来的方法的生命期就是上面所介绍的，下面就具体看看 AsyncTask 是如何处理异步操作的。

1.创建

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

可以看到刚开始 new AsyncTask 的时候如果没有指定 Looper 或者指定的 Looper 是主线程的 Looper 就是使用 AsyncTask 封装的 Hanlder ( InternalHandler ) ，否则就根据指定的 Looper 创建一个 Hander.

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

在创建的过程中会初始化一个 WorkerRunnable ，这是一个封装的 Runnable 对象，在这个对象中首先会所处的线程的优先级设置为 Process.THREAD_PRIORITY_BACKGROUND 后台线程，然后就是将 doInBackground 方法封装在这个 workerRunnable ，然后再将这个 Runable 封装到一个 FutureTask 这是一个可以有返回值的线程任务，相对于的 Runable 就是一个没有返回值的线程任务。

2.execute 开始执行

这里首先先介绍几个重要的对象

sPoolWorkQueue,阻塞队列，使用的是 LinkedBlockingQueue 的阻塞队列。
THREAD_POOL_EXECUTOR ，执行任务的线程池，与线程池配套的是上面的阻塞队列。
SERIAL_EXECUTOR，任务排队的线程池
sDefaultExecutor，默认的线程池，默认为 SERIAL_EXECUTOR

sHandler，封装的 InternalHandler ，也就是 Hanlder .

private static final BlockingQueue<Runnable> sPoolWorkQueue =
        new LinkedBlockingQueue<Runnable>(128);
public static final Executor THREAD_POOL_EXECUTOR;

static {
    ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
            CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE_SECONDS, TimeUnit.SECONDS,
            sPoolWorkQueue, sThreadFactory);
    threadPoolExecutor.allowCoreThreadTimeOut(true);
    THREAD_POOL_EXECUTOR = threadPoolExecutor;
}

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

这里看一下 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);
           }
       }
   }

可以看到这里使用的 ArrayDeque ，这是一种先进先出的队列，所以在 AsyncTask 任务执行就是一个接一个的执行。在任务执行的线程池中不会产生并发执行的过程。

回到 execute 方法

@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，在里面就会先进行一个些判断，如果当前任务是 RUNNING 即运行状态或者 FINISHED 即终止状态就抛出异常，否则就将状态设置为 RUNNING 并开始执行 onPreExecute 方法，最一些任务执行前的操作，最后就将任务提交的 SerialExecutor 线程池。在 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);
            }
        }
    }

前面也说过提交的任务在这里会添加的 ArrayDeque 的 mTasks 队列中，然后再去 THREAD_POOL_EXECUTOR 中做真正的执行。保证了任务的执行是串行的过程。

在 THREAD_POOL_EXECUTOR 执行完成后 WorkerRunnable 的方法后最后就会调用 postResult

mWorker = new WorkerRunnable<Params, Result>() {
       ...
       result = doInBackground(mParams);
       ...
       postResult(result);

       };

跳转到 postResult


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

这里就使用 message 和 getHandler 发送消息，直接看 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;
        }
    }
}

可以看到最后调用的就是 result.mTask.finish(result.mData[0]); ，这个 result.mTask 就是一个封装了最后的结果和 AsyncTask 的对象，也就是将执行的结果传递给了finish 方法，而且也从工作线程回到了主线程。

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

在finish 就会调用 onPostExecute 方法执行最后的显示操作，并将状态设置为 FINISHED ，一旦设置为 FINISHED 就说明这个 AsyncTask 对象不能再执行任务。

对于任务的更新操作也是类是的过程，首先通过 getHandler 发送 Message.

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

最后就是在 Handler 里面进行处理调用 result.mTask.onProgressUpdate(result.mData); 方法。同样从工作线程回到了主线程，然后就是进度的更新方法 onProgressUpdate 。就这样 AsyncTask 的原理就介绍到此。