[关闭]
@linux1s1s 2017-01-22T08:57:07.000000Z 字数 9479 阅读 1185

Android AsyncTask 封装初步一

AndroidMechanism 2016-05


AsyncTask基本使用

先从最熟悉的Task使用开始说起,给出LastDaysTask作为实例如下

  1. @SuppressLint("NewApi")
  2. private class LastDaysTask extends AsyncTask<Void, Integer, Boolean>{
  3. @Override
  4. protected void onPreExecute()
  5. {
  6. //TODO UI线程或者主线程
  7. }
  8. @Override
  9. protected Boolean doInBackground(Void... params)
  10. {
  11. //TODO 工作线程或者子线程
  12. return true;
  13. }
  14. @Override
  15. protected void onProgressUpdate(Integer... values)
  16. {
  17. //TODO UI线程或者主线程
  18. }
  19. @Override
  20. protected void onPostExecute(Boolean aBoolean)
  21. {
  22. //TODO UI线程或者主线程
  23. }
  24. }

这里我们把AsyncTask的第一个泛型参数指定为Void,表示在执行AsyncTask的时候不需要传入参数给后台任务。第二个泛型参数指定为Integer,表示使用整型数据来作为进度显示单位。第三个泛型参数指定为Boolean,则表示使用布尔型数据来反馈执行结果。

接下来需要重写其中的四个方法,分别是:

对上面这四个方法简短说明如下:

  1. onPreExecute()
    这个方法会在后台任务开始执行之间调用,用于进行一些界面上的初始化操作,比如显示一个进度条对话框等。
  2. onProgressUpdate(Progress...)
    当在后台任务中调用了publishProgress(Progress...)方法后,这个方法就很快会被调用,方法中携带的参数就是在后台任务中传递过来的。在这个方法中可以对UI进行操作,利用参数中的数值就可以对界面元素进行相应的更新。
  3. doInBackground(Params...)
    这个方法中的所有代码都会在子线程中运行,我们应该在这里去处理所有的耗时任务。任务一旦完成就可以通过return语句来将任务的执行结果进行返回,如果AsyncTask的第三个泛型参数指定的是Void,就可以不返回任务执行结果。注意,在这个方法中是不可以进行UI操作的,如果需要更新UI元素,比如说反馈当前任务的执行进度,可以调用publishProgress(Progress...)方法来完成。
  4. onPostExecute(Result)
    当后台任务执行完毕并通过return语句进行返回时,这个方法就很快会被调用。返回的数据会作为参数传递到此方法中,可以利用返回的数据来进行一些UI操作,比如说提醒任务执行的结果,以及关闭掉进度条对话框等。

使用异步任务获取数据

  1. @Override
  2. public void onCreate()
  3. {
  4. super.onCreate();
  5. LastDaysTask task = new LastDaysTask();
  6. task.execute();
  7. }

这样就简单的完成了子线程和UI线程之间的通信。

AsyncTask主要源码

看完上面如何使用异步任务获取远程数据,我们以task.execute();作为切入点,深入源码看看究竟。

AsyncTask.execute()方法

  1. public final AsyncTask<Params, Progress, Result> execute(Params... params) {
  2. return executeOnExecutor(sDefaultExecutor, params);
  3. }
  1. public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,
  2. Params... params) {
  3. if (mStatus != Status.PENDING) {
  4. /*
  5. 如果同一个task被启动两次,就会抛出下面两种异常,所以如果task作为成员变量的时候,一定要判断当前task是否已经在运行,否则不可以重复execute.除非先把该task取消以后才可以继续execute.
  6. */
  7. switch (mStatus) {
  8. case RUNNING:
  9. throw new IllegalStateException("Cannot execute task:"
  10. + " the task is already running.");
  11. case FINISHED:
  12. throw new IllegalStateException("Cannot execute task:"
  13. + " the task has already been executed "
  14. + "(a task can be executed only once)");
  15. }
  16. }
  17. mStatus = Status.RUNNING;
  18. /*
  19. 该方法在UI线程,获取远程数据之前,UI需要更新状态可以重写该方法
  20. */
  21. onPreExecute();
  22. /*
  23. 这里有两个成员变量mWorker和mFuture很重要,这两个变量都是final型,在构造器中初始化,另外还有一个sDefaultExecutor多线程执行器,然后返回结果当前实例this。
  24. */
  25. mWorker.mParams = params;
  26. exec.execute(mFuture);
  27. return this;
  28. }

