AsyncTask 必知必会

概要

AsyncTask

在后台执行操作，并把结果发布到 UI 线程，避免手动调用 Thread 和 Handler.

官网提到

AsyncTask

适用于短时间操作，最多几秒时间。why? 后面源码分析说明。

官网还提到，如果执行长时间操作，强烈推荐我们使用并发包下的

Executor

,

ThreadPoolExecutor

,

FutureTask

。 这个怎么玩呢？ 后面举例。

例子

我把官网的小例子改编了下

private class DownloadFilesTask extends AsyncTask<URL, Void, Long> {
protected Long doInBackground(URL... urls) {
int count = urls.length;
long totalSize = 0;
for (int i = 0; i < count; i++) {
totalSize += Downloader.downloadFile(urls[i]);
}
return totalSize;
}

protected void onPostExecute(Long result) {
showDialog("Downloaded " + result + " bytes");
}
}

执行

AsyncTask

代码如下

new DownloadFilesTask().execute(url1, url2, url3);

构造方法

给开发者都调用的构造方法只有无参的构造方法

/**
* Creates a new asynchronous task. This constructor must be invoked on the UI thread.
*/
public AsyncTask() {
this((Looper) null);
}

从注释看，构造方法必须在

UI thread

中调用，why? 然后调用了带

Looper

参数的构造方法

public AsyncTask(@Nullable Looper callbackLooper) {
mHandler = callbackLooper == null || callbackLooper == Looper.getMainLooper()
? getMainHandler()
: new Handler(callbackLooper);

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;
}
};

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);
}
}
};
}

这个构造函数只初始化了三个变量

mHandler

,

mWorker

,

mFuture

。

mWorker

类型是

Callable

，是用来执行的任务。

mFuture

最主要的作用是用来获取执行的结果，例如

AsyncTask

的

get()

方法就是用

mFuture

来获取结果的。这里还复写了

done()

方法，也就是任务

mWorker

任务执行完毕后，会调用的，这里只是简单保证了结果会被发送到

UI Thread

中。

mHandler

因为传入的参数为

null

，所以它的值为

getMainHandler()

private static Handler getMainHandler() {
synchronized (AsyncTask.class) {
if (sHandler == null) {
sHandler = new InternalHandler(Looper.getMainLooper());
}
return sHandler;
}
}

private static class InternalHandler extends Handler {
public InternalHandler(Looper looper) {
super(looper);
}

@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;
}
}
}

也就是说

mHandler

也就是用主线程

Looper

创建的一个

Handler

对象, 用来传递结果，以及更新进度。

这也就回答了为何要在

UI thread

中创建

AsyncTask

对象，因为要保证用

Handler

能把消息发送回

UI thread

。

execute()

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

@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)");
}
}

// 更新 asyncTask 状态
mStatus = Status.RUNNING;

// 后台任务执行前调用
onPreExecute();

mWorker.mParams = params;
//执行任务
exec.execute(mFuture);

return this;
}

execute()

方法实际是调用了

executeOnExecutor()

方法，这两个方法都加上了

@MainThread

注解，告诉这两个方法需要在

main thread

中调用，原理与前面一样。

executeOnExecutor()

中通过对

mStatus

的判断的那段代码，就可以知晓为何一个

AsyncTask

对象只能调用一次

execute()

方法了。

executeOnExecutor()

最后用

sDefaultExecutor

的

execute()

方法执行了

mFuture

任务。看看

sDefaultExecutor

public static final Executor THREAD_POOL_EXECUTOR;

static {
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE_SECONDS, TimeUnit.SECONDS,
sPoolWorkQueue, sThreadFactory);
threadPoolExecutor.allowCoreThreadTimeOut(true);
THREAD_POOL_EXECUTOR = threadPoolExecutor;
}

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);
}
}
}

sDefaultExecutor

是静态的对象，也就说所有的

AsyncTask

共享一个

sDefaultExecutor

，那么如果创建了 N 个

AsyncTask

对象并且调用

execute()

方法，都会用

sDefaultExecutor

执行任务。

sDefaultExecutor

决定了

AsyncTask

执行任务的顺序，是顺序执行任务还是并行执行任务。 默认的是用的

SerialExecutor

，它保证任务的顺序执行，怎么保证了？

SerialExecutor

的

execute()

和

scheduleNext()

方法都添加了

synchronized

关键字，也就是任意时刻，只有一个任务能提交，而且从代码逻辑 看，提交之后，必须执行完，才能提交第二个任务并执行，如此循环下去，就保证了任务的顺序执行。

OK， 现在回到正题， 现在是用

sDefaultExecutor

提交了

mFuture

, 而

mFuture

是由

mWorker

构造，那么就会执行

mWorker

的

call()

方法

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;
}
};

call()

方法中调用了喜闻乐见的

doInBackground()

方法，注意，这个方法是在后台线程中执行的，由

sDefaultExecutor

保证的。

然后在异常处理的代码中发现，在发生异常的时候，首先会把任务设置为取消状态，然后再抛出。

在

finally

中，用

postResult(result)

把结果发送出去，最后会传递到

UI thread

中，代码如下

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 class InternalHandler extends Handler {
public InternalHandler(Looper looper) {
super(looper);
}

@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;
}
}
}

private void finish(Result result) {
if (isCancelled()) {
onCancelled(result);
} else {
onPostExecute(result);
}
mStatus = Status.FINISHED;
}

在

finish()

方法中可以看到，如果任务取消了(前面提到的异常 或者 手动调用

asyncTask.cancel(boolean)

)，就会调用

onCancelled()

回调，如果是正常流程，就执行

onPostExecute()

回调。

并发执行任务

