时间是一切财富中最宝贵的财富 — 德奥弗拉斯多
写在前面
趁着周日休息，研究一下AsyncTask，我相信大家对AsyncTask并不陌生，用来做下载任务最爽了，即能在子线程中做耗时任务，又可以随意的回到主线程更新UI。
用法
首先，让我们来认识一下AsyncTask，正如其名“异步任务”，它是用来做异步任务的，不同于线程等，AsyncTask是一个抽象类，必须创建一个子类继承自AsyncTask，并指定其参数类型。AsyncTask有五个回调函数，各司其职。
接下来还是通过一个小Demo认识它吧：
public class AsyncTaskActivity extends BaseAppCompatActivity {
@BindView(R.id.bar_seek)
protected SeekBar mSeekBar;
@BindView(R.id.text_tips)
protected AppCompatTextView mTextTips;
private DownloadAsyncTask mDownloadAsyncTask;
@Override
public int getLayoutId() {
return R.layout.activity_async_task;
}
@Override
public void initViews() {
}
@Override
public void initData() {
}
@OnClick(R.id.btn_start)
protected void onStartClick() {
if (mDownloadAsyncTask == null) {
mDownloadAsyncTask = new DownloadAsyncTask();
}
// 调用execute()执行任务，每一个任务只能调用一次execute()，否则会抛出异常
mDownloadAsyncTask.execute();
}
@OnClick(R.id.btn_cancel)
protected void onCancelClick() {
if (mDownloadAsyncTask == null) {
return;
}
// 调用cancel()取消任务，其实它并不会真正的取消，本质上调用的是Thread.interrupt()
mDownloadAsyncTask.cancel(true);
}
// 继承自AsyncTask的子类，指定传入的参数类型为Void（无参数类型），
// 进度条参数类型为Integer，返回结果参数类型为String。
private class DownloadAsyncTask extends AsyncTask<Void, Integer, String> {
// 第一个回调，该回调运行在主线程中，
// 在AsyncTask调用execute()之后和doInBackground()之前回调，
// 用于前期的准备工作， 比如显示进度条，提示用户开始下载了
@Override
protected void onPreExecute() {
super.onPreExecute();
mSeekBar.setVisibility(View.VISIBLE);
mSeekBar.setMax(100);
mTextTips.setText("开始下载");
}
// 第二个回调，该回调是真正运行在子线程中的，不可以进行UI更新操作，
// 该函数是AsyncTask的核心函数，异步任务就是在这里做的，比如下载
// 若要更新进度，可以调用publishProgress()，然后在onProgressUpdate()中更新进度
@Override
protected String doInBackground(Void... voids) {
for (int i = 0 ; i < 100 ; i ++) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
return "下载失败";
}
(new Integer[]{i});
}
return "下载成功";
}
// 更新进度回调，该函数运行在主线程中，
// 通过在doInBackground()中调用publishProgress()函数，就会回调该函数，
// 比如更新下载进度
@Override
protected void onProgressUpdate(Integer... values) {
super.onProgressUpdate(values);
mSeekBar.setProgress(values[0]);
}
// 请求结果回调，该函数运行在主线程中，
// 该函数是在doInBackground()中return后回调，即doInBackground()做完了
// 比如提示用户下载成功，隐藏进度条
@Override
protected void onPostExecute(String s) {
super.onPostExecute(s);
mSeekBar.setVisibility(View.GONE);
mTextTips.setText(s);
}
// 任务取消回调，该函数运行在主线程中，
// 在AsyncTask调用了cancel()后回调，并将当前doInBackground()的结果作为参数传入
// 比如可以用来提示用户下载已取消
@Override
protected void onCancelled(String s) {
super.onCancelled(s);
mSeekBar.setVisibility(View.GONE);
mTextTips.setText("取消下载");
}
}
}
在上面的Demo里我创建了一个DownloadAsyncTask内部类继承自AsyncTask，并指定参数类型分别为Void，Integer，String，这三个参数分别为传入的参数类型，进度的参数类型，返回结果的参数类型，若无参数则使用Void指定。
注意：
- 每一个AsyncTask对象只能调用一次execute()，否则会抛出异常，具体原因稍后会讲。
- 调用execute()函数一定要在主线程中，因为onPreExecute()函数是在调用execute()的线程中回调的，若要在onPreExecute()函数中更新UI，就要在主线程中调用execute()。
- 调用cancel()取消任务，其实就是调用的Thread.interrupt()，然后抛出异常，使其达到取消的效果。如果要做到真正的取消，就在doInBackground()中使用取消Thread相同的方式进行取消。
- 不可以直接调用onPreExecute()，doInBackground()，onPostExcute()，onProgressUpdate()，onCancelled()五个回调函数。直接调用没有任何意义，就更没有必要使用AsyncTask了。
源码
// AsyncTask是一个带有泛型参数的抽象类，子类需要继承它并指定参数类型
// Params是调用execute()时传入的参数
// Progress是更新进度时的参数
// Result是返回结果时的参数
public abstract class AsyncTask<Params, Progress, Result> {
private static final String LOG_TAG = "AsyncTask";
// CPU可用的处理器个数
private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
// We want at least 2 threads and at most 4 threads in the core pool,
// preferring to have 1 less than the CPU count to avoid saturating
// the CPU with background work
private static final int CORE_POOL_SIZE = Math.max(2, Math.min(CPU_COUNT - 1, 4));
private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;
private static final int KEEP_ALIVE_SECONDS = 30;
// 线程工厂
private static final ThreadFactory sThreadFactory = new ThreadFactory() {
private final AtomicInteger mCount = new AtomicInteger(1);
public Thread newThread(Runnable r) {
return new Thread(r, "AsyncTask #" + mCount.getAndIncrement());
}
};
// 阻塞任务队列
private static final BlockingQueue<Runnable> sPoolWorkQueue =
new LinkedBlockingQueue<Runnable>(128);
// 真正执行具体任务的线程池
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;
}
// 任务队列线程池，即任务调度
public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
// 任务完成的消息
private static final int MESSAGE_POST_RESULT = 0x1;
// 更新进度的消息
private static final int MESSAGE_POST_PROGRESS = 0x2;
// 默认的线程池，默认线程池是任务队列线程池，
// 也可以通过setDefaultExecutor(Executor exec)自定义线程池
private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
// 该Handler用于切换到主线程
private static InternalHandler sHandler;
// 真正执行任务的地方，即doInBackground()
private final WorkerRunnable<Params, Result> mWorker;
private final FutureTask<Result> mFuture;
// 任务的当前状态，使用volatile修饰，表示该变量是可变的，
// 但是同一时间只允许一个线程修改它，是线程安全的
private volatile Status mStatus = Status.PENDING;
// 任务是否已经取消
private final AtomicBoolean mCancelled = new AtomicBoolean();
// 任务是否已经执行
private final AtomicBoolean mTaskInvoked = new AtomicBoolean();
private final Handler mHandler;
// 任务调度线程池，使用了ArrayDeque维护了一个任务队列，
// 使任务能够有序执行，同一时间只能执行一个任务，按照时间顺序依次执行
private static class SerialExecutor implements Executor {
// 任务队列
final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
// 当前正在执行的任务
Runnable mActive;
// 使用synchronized修饰该函数，同一时刻只有一个线程能够执行，保证线程安全
public synchronized void execute(final Runnable r) {
// 向任务队列加入新的任务
mTasks.offer(new Runnable()) {
public void run() {
try {
// 执行具体任务
r.run();
} finally {
// 任务执行完成，就会调用scheduleNext()去执行下一个任务
scheduleNext();
}
}
});
// 第一次会走该case
if (mActive == null) {
scheduleNext();
}
}
// 使用synchronized修饰该函数，同一时刻只有一个线程能够执行，保证线程安全
protected synchronized void scheduleNext() {
// 从任务队列取出任务，并放到执行具体任务的线程池中执行
if ((mActive = mTasks.poll()) != null) {
THREAD_POOL_EXECUTOR.execute(mActive);
}
}
}
// 任务状态
public enum Status {
// 等待
PENDING,
// 执行中
RUNNING,
// 完成
FINISHED,
}
// 获取主线程的Handler，用于切换线程，更新UI
private static Handler getMainHandler() {
// 使用同步代码块保证线程安全
synchronized (AsyncTask.class) {
// 使用主线程Looper创建Handler
if (sHandler == null) {
sHandler = new InternalHandler(Looper.getMainLooper());
}
return sHandler;
}
}
private Handler getHandler() {
return mHandler;
}
// 设置默认的线程池
public static void setDefaultExecutor(Executor exec) {
sDefaultExecutor = exec;
}
// 空参数的构造函数，实际是调用带有Looper参数的构造函数
public AsyncTask() {
this((Looper) null);
}
// 带有Handler的构造函数，实际是调用带有Looper参数的构造函数
public AsyncTask(@Nullable Handler handler) {
this(handler != null ? handler.getLooper() : null);
}
// 带有Looper的构造函数，即核心构造函数，该函数中没有执行具体的任务，
// 只是初始化了几个变量，一个mHandler，一个mWorker和一个mFuture
// mWorker和mFuture是为执行具体任务做准备的变量，初始化好等待使用
public AsyncTask(@Nullable Looper callbackLooper) {
mHandler = callbackLooper == null || callbackLooper == Looper.getMainLooper()
? getMainHandler()
: new Handler(callbackLooper);
// 新建一个WorkerRunable()对象
mWorker = new WorkerRunnable<Params, Result>() {
public Result call() throws Exception {
// 设置任务已经执行
mTaskInvoked.set(true);
Result result = null;
try {
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
// 工作线程中做具体任务
result = doInBackground(mParams);
Binder.flushPendingCommands();
} catch (Throwable tr) {
// 设置任务已经取消
mCancelled.set(true);
throw tr;
} finally {
// 任务完成会执行
postResult(result);
}
return result;
}
};
// 新建一个Future对象，将mWorker传入
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);
}
}
};
}
// 任务取消后会被调用，即执行到mFuture.done()函数
private void postResultIfNotInvoked(Result result) {
final boolean wasTaskInvoked = mTaskInvoked.get();
// 任务没有执行则调用postResult(result)通知任务执行完成，
// 即没有执行到mWorker.call()函数，因为mTaskInvoked是在mWorker.call()中设置为true的。
if (!wasTaskInvoked) {
// 任务还没有开始就取消了
postResult(result);
}
}
// 任务执行完会调用该函数
private Result postResult(Result result) {
@SuppressWarnings("unchecked")
// 通过Handler切换至主线程执行
Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
new AsyncTaskResult<Result>(this, result));
message.sendToTarget();
return result;
}
// 获取当前任务状态
public final Status getStatus() {
return mStatus;
}
// 该函数是抽象的，一定会被子类重写，运行在工作线程中，处理具体任务
@WorkerThread
protected abstract Result doInBackground(Params... params);
// 该函数可根据需求重写，运行在主线程中，在doInBackground()之前会调用
// 可做UI的前期准备工作
@MainThread
protected void onPreExecute() {
}
// 该函数可根据需求重写，运行在主线程中，在doInBackground()执行完会被调用
// 可处理结果，更新UI；任务做完就会回调
@SuppressWarnings({"UnusedDeclaration"})
@MainThread
protected void onPostExecute(Result result) {
}
// 该函数可根据需求重写，运行在主线程中，
// 在doInBackground()中调用publishProgress()方可执行到该函数，
// 可在UI中实时更新任务进度
@SuppressWarnings({"UnusedDeclaration"})
@MainThread
protected void onProgressUpdate(Progress... values) {
}
// 该函数可根据需求重写，运行在主线程中，调用AsyncTask.cancel()后会被调用，
// 可更新UI
@SuppressWarnings({"UnusedParameters"})
@MainThread
protected void onCancelled(Result result) {
onCancelled();
}
// 该函数可根据需求重写，运行在主线程中，调用AsyncTask.cancel()后会被调用，
// 可更新UI
@MainThread
protected void onCancelled() {
}
// 当前任务是否已取消
public final boolean isCancelled() {
return mCancelled.get();
}
// 取消任务
public final boolean cancel(boolean mayInterruptIfRunning) {
// 设置当前取消状态
mCancelled.set(true);
// mFuture.cancel()内部是调用的Thread.interrupt()
return mFuture.cancel(mayInterruptIfRunning);
}
/**
* Waits if necessary for the computation to complete, and then
* retrieves its result.
*
* @return The computed result.
*
* @throws CancellationException If the computation was cancelled.
* @throws ExecutionException If the computation threw an exception.
* @throws InterruptedException If the current thread was interrupted
* while waiting.
*/
public final Result get() throws InterruptedException, ExecutionException {
return mFuture.get();
}
// 该函数开始执行任务了，传入的参数类型则是该类上泛型的第一个参数类型
// 运行在主线程中，会返回一个具体AsyncTask对象
@MainThread
public final AsyncTask<Params, Progress, Result> execute(Params... params) {
return executeOnExecutor(sDefaultExecutor, params);
}
// 该函数传入一个线程池和具体的参数，AsyncTask可以直接调用该函数传入自定义的线程池
@MainThread
public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,
Params... params) {
// 如果当前任务不是等待状态就会抛出异常，也就是为什么一个AsyncTask不能调用两次execute()
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()，可在UI线程中做任务开始前的准备工作
onPreExecute();
// 将参数传给mWorker
mWorker.mParams = params;
// 若没有自定义线程池，则使用默认的线程池，将mFuture加入到任务队列执行，
// 若有自定义线程池，则根据自定义线程池的规则去执行
exec.execute(mFuture);
return this;
}
// 该函数也可以直接调用，但是要传入具体的任务，加入到任务队列等待执行，
// 即不需要使用AsyncTask的mFuture
@MainThread
public static void execute(Runnable runnable) {
sDefaultExecutor.execute(runnable);
}
// 该函数用于更新进度，在doInBackground()中调用
@WorkerThread
protected final void publishProgress(Progress... values) {
// 任务没有取消，则使用Handler切换至主线程
if (!isCancelled()) {
getHandler().obtainMessage(MESSAGE_POST_PROGRESS,
new AsyncTaskResult<Progress>(this, values)).sendToTarget();
}
}
// 该函数是在InternalHandler中收到MESSAGE_POST_RESULT消息时调用
private void finish(Result result) {
// 如果任务已经取消了，则回调onCancelled()函数，
// 否则回调onPostExecute()函数
if (isCancelled()) {
onCancelled(result);
} else {
onPostExecute(result);
}
// 设置任务执行完成
mStatus = Status.FINISHED;
}
// 内部Handler，该Handler运行在主线程中
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;
}
}
}
// 实现了Callable接口，并保存一个参数，用于doInBackground()做任务时需使用的参数
private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {
Params[] mParams;
}
// 结果实体类
// 第一个函数是当前AsysncTask对象
// 第二个函数是任务结果
@SuppressWarnings({"RawUseOfParameterizedType"})
private static class AsyncTaskResult<Data> {
final AsyncTask mTask;
final Data[] mData;
AsyncTaskResult(AsyncTask task, Data... data) {
mTask = task;
mData = data;
}
}
}
总结
分析了AsyncTask的源码后，是不是就有了更深的了解呢，我想是的，反正我对它的了解是更深了。
- AsyncTask是抽象类，必须创建其子类并继承AsyncTask，指定其泛型参数类型方可使用；doInBackground()是抽象函数，其子类一定会重写，它是执行具体任务的函数；onPreExecute()，onProgressUpdate()，onPostExecute()，onCancelled()四个函数可根据实际项目需求进行重写。
- AsyncTask会提供两个线程池和一个Handler；线程池THREAD_POOL_EXECUTOR用来执行具体任务；线程池SERIAL_EXECUTOR用来任务调度，其内部使用了ArrayDeque维护了一个任务队列，当调用execute(Runnable r)函数时，会将任务r添加到任务队列中，如果是第一个任务，则直接调用scheduleNext()从任务队列中取出任务，作为参数调用THREAD_POOL_EXECUTOR的execute()函数执行；Handler是运行在主线程的，因为它是通过getMainLooper()创建的，在主线程进行消息循环，主要作用就是从工作线程切换至主线程，方便主线程通过回调直接更新UI。
- 创建一个AsyncTask子类，无论使用哪个构造函数，最终都会调到带有Looper参数的构造函数，在该构造函数内部，只初始化了两个变量，没有执行具体的任务，首先通过new WorkerRunnable<Params, Result>()初始化了mWorker变量，由于WorkerRunable实现了Callable接口，所以实现其call()函数；然后通过new FutureTask<Result>(mWorker)初始化了mFutue变量，并重写了done()函数，由此可见，创建FutureTask时将mWorker作为参数传入，因为FutureTask实现了RunnableFuture，而RunnableFuture又继承自Runnble，所以WorkRunnable的call()函数就是由FutureTask的run()函数触发的；调用execute(Params... params)传入doInBackground()函数所使用的参数开始执行任务，execute(Params... params)内部会返回executeOnExecutor(sDefaultExecutor, params)；executeOnExecutor(sDefaultExecutor, params)函数会传入默认的线程池，默认的线程池可以通过setDefaultExecutor(Executor exec)函数指定一个自定义的线程池，否则使用的是线程池SERIAL_EXECUTOR，首先该函数内部会判断当前状态，如果不是等待中则抛出异常，否则会先回调onPreExecute()函数，因为doInBackground()函数是在WorkRunnbale的call()函数中执行的，然后将params设置给mWoker.mParams，然后调用exec.execute(mFuture)，若该线程池是SERIAL_EXECUTOR，则按照SERIAL_EXECUTOR的规则去执行任务，若该线程池是自定义的，则按照自定义线程池的规则去执行任务，最后返回this。
- executeOnExecutor(sDefaultExecutor, params)函数内部最终调用了exec.execute(mFuture)，这里只讲默认线程池SERIAL_EXECUTOR，实则是调用了SerialExecutor的execute(Runnable r)函数，首先将当前的mFuture加入到了任务队列，然后从消息队列取出任务通过线程池THREAD_POOL_EXECUTOR去执行具体任务，终于使用到了mFuture，之前说过mWorker的call()函数是在mFuture的run()函数中触发的，没错，call()函数触发了，doInBackground()函数执行了；若在执行过程中调用cancel()取消任务了，则call()函数中会捕获异常，因为调用cancel()取消任务，内部调用的是mFutere.cancel()，最终调用Thread.interrupt()函数，所以通过捕获异常来达到取消任务的目的；若任务执行正常，在doInBackground()函数执行完，会调用postResult(result)返回结果。
- mFuture.done()在什么时候执行呢？在FutureRunnable.finishCompletion()内部执行的；FutureRunnable.finishCompletion()又在什么时候执行呢？线程执行完或者取消线程时执行；现在来看一下done()函数，内部调用了postResultIfNotInvoked(get())，若捕获到了CancellationException异常，则调用postResultIfNotInvoked(null)，postResultIfNotInvoked()函数内部会判断mTaskInvoked的状态是否已经开始执行，若没有开始则调用postResult(result)函数。
网友评论