在android开发中线程有主副之别,即耗时操作要由子线程操作,然后主线程来更新Ui;handler就充当一个子线程和主线程切换的角色;但是相比于handler,AsyncTask更加轻量级;那么直接开始解析AsyncTask的源码:
1.AsyncTask的使用:
//参一:Params, 参二:Progress, 参三:Result
AsyncTask mAsync = new AsyncTask<String,Integer,String>(){
//在开始之前完成初始化等一系列的准备工作
@Override
protected void onPreExecute() {
super.onPreExecute();
}
//在这个方法中处理耗时操作
@Override
protected String doInBackground(String... strings) {
return null;
}
//接收处理完的返回值然后开始在UI线程中处理更新Ui的操作
@Override
protected void onPostExecute(String s) {
super.onPostExecute(s);
}
//在这里跟新进度条
@Override
protected void onProgressUpdate(Integer... values) {
super.onProgressUpdate(values);
}
}.execute(new String[]{"haha"} );
首先来看在new AsyncTask的时候 传入的参数为(Paramas,Progress,Result);在这一步就确定了 耗时操作参数的类型,耗时操作完成之后的返回值类型,进度条progress值的类型
2.execute(Params… params)
首先来看execute源码:
public final AsyncTask<Params, Progress, Result> execute(Params... params) {
return executeOnExecutor(sDefaultExecutor, params);
}
看的出来execute的真正实现方法是:executeOnExecutor,ok~接下来来看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;
}
在以上源码中,第一步是走的AsyncTask的onPreExecute();相当于数据初始化的准备工作;
之后是mWorker.mParams = params;很明显是个mWorker的mParams属性赋值;ok~ 那么接着来看mWork(WorkerRunnable)这个类的源码实现:
private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {
Params[] mParams;
}
以上代码看不出什么 那么据需看mWorker的具体实例化过程(即是new 该对象的过程):
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;
}
};
注意关键代码:result = doInBackground(mParams);在这里mWorker.Params已经赋值完毕;然后params的值赋值给doInBackground的参数;供开发者来实现,以params作为参数来做耗时处理,最后返回result;
接着回到executeOnExecutor方法中 :onPreExecute()—>oWorker.Pramas = pramas;接着来看:exec.execute(mFueture);
那么我们来看mFueture所代表的类实例化的源码:
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);
}
}
};
首先会走FutureTask的构造,将参数mWorker进行初始化的赋值:
public FutureTask(Callable<V> callable) {
if (callable == null)
throw new NullPointerException();
this.callable = callable;
this.state = NEW; // ensure visibility of callable
}
在走完构造之后Future中的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);
}
}
这里的callable就是穿进来的参数mworker,然后调用mWorker的call方法返回耗时操作(供开发者实现并返回)的返回值,进行set(result)到线程池中(有兴趣要看下线程池的概念,这里先不解释)
这里写代码片
ok~来看下new FutureTask<Result>(mWorker)关键的代码:
postResultIfNotInvoked(get());
先来看get()的实现:
public V get() throws InterruptedException, ExecutionException {
int s = state;
if (s <= COMPLETING)
s = awaitDone(false, 0L);
return report(s);
}
@SuppressWarnings("unchecked")
private V report(int s) throws ExecutionException {
Object x = outcome;
if (s == NORMAL)
return (V)x;
if (s >= CANCELLED)
throw new CancellationException();
throw new ExecutionException((Throwable)x);
}
可以看出来get()—>reprot(s) 而report返回是(V)x,就是outcome;
然后追溯outcome:
看到outcome在set(Result)中被赋值;
protected void set(V v) {
if (U.compareAndSwapInt(this, STATE, NEW, COMPLETING)) {
outcome = v;
U.putOrderedInt(this, STATE, NORMAL); // final state
finishCompletion();
}
}
联系前面FutureTask实例化run()中通过set(result)到线程池,get()就是从先前的线程池中取出result;是不是恍然大悟;ok~这样我们就可以将:postResultIfNotInvoked(get());变化为postResultIfNotInvked(result)了;那么接下来看postResultIfNoInvoked的源码:
private void postResultIfNotInvoked(Result result) {
final boolean wasTaskInvoked = mTaskInvoked.get();
if (!wasTaskInvoked) {
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;
}
很明显是要利用handler将result回归主线程更新ui,顺着猜测往下看,来追溯,handleMessger()的方法:
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;
}
}
迅速找到刚刚发送msg的what为MESSAGE_POST_RESULT;ok~接下来就简单了 获取result作为参数走到 result.mTask.finish(result.mData[0]);
那么来看finish的源码:
private void finish(Result result) {
if (isCancelled()) result = null;
// 在主线程中调用更新界面的方法
onPostExecute(result);
mStatus = Status.FINISHED;
}
显而易见,在finish中调用onPostExecute(result)来更新ui(开发者实现抽象方法onPostExecute(result)来更新ui)
到这里AsyncTask的源码解析就完成了,感谢阅读,期待一起进步,欢迎关注,谢谢~