默认情况下，

AsyncTask

是顺序执行任务，那么可不可以并行执行任务呢？我们只要改变执行任务的

Executor

就行了。

setDefaultExecutor()

方法可以改变默认的

Executor

，但是对开发者来说这个方法是不可以的

/** @hide */
public static void setDefaultExecutor(Executor exec) {
sDefaultExecutor = exec;
}

这个方法是隐藏的，why? 因为一旦开发者改变了

AsyncTask

的

sDefaultExecutor

，一会并行执行一会顺序执行，那岂不是乱套了~

那么利用

executeOnExecutor()

方法自己传入

Executor

@MainThread
public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,
Params... params) {}

AsyncTask

同时也提供了一个线程池用来并行执行任务

public static final Executor THREAD_POOL_EXECUTOR;

static {
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE_SECONDS, TimeUnit.SECONDS,
sPoolWorkQueue, sThreadFactory);
threadPoolExecutor.allowCoreThreadTimeOut(true);
THREAD_POOL_EXECUTOR = threadPoolExecutor;
}

也就是说

new MyAsyncTask().execute(THREAD_POOL_EXECUTOR, url1, url2, url3)

就可以并行执行多个任务。

那有人会问，既然可以并行，为何默认要顺序执行？ 问题就出在

ThreadPoolExecutor

上，如果任务的处理速度超过了任务的提交速度，那么并行完全 OK。 然而，如果提交的任务的速度远远大于任务的处理速度，那么 CPU 超负荷，性能得不到保障。因此，如果想要并行，就要考虑如何构造

ThreadPoolExecutor

对象。

进度更新

到现在为止，我还没有提到如何更新进度，官方的例子如下

private class DownloadFilesTask extends AsyncTask<URL, Integer, Long> {
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");
}
}

从例子中可以看到，在

doInBackground()

方法中，调用了

publishProgress()

方法来发布进度，源码如下

@WorkerThread
protected final void publishProgress(Progress... values) {
if (!isCancelled()) {
getHandler().obtainMessage(MESSAGE_POST_PROGRESS,
new AsyncTaskResult<Progress>(this, values)).sendToTarget();
}
}

private static class InternalHandler extends Handler {
// ...

@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;
}
}
}

publishProgress()

是通过

mHandler

把消息传回

UI thread

，然后回调了

onProgressUpdate()

(这个方法在例子中复写了)。 但是我们要注意，只有在这个任务没有被取消的情况下，才能发布进度。

如何正确取消任务

可能通过

AsyncTask

的

cancel()

方法取消任务

public final boolean cancel(boolean mayInterruptIfRunning) {
mCancelled.set(true);
return mFuture.cancel(mayInterruptIfRunning);
}

从源码实现看，参数

mayInterruptIfRunning

代表是否中断线程。如果线程不能响应中断，那么这种方式是无法取消任务的，只能等后台任务执行完毕，然后回调

onCancelled()

而不是

onPostExecute()

。

哪些情况线程能响应中断，请参考

Thread

类的

interrupt()

方法.

例子中，在

doInBackground()

方法中，用

for

循环，进行了多个下载任务，需要注意的是在

publishProgress()

方法后，会调用

isCancelled()

来判断任务是否取消，如果取消了就不再进行下一个下载任务。 这给了我们一个很好的示范，如果在

doInbackground()

中通过循环来处理一些事情，需要在恰当的位置判断任务是否中断，从而决定任务是否进行下一次循环。

执行长时间任务

开头提到，官网说如果运行的不是几秒的任务，而是长时间的任务，就不要用

AsyncTask

，而是用

Executor

,

ThreadPoolExecutor

,

FutureTask

。 其实这是因为

AsyncTask

默认顺序执行任务，如果某一个任务执行时间过长，会导致后面的任务延迟太长，而如果你很有把握，可以并发执行，也就不存在所谓的不能执行长时间任务了。

那么，既然官网都说了这茬，那么如何做呢？ 如果你对 Java 并发的这些类掌握得比较好的话，就很容易了。

demo 代码如下

public class TestActivity extends AppCompatActivity {
private TextView mTextView;
private Handler mUIHandler;
private FutureTask<String> mFutureTask;
private ExecutorService mService;

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_test_acrtivity);
mTextView = findViewById(R.id.tv);
mService = Executors.newCachedThreadPool();
mFutureTask = new FutureTask<String>(new Task()) {
@Override
protected void done() {
runOnUiThread(new Runnable() {
@Override
public void run() {
mUIHandler.sendEmptyMessage(666);
}
});
}
};
mUIHandler = new Handler(getMainLooper()) {
@Override
public void handleMessage(Message msg) {
if (msg.what == 666) {
try {
mTextView.setText(mFutureTask.get());
} catch (InterruptedException | ExecutionException e) {
e.printStackTrace();
}
}
}
};
}

@Override
protected void onResume() {
super.onResume();
mService.execute(mFutureTask);
}

private static class Task implements Callable<String> {
@Override
public String call() throws Exception {
Log.d("david", "doInBackground ... ");
// 假如这里3秒代表的是30秒，甚至更长时间运行的任务
TimeUnit.SECONDS.sleep(3);
return "Download has completed!";
}
}

}

原理与

AsyncTask

一致，我就不献丑解释代码了。

那么，你可能有疑问，这明明可以通过

Thread

和

Handler

实现的，为何要搞这么复杂。 简单的理由有几个

Thread 类执行任务无法查询执行的结果，也没有 API 调用来取消任务。

并发任务需要用

ThreadPoolExecutor

，而 Thread 类无法做到这一点。

其实把代码做下封装，基本上就是

AsyncTask

了。