本想写一下源码的获取和编译的过程,无奈出租房的网络实在太差,没能把源码下完整,暂且跳过这一步,假设我已经写好了.这一篇就学习一下AsyncTask,这是一个比较简单的知识点,作为源码开发的热身小甜点.
AsyncTask是一个轻量级的异步操作类,我写了一个极其简单的Demo代码如下
public class MainActivity extends Activity {
private final String TAG = "testlog";
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
//实例化一个AsyncTask
new AsyncTask<Integer, Integer, Integer>() {
//根据名字可以了解到这个函数可以在执行doInBackground函数之前做一些初始化的工作
@Override
protected void onPreExecute() {
super.onPreExecute();
log("onPreExecute: ");
}
//进行异步操作的函数,该函数不在主线程执行
@Override
protected Integer doInBackground(Integer... integers) {
log("doInBackground: init > " + integers[0]);
int i = 5;
while (i-- > 0) {
log("doInBackground: " + i);
//调用该函数可以更新进度条,会调用onProgressUpdate()函数
publishProgress(i);
//模拟耗时操作
sleep(500);
}
return i;
}
//执行在主线程里
@Override
protected void onProgressUpdate(Integer... values) {
super.onProgressUpdate(values);
log("onProgressUpdate: " + values[0]);
}
//异步操作执行完成后调用该方法
@Override
protected void onPostExecute(Integer integer) {
super.onPostExecute(integer);
log("onPostExecute: " + integer);
}
}.execute(13);
}
private void sleep(long time) {
try {
Thread.sleep(time);
} catch (Exception e) {
e.printStackTrace();
}
}
private void log(String msg) {
Log.i(TAG, msg + " > " + Thread.currentThread());
}执行结果如下
04-14 13:02:10.250 I: onPreExecute: > Thread[main,5,main]
04-14 13:02:10.251 I: doInBackground: init > 13 > Thread[AsyncTask #1,5,main]
04-14 13:02:10.255 I: doInBackground: 4 > Thread[AsyncTask #1,5,main]
04-14 13:02:10.264 I: onProgressUpdate: 4 > Thread[main,5,main]
04-14 13:02:10.757 I: doInBackground: 3 > Thread[AsyncTask #1,5,main]
04-14 13:02:10.758 I: onProgressUpdate: 3 > Thread[main,5,main]
04-14 13:02:11.259 I: doInBackground: 2 > Thread[AsyncTask #1,5,main]
04-14 13:02:11.260 I: onProgressUpdate: 2 > Thread[main,5,main]
04-14 13:02:11.761 I: doInBackground: 1 > Thread[AsyncTask #1,5,main]
04-14 13:02:11.762 I: onProgressUpdate: 1 > Thread[main,5,main]
04-14 13:02:12.263 I: doInBackground: 0 > Thread[AsyncTask #1,5,main]
04-14 13:02:12.264 I: onProgressUpdate: 0 > Thread[main,5,main]
04-14 13:02:12.765 I: onPostExecute: -1 > Thread[main,5,main]接下来就去挖坟,看看这是一个怎样的流程,首先从AsyncTask的入口execute着手
@MainThread
public final AsyncTask<Params, Progress, Result> execute(Params... params) {
return executeOnExecutor(sDefaultExecutor, params);
}在execute里面调用了executeOnExecutor()函数,不过多了一个参数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);
}
}
} @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;
}
这里面先判断了一下当前的状态,怪不得这个异步任务只能执行一次execute(),原来在这块根据状态抛出了异常.判断状态之后调用了onPreExecute(),这是AsyncTask回调的第一个函数,注意这个 @MainThread 注解的意思是这个函数必须在主线程中执行.回调onPreExecute()之后又调用了exec.execute(mFuture),看看mFuture是啥，
mFuture = new FutureTask<Result>(mWorker) public class FutureTask<V> implements RunnableFuture<V> public interface RunnableFuture<V> extends Runnable, Future<V> protected synchronized void scheduleNext() {
if ((mActive = mTasks.poll()) != null) {
THREAD_POOL_EXECUTOR.execute(mActive);
}
}这个函数是把队列中的第一个任务放进线程池，这样一来在条件允许的情况下会执行该任务，也就是会在新的线程里回调mFuture的的run方法。下面研究一下FutureTask类
public FutureTask(Callable<V> callable) {
if (callable == null)
throw new NullPointerException();
this.callable = callable;
this.state = NEW; // ensure visibility of callable
}
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);
}
}在这里调用的 mWorker的call()函数，在回到AsyncTask类看看mWorker是什么样子的。
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(),因为他是由mFuture所在线程调用的，也就是线程池里的线程，并非在主线程上运行，所以这里不能出现直接更新UI的操作。在最后还调用了 postResult(result);
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;
}
}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;
}
}
}原来他是AsyncTask里的handler，他接收到MESSAGE_POST_RESULT消息的时会调用finish()函数
private void finish(Result result) {
if (isCancelled()) {
onCancelled(result);
} else {
onPostExecute(result);
}
mStatus = Status.FINISHED;
}在finish()里调用了 onPostExecute(result);因为是AsyncTask的handler调用的finish()函数，因此该函数是运行在AsyncTask所在的线程里的，也就是主线程。至此AsyncTask的三个函数
protected void onPreExecute()
protected Integer doInBackground(Integer... integers)
protected void onPostExecute(Integer integer)都已经出现了，还差一个 protected void onProgressUpdate(Integer... values)，这个函数通常是为了更新进度条的，与他有直接关系的就是publishProgress(Progress... values)
@WorkerThread
protected final void publishProgress(Progress... values) {
if (!isCancelled()) {
getHandler().obtainMessage(MESSAGE_POST_PROGRESS,
new AsyncTaskResult<Progress>(this, values)).sendToTarget();
}
}