Android基础—AsyncTask机制

AsyncTask基本使用：

AsyncTask<String, Integer, Object> asyncTask = new AsyncTask<String, Integer, Object>() {

protected void onPreExecute() {};

@Override
protected Object doInBackground(String... params) {
return null;
}

protected void onPostExecute(Object result) {};

protected void onProgressUpdate(Integer[] values) {};

};
asyncTask.execute("params")

AsyncTask的execute方法，开始执行异步任务，在此方法体中

public final AsyncTask<Params, Progress, Result> execute(Params... params) {
...

mStatus = Status.RUNNING;

//调用onPreExecute方法
onPreExecute();

//把参数赋值给mWorker对象
mWorker.mParams = params;
//线程池对象执行mFuture
sExecutor.execute(mFuture);

return this;
}

mWorker是什么类型？，在AsyncTask的构造方法中

mWorker = new WorkerRunnable<Params, Result>() {
public Result call() throws Exception {
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
return doInBackground(mParams);
}
};

然后把mWorker对象封装至FutureTask对象

mFuture = new FutureTask<Result>(mWorker)

在FutureTask的构造中，又把mWorker封装给Sync对象

public FutureTask(Callable<V> callable) {
if (callable == null)
throw new NullPointerException();
sync = new Sync(callable);
}

在Sync的构造方法中

Sync(Callable<V> callable) {
//这里的callable就是mWorker
this.callable = callable;
}

线程池执行mFuture对象，此对象是FutureTask的对象，而FutureTask实现了Runnable接口

public final AsyncTask<Params, Progress, Result>                    execute(Params... params) {
...

//线程池对象开一个子线程去执行mFuture对象中的run方法
sExecutor.execute(mFuture);
...
}

mFuture的run方法被调用了

public void run() {
sync.innerRun();
}

在innerRun方法中，调用了callable的call方法，但是在sync被new出来的时候，在构造方法中就已经把mWorker赋值给了callable，所以实际上是调用mWorker的call方法

void innerRun() {
...
//调用mWorker的call()
result = callable.call();

set(result);
...
}

mWorker的call在mWorker被new出来时就已经重写了

mWorker = new WorkerRunnable<Params, Result>() {
public Result call() throws Exception {
...
//在子线程中调用了doInBackground方法
return doInBackground(mParams);
}
};

call方法调用完毕后，得到doInBackground所返回的result

void innerRun() {
...
result = callable.call();
//返回的result传入了set方法
set(result);
...
}

set方法体

protected void set(V v) {
sync.innerSet(v);
}

innerSet方法体

if (compareAndSetState(s, RAN)) {
result = v;
releaseShared(0);
//关键的done方法
done();
return;
}

innerSet方法是属于FutureTask类的，那么done方法也是调用FutureTask类的，这个done方法定义的地方，在AsyncTask.java的构造方法里

mFuture = new FutureTask<Result>(mWorker) {
//此处重写done方法
@Override
protected void done() {

//获取doInbackground方法返回的结果
result = get();

//创建一个消息
message = sHandler.obtainMessage(MESSAGE_POST_RESULT,
new AsyncTaskResult<Result>(AsyncTask.this, result));
//把这条消息发送给创建这个消息的Handler：target.sendMessage(this)
message.sendToTarget();
}
};

然后sHandler的handlerMessage被触发

public void handleMessage(Message msg) {
AsyncTaskResult result = (AsyncTaskResult) msg.obj;
switch (msg.what) {
case MESSAGE_POST_RESULT:
//调用finish方法
result.mTask.finish(result.mData[0]);
break;

}
}

查看AsyncTaskResult类中的mTask成员，其实它就是AsyncTask对象

再看AsyncTask对象的finish的方法体

private void finish(Result result) {
if (isCancelled()) result = null;
//调用onPostExecute方法，并传入结果
onPostExecute(result);
mStatus = Status.FINISHED;
}