成员变量mWorker和mFuture

  1. public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
  2. private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
  3. private final WorkerRunnable<Params, Result> mWorker;
  4. private final FutureTask<Result> mFuture;
  5. /*
  6. - 构造器,初始化两个重要的成员变量mWorker和mFuture,在mWorker中我们看到了熟悉的doInBackground()方法,很明显这个是放在子线程中执行的,另外WorkerRunnable这个类简单的实现了Callable接口,新增成员变量Params数组。
  7. */
  8. public AsyncTask() {
  9. mWorker = new WorkerRunnable<Params, Result>() {
  10. public Result call() throws Exception {
  11. mTaskInvoked.set(true);
  12. Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
  13. //noinspection unchecked
  14. return postResult(doInBackground(mParams));
  15. }
  16. };
  17. mFuture = new FutureTask<Result>(mWorker) {
  18. @Override
  19. protected void done() {
  20. try {
  21. postResultIfNotInvoked(get());
  22. } catch (InterruptedException e) {
  23. android.util.Log.w(LOG_TAG, e);
  24. } catch (ExecutionException e) {
  25. throw new RuntimeException("An error occured while executing doInBackground()",
  26. e.getCause());
  27. } catch (CancellationException e) {
  28. postResultIfNotInvoked(null);
  29. }
  30. }
  31. };
  32. }
  33. private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {
  34. Params[] mParams;
  35. }

sDefaultExecutor默认分发器

  1. /*
  2. - 默认分发器,SerialExecutor根据名称大概可以猜到这是个串行分发器,然后前面使用异步任务的时候调用了execute()方法,我们一路跟踪到这里,最后进入到上面代码L29 exec.execute(mFuture), 而这个exec就是这个串行分发器,然后进入串行分发器的execute(final Runnable r)方法中.mTasks是个循环队列,offer加入队列尾,poll拿出队列头,刚开始进入execute()方法,将mFuture加入循环队列中,然后判断mActive(就是加入进来的mFuture)是否为空,第一次进来当然为空,所以执行 scheduleNext()方法,取出刚加入的mFuture放入线程池中去执行,接下来看线程池的定义
  3. */
  4. private static class SerialExecutor implements Executor {
  5. final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
  6. Runnable mActive;
  7. public synchronized void execute(final Runnable r) {
  8. mTasks.offer(new Runnable() {
  9. public void run() {
  10. try {
  11. r.run();
  12. } finally {
  13. scheduleNext();
  14. }
  15. }
  16. });
  17. if (mActive == null) {
  18. scheduleNext();
  19. }
  20. }
  21. /*
  22. 进入线程池execute方法以后执行Runnable中的run方法,即上面L10处,然后执行出入参数为Runnable的run方法,最后在finally块中执行下面一个队列中的Runnable的run方法,依次取出队列。我们看到无论队列中前面一个Runnable执行的如何都会去取下面一个Runnable实例去执行,所以不用担心诸如异常导致的阻塞行为。
  23. */
  24. protected synchronized void scheduleNext() {
  25. if ((mActive = mTasks.poll()) != null) {
  26. THREAD_POOL_EXECUTOR.execute(mActive);
  27. }
  28. }
  29. }

THREAD_POOL_EXECUTOR线程池

  1. private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
  2. private static final int CORE_POOL_SIZE = CPU_COUNT + 1;
  3. private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;
  4. private static final int KEEP_ALIVE = 1;
  5. /*
  6. 线程工厂生产出来的线程做了名称标记,所以我们看Log经常会看到"AsyncTask #" + mCount.getAndIncrement()比如“AsyncTask #1”等等字样。而线程池的核心线程数和最大线程数都是通过Runtime动态获取和指定的。
  7. */
  8. private static final ThreadFactory sThreadFactory = new ThreadFactory() {
  9. private final AtomicInteger mCount = new AtomicInteger(1);
  10. public Thread newThread(Runnable r) {
  11. return new Thread(r, "AsyncTask #" + mCount.getAndIncrement());
  12. }
  13. };
  14. /**
  15. * An {@link Executor} that can be used to execute tasks in parallel.
  16. */
  17. public static final Executor THREAD_POOL_EXECUTOR
  18. = new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,
  19. TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);

