AsyncTask 源码解析 (Android Learning Note)

工作流程简述

AsyncTask 涉及的知识点有 Handler,Thread,Callable,FutureTask等。

大体流程图如下:


AsyncTask

简单介绍下:
AsyncTask 的构造器创建了一个 mFuture(FutureTask) 和 mWorker(WorkerRunnable),mFuture 重写了 done 方法,mWorker 实现了 call 方法,将 mWorker 传入 mFuture。
构建完 AsyncTask 对象,就可以执行 execute 方法,execute 方法中调用了 executeOnExecutor,并传入了默认的 sDefaultExecutor ,sDefaultExecutor 默认是模拟的单线程(下面会详细说怎么模拟的),AsyncTask 的任务只会一个一个执行。也可以传入自定义的线程,并发执行任务。在 executeOnExecutor 方法中,执行下载前的准备方法 onPreExecute(); 。然后 Executor 执行 mFuture(FutureTask),此时会调用 mFuture 的 run();run() 方法中会调用 mWorker 中的 call();,此时在子线程中会调用 doInBackground(),我们的耗时任务就是在这里实现的。耗时任务结束后,拿到返回值调用 postResult(),这里创建了一个 Message (what = MESSAGE_POST_RESULT)带上结果 result 发送给了处理消息的 InternalHandler 对象。sHandler 收到消息之后如果 what 是 MESSAGE_POST_RESULT,则判断任务是否被取消 isCancelled() 。如果取消了则调用 onCancelled(result) 没有取消则调用 onPostExecute(result)
doInBackground() 中,我们还可以调用 publishProcess() 方法,在主线程中刷新进度,方法中创建了一个 Message (what = MESSAGE_POST_PROGRESS)带上进度值 value,同样发送给 sHandler 处理,sHandler 处理消息,如果 what 是 MESSAGE_POST_PROGRESS 则调用 onProgressUpdate(Progress... values) 方法。
onPreExecute();onCancelled(result)onPostExecute(result)onProgressUpdate(Progress... values) 这些方法都是在主线程中执行,只有 doInBackground() 是子线程中执行。

AsyncTask 概念

AsyncTask ,(以下翻译自官方文档)能够正确,容易的使用 UI 线程。这个类允许你执行后台操作并将结果呈现在 UI 线程上,不用你去操作 threads 和 handlers。

AsyncTask 被设计为一个 Thread 和 Handler 的辅助类,并不是构建线程的框架。理想情况下,AsyncTask 被用于短时间操作(大部分是几秒钟的),如果你需要保持线程长时间运行,非常推荐你使用 java.util.concurrent 包的一些 APIs,如 Executor,ThreadPoolExecutor 和 FutureTask。

异步任务由在后台线程运行,在 UI 线程呈现结果的计算定义。异步任务由三个普通类型,Params,Progress,Result 和四个步骤,分别是 onPreExecute, doInBackground, onProgressUpdate and onPostExecute 来定义。

代码示例:

 private class DownloadFilesTask extends AsyncTask<URL, Integer, Long> {
 
     @Override
     protected void onPreExecute() {
        //准备工作,在主线程。
     }
 
     protected Long doInBackground(URL... urls) {
         //耗时操作,在子线程。
         int count = urls.length;
         long totalSize = 0;
         for (int i = 0; i < count; i++) {
             totalSize += Downloader.downloadFile(urls[i]);
             publishProgress((int) ((i / (float) count) * 100));
             // Escape early if cancel() is called
             if (isCancelled()) break;
         }
         return totalSize;
     }

     @Override
     protected void onProgressUpdate(Integer... progress) {
         //显示进度,在主线程
         setProgressPercent(progress[0]);
     }
     
     @Override
     protected void onCancelled(Float result) {
         //任务被取消会调用这个方法,不会调用 onPostExecute ,在主线程。
         showDialog("Cancelled " + result + " bytes");
     }

     @Override
     protected void onPostExecute(Long result) {
         //任务完成,没有被取消,调用这个方法,在主线程。
         showDialog("Downloaded " + result + " bytes");
     }
 }
 
 //使用
 new DownloadFilesTask().execute(url1, url2, url3);

接下来结合这段代码示例,前面的工作流程图和源代码,看下 AsyncTask 如何在 UI 线程和子线程之间切换,如何使用三个范型,四个步骤如何调用。
先看 AsyncTask 的构造方法:

public AsyncTask() {
    mWorker = new WorkerRunnable<Params, Result>() {
        public Result call() throws Exception {
            mTaskInvoked.set(true);

            Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
            //noinspection unchecked
            Result result = doInBackground(mParams);
            Binder.flushPendingCommands();
            return postResult(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);
            }
        }
    };
}

构造方法中创建了一个 mWorker(WorkerRunnable),它实现的是 Callable 接口,和 Runnable 接口的区别是,实现方法有返回值 V call() throws Exception;,call() 方法的代码后面会做说明。
同时还创建了一个 mFuture(FutureTask),并将 mWorker 做为参数传入。mFuture 重写了 done() 方法,这里也是后面调用到再做说明。

AsyncTask 创建出来后,需要调用 public final AsyncTask<Params, Progress, Result> execute(Params... params) 方法来这执行这个任务。
这个方法里调用的是 executeOnExecutor(sDefaultExecutor, params);,传入的是 sDefaultExecutor 和 params 对应的参数。我们先看 sDefaultExecutor 到底是什么?

private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;

public static final Executor SERIAL_EXECUTOR = new 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);
        }
    }
}

