- 通过
new DownloadAsyncTask().execute()在主线程调用的时候源码如下：private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
public final AsyncTask<Params, Progress, Result> execute(Params... params) {
return executeOnExecutor(sDefaultExecutor, params);
}
- 这里先看一下
sDefaultExecutor, 它是一个自定义线程池，我们看下它的实现：public static final Executor THREAD_POOL_EXECUTOR;
static {
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE_SECONDS, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>(), sThreadFactory);
threadPoolExecutor.setRejectedExecutionHandler(sRunOnSerialPolicy);
THREAD_POOL_EXECUTOR = threadPoolExecutor;
}
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中使用ArrayDeque队列的形式对需要执行的任务进行了入队操作, 来看源码，当执行execute方法的时候，首先往队列中offer一个要真正执行的Runnable，然后判断mActive == null, 因为这里是第一次执行，所以会执行scheduleNext(),scheduleNext()的逻辑也比较简单，就是从队列中poll取出一个任务，因为前面已经offer一个任务了，所以这里就可以执行刚才offer的任务了，但是真正执行任务的是THREAD_POOL_EXECUTOR, 它是一个自定义的ThreadPoolExecutor, 是真正意义上的线程池，通过上面的源码可以看出来；- 这时候如果在执行第一个耗时任务的时候，又进来一个任务，这时候的处理逻辑是什么样的呢？这时候还会判断
mActive == null是否成立，很显然刚才已经把第一个任务赋值给mActive了，所以这时候并不会真正的执行后来的任务，而是先入队列，等到第一个耗时任务执行完毕之后，会执行finally中的scheduleNext()方法，这时候就会从队列中poll得到下一个任务来执行了，从上面的分析就能看出来，AsyncTask的执行是串行的，并不是真正意义上的多线程，这是为了防止出现并发问题，但是内部维护了一个线程池，对于线程开销有了很大的性能提升。 其实在Android1.6之前AsyncTask是串行执行的，在1.6之后内部使用了线程池来并行处理任务，但是从3.0开始又使用了线程池串行执行任务。尽管如此，但是如果我们使用executeOnExecutor(Executor exec, Params... params)的话就可以自己执行线程池，从而达到真正意义上的并发。- 接着上面的
execute调用的executeOnExecutor, 我们继续看executeOnExecutor源码：
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;
}
mStatus用来记录当前的状态，他有三种状态，默认是PENDING状态，当调用execute方法的时候，正常情况下会改变状态为RUNNING状态，当执行完onPostExecute后，会将状态赋值为FINISHED。但是这里要注意，如果我们连续两次通过mAsyncTask.execute调用一个耗时任务，这里会出现Cannot execute task: the task is already running.异常，从上面的源码部分可以看出问题，因为这时候当前任务已经处于RUNNING状态了，不能重复执行，想多次调用的话使用两次new DownloadAsyncTask().execute()就没问题了，这里注意一下。- 接着就会调用
onPreExecute方法，然后把传进来的参数赋值给前面的mWorker.mParams, 便于在后面doInBackground(mParams)中使用。接着就调用了exec.execute(mFuture)开始执行任务了。执行的其实就是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 {
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);
}
}
- 内部调用了
c.call返回了result，这里的c就是上面的WorkerRunnable, 也就是在构造方法中初始化的mWorker, 然后调用set(result)方法，我们看一下源码：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
}
- 上面
set(result)方法回调用finishComplete方法，最终调用了done, done是一个空的实现，需要我们自己实现，在AsyncTask中的FutureTask中我们已经实现了这个done方法，下面我们再回过头看一下最开始构造方法中初始化的call方法以及done方法。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);
}
}
};
private void postResultIfNotInvoked(Result result) {
final boolean wasTaskInvoked = mTaskInvoked.get();
if (!wasTaskInvoked) {
postResult(result);
}
}
- 上面的分析中先执行了
call方法, call中先设置了mTaskInvoked.set(true), call之后调用了done，done中调用了然后调用了postResultIfNotInvoked, 源码上面可以看到，首先会判断mTaskInvoked.get(), 如果为false就会调用postResult(result);, 但是实际上在上面call已经赋值为true了，所以这里一般不会执行postResultIfNotInvoked。其实这两个方法主要目的就是为了执行postResult, 那么我们接着上面的call分析。call中调用doInbackground方法，传入了刚才的mParams，而doInbackground就是我们必须要实现的方法，这里返回了result。 在finally中调用了postResult。接着调用了源码如下：private Result postResult(Result result) {
@SuppressWarnings("unchecked")
Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
new AsyncTaskResult<Result>(this, result));
message.sendToTarget();
return result;
}
- 这里
getHandler就是上面的InternalHandler, 它内部的Looper是主线程的Looper, 通过Handler机制，就实现了线程的切换，我们看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;
}
}
}
- 我们看到上面
MESSAGE_POST_RESULT对应的是第一个，所以就会执行result.mTask.finish(result.mData[0]), 而mTask就是AsyncTask自身，所以我们看finish即可。我们看下finish方法源码：private void finish(Result result) {
if (isCancelled()) {
onCancelled(result);
} else {
onPostExecute(result);
}
mStatus = Status.FINISHED;
}
- 如果我们没有主动调用
cancel方法就会进入onPostExecute方法，这里也是在主线程执行的，这个方法是需要我们自己处理的，然后把mStatus = Status.FINISHED, 标志着一个完整的调用结束了。 - 如果我们在
doInBackground中调用了publishProgress方法，内部的逻辑是什么样的呢？因为doInbackground是在子线程中执行的，publishProgress的逻辑和postResult逻辑一样, 它发送一个MESSAGE_POST_PROGRESS，通过Handler机制将线程切换到InternalHandler的主线程中，然后会调用result.mTask.onProgressUpdate(result.mData);也就是调用我们重写的onProgressUpdate方法，这里就不贴源码了，小伙伴们可以自己查看源码，比较简单。
- 如果在执行的过程中，我们想取消任务的执行怎么办？我们可以调用
mAsyncTask.cancel来处理，我们看看源码部分：public final boolean cancel(boolean mayInterruptIfRunning) {
mCancelled.set(true);
return mFuture.cancel(mayInterruptIfRunning);
}
- 首先调用
mCancelled.set(true)，这个值后面会用到。然后调用mFuture.cancel(mayInterruptIfRunning), 内部代码如下：public boolean cancel(boolean mayInterruptIfRunning) {
if (!(state == NEW &&
U.compareAndSwapInt(this, STATE, NEW,
mayInterruptIfRunning ? INTERRUPTING : CANCELLED)))
return false;
try { // in case call to interrupt throws exception
if (mayInterruptIfRunning) {
try {
Thread t = runner;
if (t != null)
t.interrupt();
} finally { // final state
U.putOrderedInt(this, STATE, INTERRUPTED);
}
}
} finally {
finishCompletion();
}
return true;
}
- 最后
finally中执行了finishCompletion()方法，接着会调用done，done中会执行postResultIfNotInvoked, 源码如下：private void postResultIfNotInvoked(Result result) {
final boolean wasTaskInvoked = mTaskInvoked.get();
if (!wasTaskInvoked) {
postResult(result);
}
}
- 会不会执行这里的
postResult取决于mTaskInvoked的值，如果任务正在执行中，那么这里的mTaskInvoked就为true, 会执行call中finally的postResult；如果还没来得及执行，就会执行这里的postResult。所以不管怎么样，最终的结果也是会执行postResult，上面关于postResult的流程我们详细分析过了，这里我们看下最终会执行到的finish方法：private void finish(Result result) {
if (isCancelled()) {
onCancelled(result);
} else {
onPostExecute(result);
}
mStatus = Status.FINISHED;
}
- 由上可以看出，因为我们调用
cancel,所以这里的isCancel为true, 就不会执行onPostExecute。这样就实现了取消任务的功能，但是这里要主要一下，如果任务一旦开始执行，调用cancel方法，doInbackground是会执行结束的，但是不会将结果刷新到UI线程而已。包括在doInBackground中调用publishProgress也一样，它的源码如下：protected final void publishProgress(Progress... values) {
if (!isCancelled()) {
getHandler().obtainMessage(MESSAGE_POST_PROGRESS,
new AsyncTaskResult<Progress>(this, values)).sendToTarget();
}
}
publishProgress也是会先检查标志isCancelled是否已经取消了，如果取消 了就不会将值刷新到UI线程。这一点要理解一下，并不是调用cancel之后，doInbackground也停止工作了。感兴趣的小伙伴可以自己打印看下，这里就不贴代码了。
扫一扫
1914
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
