protected void onPreExecute() {
super.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;
}
protected void onProgressUpdate(Integer... progress) {
setProgressPercent(progress[0]);
}
protected void onPostExecute(Long result) {
showDialog("Downloaded " + result + " bytes");
}}
* * *
[](
)一、AsyncTask构造函数
--------------------------------------------------------------------------
首先先从AsyncTask的构造函数说起：
/AsyncTask的构造函数源码片段/
public AsyncTask() {
mWorker = new WorkerRunnable<Params, Result>() {
public Result call() throws Exception {
mTaskInvoked.set(true);
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
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) {
...
e.getCause());
} catch (CancellationException e) {
postResultIfNotInvoked(null);
}
}
};}
在AsyncTask构造函数中初始化了两个对象：WorkerRunnable和FutureTask，分别赋值为mWorker、mFuture。这两个对象初始化都实现了两个回调方法，当用户执行了execute方法的时候在特定情况下会触发这两个对象的回调方法，下面我们就开始详细分析这两个对象。
#### [](
)结论：doInBackground是在WorkerRunnable的call方法中被回调执行的
### [](
)WorkerRunnable【mWorker】
由于WorkerRunnable实现了Callable接口，所以在AsyncTask的构造函数中实例化WorkerRunnable时，必须实现call()方法。其中还需要指定泛型参数Params和Result。这样在回调了call方法之后，就能返回Result。
/ WorkerRunable类/
private static abstrat class WorkerRunable<Params, Result> implements Callable<Result>
{
Params[] mParams;}
/ Callable接口/
public interface Callable<V>
{
V call() throws Exception;}
现在我们暂时只需要知道当执行execute的时候会回调WorkerRunnable的call方法。
### [](
)FutureTask【mFuture】
从上面的AsyncTask的构造函数源码中可以看到，在构造FutureTask对象初始化时，mWorker是作为参数传递进来的。从FutureTask的构造函数也看出来了FutureTask需要一个Callable对象。
/ FutureTask的构造函数/
public FutureTask(Callable<V> callable) {
if (callable == null)
throw new NullPointerException();
this.callable = callable;
this.state = NEW; // ensure visibility of callable
}
【在这里不禁可以提前猜测出一个信息了，既然FutureTask把WorkerRunnable传递进来了，那WorkerRunnable的回调方法call肯定是在FutureTask中调用的】
来看看FutureTask这个类：
可以看出，FutureTask是实现了RunnableFuture接口，而这个接口继承了Runnable、以及Future。
通过上面两个类，发现其实FutureTask中的get方法实现了Runnable的阻塞和返回执行完毕的数据(泛型V)。
我们再来看FutureTask的run方法，豁然开朗，原来WorkerRunnable中的回调方法call果然是在这里调用的。
#### [](
)结论：WorkerRunnable中的回调方法call()是在执行FutureTask的run方法后回调的。当WorkerRunnable的call方法执行完毕后将返回数据给FutureTask。
疑问：那么，FutureTask的run方法又是被谁调用的呢？
* * *
[](
)二、execute()方法
------------------------------------------------------------------------
很显然，FutureTask的run方法肯定需要AsyncTask执行execute方法后才会执行。
private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
/ AsyncTask类的execute方法/
public final AsyncTask<Params, Progress, Result> execute(Params… params) {
return executeOnExecutor(sDefaultExecutor, params);}
当执行execute方法时，其实是调用的executeOnExecutor方法。这里传递了两个参数，一个是sDefaultExecutor，一个是params。从上面的源码可以看出，sDefaultExecutor其实是一个SerialExecutor对象。params其实最终会赋给doInBackground方法，就是用户实现回调的方法，这个后面会看到。
### [](
)executeOnExecutor
我们现在先来看executeOnExecutor方法。
/ AsyncTask类的executeOnExecutor方法/
public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,
Params... params) {
...
mStatus = Status.RUNNING;
onPreExecute();实战系列
话不多说，Android实战系列集合都已经系统分类好，由于文章篇幅问题没法过多展示
CodeChina开源项目：《Android学习笔记总结+移动架构视频+大厂面试真题+项目实战源码》
原创文章，作者：kepupublish，如若转载，请注明出处：https://blog.ytso.com/149625.html