AsyncTask源码分析

Android 多线程

为了方便我们在子线程中更新UI，Android提供了AsyncTask，利用AsyncTask我们可以很方便的在子线程和主线程间进行切换，更新UI。为了更好的使用AsyncTask，理解AsyncTask的机制，需要对AsyncTask的源码进行分析。从构造方法开始分析：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
/**
    * Creates a new asynchronous task. This constructor must be invoked on the UI thread.
    */
   public AsyncTask() {
       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的实例mWorker 和一个FutureTask的实例mFuture，WorkerRunnable是一个实现了Callable接口的的AsyncTask的静态内部类，源码如下：

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

在mWorker中实现了call方法，在call方法中调用了AysncTask的doInBackground(mParams)方法，doInBackground(mParams)方法的执行结果通过postResult(result)从子线程传递出去。创建的mWorker被传递进了mFuture中。接下来看execute方法

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

execute方法中只是执行了executeOnExecutor(sDefaultExecutor,params)方法，具体的逻辑在executeOnExecutor(sDefaultExecutor, params)方法中。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 @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;
}

executeOnExecutor方法中调用了AysncTask的onPreExecute()方法，证明了onPreExecute()方法会第一个得到执行。接下来调用了Executor的execute()方法，并将前面初始化的mFuture对象传了进去，这个Executor对象是execute()方法传入的sDefaultExecutor变量，sDefaultExecutor变量定义的源码如下所示：

1
2
3
public static final Executor SERIAL_EXECUTOR = new SerialExecutor();

private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;

先创建了一个SERIAL_EXECUTOR常量，然后将sDefaultExecutor的值赋值为这个常量，刚才在executeOnExecutor()方法中调用的execute()方法，其实也就是调用的SerialExecutor类中的execute()方法。SerialExecutor是AsyncTask中一个实现了Executor接口的静态内部类，源码如下。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
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中有一个execute()方法，这个方法里中的所有逻辑都是在子线程中执行的，这个方法的Runnable参数就是mFuture对象，也就是说Runnable的run方法中调用的就是FutureTask类的run()方法，而在FutureTask类的run()方法里又会去调用callable的call()方法，FutureTask类的run()方法的源码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
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 {
                  result = c.call();
                  ran = true;
              } catch (Throwable ex) {
                  result = null;
                  ran = false;
                  setException(ex);
              }
              if (ran)
                  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);
      }
  }

run()方法里调用了callable的call()方法，这个callable就是在初始化mFuture对象时传入的mWorker对象，一开始在AsyncTask的构造函数中指定的mWorker对象的call方法在这里得到执行。从这里可以看出call方法是运行在子线程中，这说明doInBackGround是运行在子线程中，这也就是为什么我们可以在doInBackGround中进行耗时操作的原因。这里再贴一下call方法的源码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 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;
            }
};

doInBackground(mParams)方法的执行结果被传递给postResult(result)方法。postResult(Result result)的源码如下所示：

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

在postResult方法中将传递进去的doInBackground(mParams)的执行结果包装成了一个AsyncTaskResul，然后通过消息传递给了InternalHandler的handleMessage进行处理,InternalHandler是AsyncTask的一个静态内部类，AsyncTaskResul，getHandler() 和InternalHandler的源码如下。

1
2
3
4
5
6
7
8
9
10
@SuppressWarnings({"RawUseOfParameterizedType"})
    private static class AsyncTaskResult<Data> {
        final AsyncTask mTask;
        final Data[] mData;

        AsyncTaskResult(AsyncTask task, Data... data) {
            mTask = task;
            mData = data;
        }
}
1
2
3
4
5
6
7
8
private static Handler getHandler() {
       synchronized (AsyncTask.class) {
           if (sHandler == null) {
               sHandler = new InternalHandler();
           }
           return sHandler;
       }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
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的handleMessage中对消息的类型进行了判断，是一条MESSAGE_POST_RESULT消息，就会去执行finish()方法，如果是一条MESSAGE_POST_PROGRESS消息，就会去执行onProgressUpdate()方法。finish()方法的源码如下所示：

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

首先会通过isCancelled()方法来判断当前的任务是否被取消了，如果当前任务被取消掉了，就会调用onCancelled()方法，如果没有被取消，则调用onPostExecute()方法，这样当前任务的执行就全部结束了。在InternalHandler的handleMessage()方法里，还有一种MESSAGE_POST_PROGRESS的消息类型，这种消息是用于当前进度的，调用的正是onProgressUpdate()方法，当我们调用publishProgress()方法的时候，就会发出MESSAGE_POST_PROGRESS类型的信息，publishProgress()方法的源码，如下所示：

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

这也就是为什么当我们在doInBackground()方法中调用publishProgress()方法的时候可以从子线程切换到UI线程更新UI的原因。

参考资料：

Android AsyncTask完全解析，带你从源码的角度彻底理解

当前网速较慢或者你使用的浏览器不支持博客特定功能，请尝试刷新或换用Chrome、Firefox等现代浏览器