经过上面的源码分析,我们小结一下:
AsyncTask中有个默认串行分发器,它负责将Runnable实例加入循环队列中,然后逐一取出交由线程池去执行,根据Runtime决定线程池的大小和规格,最小核心线程数是2,线程名都是以"AsyncTask #"开头,所以当我们在一个生命周期中提交多个异步任务,一般是逐步加入线程池中去执行,这种实现就像是模拟单一的线程池一样,如果我们快速地启动了很多任务,同一时刻只会有一个线程正在执行,其余的均处于等待状态。我们知道对于这个默认的串行分发器,在Android3.0之前是没有的,那么为什么加入这个默认的串行分发器呢?原因就是AsyncTask在Android3.0以后提供了更大的灵活性,这里仅仅是提供了默认的串行分发器,如果你感觉太过保守,你可以不使用这个默认的串行分发器,而是直接这样。

  1. Executor exec = new ThreadPoolExecutor(15, 200, 10,
  2. TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>());
  3. new LastDaysTask().executeOnExecutor(exec);

这样就可以使用我们自定义的一个Executor来执行任务,而不是使用SerialExecutor。上述代码的效果允许在同一时刻有15个任务正在执行,并且最多能够存储200个任务。

PS:
小结一下AsyncTask的任务是并行还是串行执行?

  • 在Android 1.5刚引入的时候,AsyncTask的execute是串行执行的;
  • 到了Android 1.6直到Android 2.3.2,又被修改为并行执行了,这个执行任务的线程池就是THREAD_POOL_EXECUTOR,因此在一个进程内,所有的AsyncTask都是并行执行的;
  • 但是在Android 3.0以后,如果你使用execute函数直接执行AsyncTask,那么这些任务是串行执行的;

AsyncTask其他源码剖析

前面我们分析了大概脉络,这里我们进一步分析子线程和UI线程的通信部分。

提交给线程池执行execute()方法,在sDefaultExecutor默认分发器中的L12行,参数Runnable中的r传参是mFuture实例,所以直接进入FutureTask的run()方法中.

  1. public void run() {
  2. if (state != NEW ||
  3. !UNSAFE.compareAndSwapObject(this, runnerOffset,
  4. null, Thread.currentThread()))
  5. return;
  6. try {
  7. Callable<V> c = callable;
  8. if (c != null && state == NEW) {
  9. V result;
  10. boolean ran;
  11. try {
  12. result = c.call();
  13. ran = true;
  14. } catch (Throwable ex) {
  15. result = null;
  16. ran = false;
  17. setException(ex);
  18. }
  19. if (ran)
  20. set(result);
  21. }
  22. } finally {
  23. // runner must be non-null until state is settled to
  24. // prevent concurrent calls to run()
  25. runner = null;
  26. // state must be re-read after nulling runner to prevent
  27. // leaked interrupts
  28. int s = state;
  29. if (s >= INTERRUPTING)
  30. handlePossibleCancellationInterrupt(s);
  31. }
  32. }

重点看上面的L12行,调用Callable的call()方法,而这个Callable就是我们构造器中的mWoker,所以还是回到AsyncTask构造器。

  1. public AsyncTask() {
  2. /*
  3. 进入call()方法中,设置task是否被唤起,线程优先级以及我们熟悉的doInBackground方法,并将结果postResult到UI线程中,接着继续跟postResult方法。
  4. */
  5. mWorker = new WorkerRunnable<Params, Result>() {
  6. public Result call() throws Exception {
  7. mTaskInvoked.set(true);
  8. Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
  9. //noinspection unchecked
  10. return postResult(doInBackground(mParams));
  11. }
  12. };
  13. }

