AsyncTask-Analyze

我们在初学Android都用过AsyncTask 一个很方便用来请求网络改变UI控件的类。面试官不多不少也会问到AsyncTask的内容,下面来分析一下这个类内部的逻辑。

AsyncTask说明

AsyncTask内部封装了Handler和Thread分别原来改变ui线程和在子线程做耗时操作。同时AsyncTask是一个抽象的泛型类

1
public abstract class AsyncTask<Params,Progress,Result>{}
  1. Params代表参数类型(doInBackground的参数)通常是请求的url
  2. Progress代表进度类型(onProgressUpdate的参数)通常是Integer
  3. Result代表结果返回类型(onPostExecute的参数),如果asynctask不需要传递参数就用Void来代替上述三个参数类型

AsyncTask 4个核心方法

  1. onPreExecute() 异步开始前会执行该方法,用于显示dialog
  2. doInBackground(Params… params) 在线程池执行的异步任务,在此方法内调用publishProgress 传入int进度值来更新进度,返回结果给onPostExecute,这里的省略号是可以传入多个相同类型的参数。
  3. onPorgressUpdate(Progress… progress) 此方法在主线程执行,当任务发生进度改变就会调用此方法,比如显示下载进度
  4. onPostExecute(Result… result) 主线程执行,但异步方法执行完就会调用的方法。传入参数为doInBackground的返回值.

ps: 当doInBackground的线程被取消就会回调给onCancelled这个方法,此方法被调用onPostExecute就不会调用了。

总结:

  1. asynctask对象要在主线程创建,并调用execute方法
  2. 不能直接调用doinbackground方法
  3. 一个asynctask对象只执行一次
  4. 3.0之前asynctask用并行线程池执行,3.0后asynctask改用串行线程池,当然你可以通过asynctask.executeOnExecutor来并行执行任务

源码入口execute

AsyncTask开始执行的方法是在new AsyncTask().execute(url1),execute又调用了executeOnExetutor方法 传入一个串行的线程池SDefaultExecutor和url参数。以下代码:

1
2
3
4
@MainThread
public final AsyncTask<Params, Progress, Result> execute(Params... params) {
return executeOnExecutor(sDefaultExecutor, params);
}

上面的sDefaultExecute就是new一个SerialExecute类

1
2
3
public static final Executor SERIAL_EXECUTOR = new SerialExecutor();

private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;

进入SerialExecutor类,我们看到这个类有个mTask 里面的Runnable会排队执行。并且判断执行完开始执行下一个任务。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
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);
}
}
}

接来下,回到executeOnExetutor 这个方法里面 我们可以看到一个mStatus来记录当前任务的状态,期间不断改变状态。

每个AsyncTask最先执行onPreExecute方法,然后线程池exec.execute(mFuture);开始执行。这里的mFuture就是一个Runnable

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
@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;
}

接着将mFuture传入SerialExecutor的execute方法执行,将之前的mFuture对象插入队列mTask里面,判断当前有没有任务在进行,没活动就调用schedulNext方法执行下一个asynctask任务。

Asynctask里面有2个线程池(一个用于排队的serialexecutor和用于真正执行任务的THREAD_POOL_EXECUTOR )和(负责线程调度的)internalHandler

然后在Asynctask的构造方法 mWork会调用call方法将mTaskInvoked设置为true,再调用doinbackground 得到返回值再调用onpostexecute方法,

在postResult方法里面会发送message到sHandle来执行finish task还是更新进度条,这里的finish有2种情况分别是调用onCancelled 和onPostexecute.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
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;
}
};