简介:AsyncTask是Android中用于异步操作的类。尽管现在已经逐渐被强调舍弃,不过就源码来说,AsyncTask还是一个挺不错的设计。鉴于上一篇文章非墨研究过线程池<a href="http://www.jianshu.com/p/10da5cc92caa"> 线程池源码分析</a>,正好以AsyncTask作为第二篇线程池相关的研究对象。
废话不多说,我们先来看下,我们再代码中如何使用一个AsyncTask:
// demo1
new AsyncTask<String, Integer, String>() {
protected void onProgressUpdate(Integer[] values) {
//TODO process update in UI Thread
};
protected void onPostExecute(String result) {
//TODO on Execute finish
};
@Override
protected String doInBackground(String... params) {
int i = 0;
while (i <= 100) {
//todo something
this.publishProgress(i);// notify progress change
i ++;
}
return "result";
}
}.execute("params1","params2");
demo1是比较常见的做法,生成了一个AsyncTask对象,然后通过执行execute方法。我们可以从demo1得到下面的结论:
1.execute方法里面需要传入不定个数的参数,参数的类型由AsyncTask的第二个泛型参数指定。如果你想指定多种类型的参数,可以将你的类型做顶层抽象,或者是将多种参数封装到一个新的类型里面,然后从这个类里面取。
2.在AsyncTask里面,一般以“on”打头的方法都是在UI线程中执行(其实并不准确,实际上如果你的线程中存有Looper都可以使用)。
其实不管是在Android或者java,跟线程池或者线程相关的执行动作,常常都被命名成为execute。我们姑且有个印象,AsyncTask里面或许用到了线程池。我们来看下AsyncTask的具体源码：
//code2
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 ThreadFactory sThreadFactory = new ThreadFactory() {
private final AtomicInteger mCount = new AtomicInteger(1);
public Thread newThread(Runnable r) {
return new Thread(r, "AsyncTask #" + mCount.getAndIncrement());
}
};
private static final BlockingQueue<Runnable> sPoolWorkQueue =
new LinkedBlockingQueue<Runnable>(128);
/**
* An {@link Executor} that can be used to execute tasks in parallel.
*/
public static final Executor THREAD_POOL_EXECUTOR
= new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,
TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);
正如code2代码所示,我们上面方法名的假设并没有错,AsyncTask用了线程池,并且核心线程数量按照cpu的数量+1给出,最大线程数量按照2倍的cpu数量+1给出。至于为什么按照这个给值,非墨不得而知,这种数值或许是最优解,但是为什么是最优解呢?如果非墨得到了答案,非墨会在后续的文章中说明。在这里,线程池被定义为常量,我们可以断言,所有的AsyncTask都是共享线程池的。
//code3
public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
//线性执行队列
private static final int MESSAGE_POST_RESULT = 0x1;//post结果消息
private static final int MESSAGE_POST_PROGRESS = 0x2;//进度消息
private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
private final WorkerRunnable<Params, Result> mWorker;//执行对象
private final FutureTask<Result> mFuture;//worker的一个装饰对象,用于线程池操作
private volatile Status mStatus = Status.PENDING;
private final AtomicBoolean mCancelled = new AtomicBoolean();
private final AtomicBoolean mTaskInvoked = new AtomicBoolean();
code3代码里,定义了一个线性的执行队列,还有返回消息函数,已经一个工作对象worker,以及其包装对象Future。用Status枚举类型来记录AsyncTask的状态。用两个原子变量mCancelled和mTaskInvoked来标记拦截一些操作。
//code3
public AsyncTask() {
mWorker = new WorkerRunnable<Params, Result>() {
public Result call() throws Exception {
mTaskInvoked.set(true);
//noinspection unchecked
return postResult(doInBackground(mParams));
}
};
mFuture = new FutureTask<Result>(mWorker) {
@Override
protected void done() {
try {
postResultIfNotInvoked(get());
} catch (InterruptedException e) {
} catch (ExecutionException e) {
throw new RuntimeException("An error occured while executing doInBackground()",
e.getCause());
} catch (CancellationException e) {
postResultIfNotInvoked(null);
}
}
};
}
在AsyncTask的构造器里,生成了他的工作Worker对象和和Future对象。mWorker是一个WorkerRunnable类,它实现了java.util.concurrent.Callable接口。这点在非墨上篇的线程池分析中并没有提及,但是万变不离其总,Callable接口对象最终一样会包装成为一个Runnable对象。而这种包装的方式,需要一个叫做FutureTask的类来完成。这就是我们的mFuture对象。我们不妨回到我们的线程池相关代码:
// code AbstractExecutorService.java
public <T> Future<T> submit(Callable<T> task) {
if (task == null) throw new NullPointerException();
RunnableFuture<T> ftask = newTaskFor(task);
execute(ftask);
return ftask;
}
...
public interface RunnableFuture<V> extends Runnable, Future<V> {
/**
* Sets this Future to the result of its computation
* unless it has been cancelled.
*/
void run();
}
线程池使用Callable接口需要调用submit方法,在submit的代码中,会将你的Callable对象包装成为一个RunnableFuture对象。而RunnableFuture就实现了我们上篇所说的Runnable接口。FutureTask是这个接口的真正实现类。这个类的主要工作是为run方法做装饰。
// code FutureTask.java 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 {
....
}
}
从代码上看,FutureTask在实现的时候,使用了CAS算法来保证原子性。实现方式是使用了UnSafe类。注入了当前的运行线程。之后调用Callable的call方法来获取返回值。然后通过set方法来设置你的result。
protected void set(V v) {
if (U.compareAndSwapInt(this, STATE, NEW, COMPLETING)) {
outcome = v;
U.putOrderedInt(this, STATE, NORMAL); // final state
finishCompletion();
}
}
public V get() throws InterruptedException, ExecutionException {
int s = state;
if (s <= COMPLETING)
s = awaitDone(false, 0L);
return report(s);
}
在FutureTask通过调用set来设置返回值了以后,另外一个线程通过调用get方法来获取执行结果。get方法在awaitDone的时候将执行CAS操作阻塞。那么我们基于以上的理解,回到我们刚才的code3 AsyncTask 的构造器代码。
mFuture复写了FutureTask的done方法,主要是为了处理当你的AsyncTask没有执行的时候,默认的返回值。我们构造完AsyncTask了以后,接下去就要执行它的execute方法。而execute方法内部会调用到executeOnExecutor()方法。
-executeOnExecutor包含两个种类型的参数,这一种是Executor 变量,一般情况下指的是我们上面说的线性执行队列SERIAL_EXECUTOR,第二种类型就是你传入的参数列表。
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;
}
在AsyncTask执行executeOnExecutor将回调onPreExecute方法,然后将参数列表注入到mWorker对象中。onPreExecute 是个空的protected方法。因此,这个回调是在当前调用线程中执行的。
当SERIAL_EXECUTOR.execute的时候,mFuture对象将会抛给共享线程池的execute 方法:
if ((mActive = mTasks.poll()) != null) {
THREAD_POOL_EXECUTOR.execute(mActive);
}
当mFuture处理完结果以后,将通过postResult方法将结果抛给Handler所在的线程。实际上在Handler里面定义了两个消息
1.private static final int MESSAGE_POST_RESULT = 0x1;
2. private static final int MESSAGE_POST_PROGRESS = 0x2;
分别用于返回结果到Handler所在线程,已经发布进度。发布进度的消息可以调用publicProgress发送出去。我们来看下Result消息的处理:
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;
}
}
...
private void finish(Result result) {
if (isCancelled()) {
onCancelled(result);
} else {
onPostExecute(result);
}
mStatus = Status.FINISHED;
}
消息处理将调用AsyncTask.finish方法。这个方法里面,将根据当前task的状态回调onCancelled方法,或者onPostExecute方法。这就是我们熟知的东西。要记住,这里面的回调方法,是在Handler所在的线程,一般是Ui线程中执行。那么这个Handler所在的线程是不是在Ui线程呢？
private static final InternalHandler sHandler = new InternalHandler();
AsyncTask使用一个静态成员变量来标记使用的Handler,那么这个Handler所在的线程就是第一次加载该类的那个线程。那么第一次加载该类是在什么地方呢？我们知道,所有的Android进程都是运行在Davik的虚拟机上的,这个虚拟机的入口是ActivityThread类。这个类运行的线程就是我们熟悉的UI线程。
//code ActivityThread.main
...
AsyncTask.init();
...
我们看到,在这个进程刚开始启动,还没进入消息循环的时候,主进程堆栈里,已经对AsyncTask进行了初始化的操作,这里面调用了AsyncTask的init方法:
/** @hide Used to force static handler to be created. */
public static void init() {
sHandler.getLooper();
}
当然这种调用没有任何的实际的逻辑意义,就像注释说的,只是为了让Handler生成而已。这样,实际上我们对AsyncTask本身已经分析的差不多了,最后一个小问题就是:既然AsyncTask里面用到Future的模式,那AsyncTask是否Future的特性的。这是当然的,AsyncTask里面提供了get接口,里面调用了Future的get接口,相当于有了Future的特性:
public final Result get() throws InterruptedException, ExecutionException {
return mFuture.get();
}
好的,更多的功能,更多的特性就让各位看官自己发掘吧。
——非墨