postResult()方法,该方法完成线程间通信。

  1. private static final int MESSAGE_POST_RESULT = 0x1;
  2. private static final int MESSAGE_POST_PROGRESS = 0x2;
  3. private Result postResult(Result result) {
  4. @SuppressWarnings("unchecked")
  5. /*
  6. 这里看到了熟悉的Message,获取message以后将消息一并发出去,接受者key就是MESSAGE_POST_RESULT,所以我们跟踪这个key,看看处理这如何处理。
  7. */
  8. Message message = sHandler.obtainMessage(MESSAGE_POST_RESULT,
  9. new AsyncTaskResult<Result>(this, result));
  10. message.sendToTarget();
  11. return result;
  12. }

MESSAGE_POST_RESULT

  1. private static class InternalHandler extends Handler {
  2. @SuppressWarnings({"unchecked", "RawUseOfParameterizedType"})
  3. @Override
  4. public void handleMessage(Message msg) {
  5. AsyncTaskResult result = (AsyncTaskResult) msg.obj;
  6. switch (msg.what) {
  7. case MESSAGE_POST_RESULT:
  8. // There is only one result
  9. result.mTask.finish(result.mData[0]);
  10. break;
  11. case MESSAGE_POST_PROGRESS:
  12. result.mTask.onProgressUpdate(result.mData);
  13. break;
  14. }
  15. }
  16. }

L9 调用finish()方法

  1. private void finish(Result result) {
  2. if (isCancelled()) {
  3. onCancelled(result);
  4. } else {
  5. onPostExecute(result);
  6. }
  7. mStatus = Status.FINISHED;
  8. }

上面的finish方法根据Task的状态调用不同的状态方法,然后置位状态。这里看到了熟悉的onPostExecute()方法又一次回到了UI线程。我们注意到,在刚才InternalHandler的handleMessage()方法里,还有一种MESSAGE_POST_PROGRESS的消息类型,这种消息是用于当前进度的,调用的正是onProgressUpdate()方法,那么什么时候才会发出这样一条消息呢?相信你已经猜到了,查看publishProgress()方法的源码,如下所示:

  1. protected final void publishProgress(Progress... values) {
  2. if (!isCancelled()) {
  3. sHandler.obtainMessage(MESSAGE_POST_PROGRESS,
  4. new AsyncTaskResult<Progress>(this, values)).sendToTarget();
  5. }
  6. }

最后我们还有一个构造器中的mFuture还没有分析,因为只有一个done方法,所以有必要一起来看一下FutureTask中的done方法

  1. /**
  2. * Protected method invoked when this task transitions to state
  3. * {@code isDone} (whether normally or via cancellation). The
  4. * default implementation does nothing. Subclasses may override
  5. * this method to invoke completion callbacks or perform
  6. * bookkeeping. Note that you can query status inside the
  7. * implementation of this method to determine whether this task
  8. * has been cancelled.
  9. */
  10. protected void done() { }

看注释应该清楚,这里需要子类去重写,需要判断状态做出相应的处理即可,解析来看看AsyncTask构造器中的done方法

  1. mFuture = new FutureTask<Result>(mWorker) {
  2. @Override
  3. protected void done() {
  4. try {
  5. postResultIfNotInvoked(get());
  6. } catch (InterruptedException e) {
  7. android.util.Log.w(LOG_TAG, e);
  8. } catch (ExecutionException e) {
  9. throw new RuntimeException("An error occured while executing doInBackground()",
  10. e.getCause());
  11. } catch (CancellationException e) {
  12. postResultIfNotInvoked(null);
  13. }
  14. }
  15. };

主要的方法是postResultIfNotInvoked(get())然后把结果传过去

  1. private void postResultIfNotInvoked(Result result) {
  2. final boolean wasTaskInvoked = mTaskInvoked.get();
  3. if (!wasTaskInvoked) {
  4. postResult(result);
  5. }
  6. }

如果task没有被唤起的话,或者说没有执行call()方法的话,wasTaskInvoked标志位为false,还是通过postResult方法将数据传给UI线程,到此分析结束。

添加新批注
在作者公开此批注前,只有你和作者可见。
回复批注