sDefaultExecutor 的值是一个内部类 SerialExecutor 的对象 SERIAL_EXECUTOR,这个类实现 Executor 接口。为什么说它是模拟的单线程呢?一开始我以为它是一个单线程的线程池,看了代码之后发现并不是,任务是 THREAD_POOL_EXECUTOR 这个自定义线程池执行的。任务维护在 ArrayDeque 这个队列中,SERIAL_EXECUTOR 执行 execute 方法就会创建一个任务放入这个队列。当 mActive == null 的时候,说明之前队列中还没有任务,然后执行 scheduleNext(); ,从队列中取出任务赋值给 mActive,并由 THREAD_POOL_EXECUTOR 来执行任务,这时会执行任务的 run() 方法,而 run() 方法中又会执行传进来的那个任务 final Runnable r,执行完后,同样调用 scheduleNext(); 再去取下一个任务,如此循环,直到队列中没有任务为止。
THREAD_POOL_EXECUTOR 这个自定义线程的创建过程看如下代码:

private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
private static final int CORE_POOL_SIZE = CPU_COUNT + 1;
private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;
private static final int KEEP_ALIVE = 1;
private static final BlockingQueue<Runnable> sPoolWorkQueue =
        new LinkedBlockingQueue<Runnable>(128); 
public static final Executor THREAD_POOL_EXECUTOR
= new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,
        TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);

介绍完 sDefaultExecutor 后,回到主线,看方法 public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec, Params... 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;
}

方法中,先是校验任务状态,如果是 RUNNING 已运行或是 FINISHED 已完成都会抛出异常。然后,修改任务状态为 RUNNING。之后再执行 onPreExecute(); 方法,此时重要的四个步骤的第一步就被执行了。之后将传入的参数 params 交给 mWorker,执行 mFuture。
此时,和我们之前介绍的 sDefaultExecutor 执行过程 和 AsyncTask 的构造方法就要联系起来了。调用 exec.execute(mFuture); 方法将 mFuture 包装成任务放入队列(前面说过的),随后被执行 mFuture.run()。因为 FutureTask 实现了 Runnable 接口,所以会有对应的 run() 方法。

我们找到 FutureTask 类来看下它的 run() 方法是如何实现的。

public class FutureTask<V> implements RunnableFuture<V> {
...
    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);
        }
    }
    
    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
    }
...
}

代码中的 callable 就是前面构造器中传入 mFuture 的 mWorker。Callable<V> c = callable; result = c.call(); 可以看到 mWorker 被调用了,随后又调用 set(result);,将结果赋值给
outcome,调用 finishCompletion(),最后调用 done()。done 方法中主要是调用 postResultIfNotInvoked(get()); 来校验(mTaskInvoked标识位)如果任务没有执行,也保证执行postResult(result); 方法,把结果返回给主线程。

private void postResultIfNotInvoked(Result result) {
    final boolean wasTaskInvoked = mTaskInvoked.get();
    if (!wasTaskInvoked) {
        postResult(result);
    }
}

此时 mWorker 的 call() 和 mFuture 的 done() 方法都被调用了。

我们在翻回去看 mWorker 的 call() 方法。

mWorker = new WorkerRunnable<Params, Result>() {
    public Result call() throws Exception {
        mTaskInvoked.set(true);

        Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
        //noinspection unchecked
        Result result = doInBackground(mParams);
        Binder.flushPendingCommands();
        return postResult(result);
    }
};

首先设置任务被调用的标识为 true,设置线程优先级了 THREAD_PRIORITY_BACKGROUND,再调用方法 doInBackground(mParams),这是四个步骤的第二步方法被调用,耗时任务开始执行。获取到返回的结果后,调用 postResult(result); 方法。
Binder.flushPendingCommands(); 作用并不清楚。我们先看 postResult。

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

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

创建一个 Message,what 是 MESSAGE_POST_RESULT,用返回值创建一个 AsyncTaskResult 对象做为message 的 obj,并发送出去,交给 sHandler 来处理,我们看 Handler 处理消息的代码。

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

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

handleMessage 方法中处理收到的消息,如果消息是 MESSAGE_POST_RESULT,调用 finish 方法。 finish 方法中根据任务是否被取消,来执行不同的方法,如果取消则执行 onCancelled(result);,没有取消执行 onPostExecute(result);,此时 AsyncTask 的第四步骤就走完了。整个任务执行完毕。可以看到 onCancelled 和 onPostExecute 只会执行一个。
如果是 MESSAGE_POST_PROGRESS 的消息,则执行 onProgressUpdate(result.mData) 方法,这个是第三个步骤,这个消息是怎么来的呢?

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

原来我们可以在工作线程中调用这个方法,也就是在 doInBackground 中使用。如果任务没有取消,就会创建一个 what 是 MESSAGE_POST_PROGRESS,将进度值封装成一个 AsyncTaskResult 对象做为 obj 的 Message 给 Handler 处理。

最后看下,任务是怎么被取消的,调用如下方法:

public final boolean cancel(boolean mayInterruptIfRunning) {
    mCancelled.set(true);
    return mFuture.cancel(mayInterruptIfRunning);
}

修改是否取消的标识位,调用 mFuture 的 cancel 方法。mFuture 的 cancel 方法中,如果有当前任务的线程则会调用这个线程的 interrupt 的方法并也会调用 finishCompletion();,判断任务是否调用,发送 postResult。

总结

AsyncTask 不仅能帮我们简单的完成异步任务的操作,还就如何更好更准确的使用 Handler 和 Thread 做出了示范,从其中能学到很多有用的知识。

推荐阅读更多精彩内容