如果在一个进程中,频繁创建和销毁线程,显然不是高效的做法。正确的做法是采用线程池,一个线程池中会缓存一定数量的线程,通过线程池可以避免因为频繁创建和销毁线程所带来的消耗。
1.AsyncTask简介
Asynctask是一个抽象类,它是Android封装的一个轻量级异步类(轻量级体现在使用方便,代码简洁),它可以在线程池中执行后台任务,然后把执行的进度和最终的结果呈现给主线程,并且更新UI。
Asynctask内部封装了两个线程池(SerialExecutor
和THREAD_POOL_EXECUTOR
),和一个Handler(IntentHandler)
。
- SerialExecutor线程池用于任务的排队,让需要执行的多个耗时任务按顺序排列。
- THREAD_POOL_EXECUTOR线程池才真正执行任务。
- IntentHandler用于从工作线程切换到主线程
1.1 AsyncTask的泛型参数
AsyncTask的类型声明:
public abstract class AsyncTask {}
AsyncTask是一个抽象的泛型类。
- Params: 开始异步任务执行时传入的参数类型。
- Progress:异步任务执行过程中,返回下载进度值的类型。
- Result: 异步任务执行完成,返回的结果类型。
如果AsyncTask确定不需要传递具体参数,那么这三个泛型参数可以用Void来代替。
1.2 AsyncTask的核心方法
- onPreExecute()(主线程中执行):这个方法会在后台任务开始执行前调用,在主线程执行。用于进行一些界面上的初始化操作,比如显示一个对话框列表什么的。
- doInBackground(Params...)(子线程中执行): 这个方法在子线程中执行,负责处理耗时操作。
任务一旦完成就可以通过return语句来将任务的执行结果进行返回,如果AsyncTask的第三个参数指定的是Void,就可以不返回执行结果。如果要更新UI,可以通过调用publishProgress(Progess...)方法来完成比如反馈当前的进度。 - onProgressUpdate(Progress...)(主线程中执行):当在后台进程中调用publishProgress(Progress...)方法后,这个方法就会被调用,方法中携带的参数就是后台任务中传递过来的。在这个方法中可以对UI进行更新操作。
- onPostExecute(Result)(主线程中执行):当doInBackground(Params...)执行完毕并通过return语句进行返回时,这个方法就很快会被调用。返回的数据会作为参数传递到这个方法里面。利用参数的数据,就可以进行UI的修改。
上面几个方法的调用顺序:onPreExcute() --> doInBackground() --> publishProgress() --> onProgressUpdate() --> onPostExcute()
如果不需要执行更新UI操作,顺序是:onPreExcute() --> doInBackground() --> onPostExcute()。
- onCancelled()(主线程中执行):该方法被调用,onPostExecute()方法将不会被执行,需要注意的是,AsncTask中的cancel()不是真正的取消任务,只是将任务标记为取消状态,我们需要在doInBackground()内判断终止任务。就好比想要终止一个线程,调用interrupt()方法,只是进行标记为中断,需要在线程内部进行标记判断,然后中断线程。
1.3 AsyncTask的简单使用
public class DownloadTask extends AsyncTask {
@Override
protected void onPreExecute() {
progressDialog.show();
}
@Override
protected Boolean doInBackground(Void... voids) {
try {
while (true) {
int downloadPercent = doDownload();
publishProgress(downloadPercent);
if (downloadPercent >= 100) {
break;
}
}
} catch (Exception e) {
return false;
}
return true;
}
@Override
protected void onProgressUpdate(Integer... values) {
progressDialog.setMessage("当前下载进度: " + values[0] + "%");
}
@Override
protected void onPostExecute(Boolean result) {
progressDialog.dismiss();
if (result) {
Toast.makeText(context, "下载成功", Toast.LENGTH_SHORT).show();
} else {
Toast.makeText(context, "下载失败", Toast.LENGTH_SHORT).show();
}
}
}
这里模拟了一个下载任务,在doInBackground方法中,去执行具体的下载逻辑,在onProgressUpdate()方法中显示下载的进度。在onPostExecute()方法中提示下载任务的结果。
调用方法:
new DownloadTask().execute();
1.4 使用AsyncTask的注意事项
-
- 异步任务的实例必须在UI线程中创建,即AsynacTask对象必须在UI线程中创建。
-
- execute(Params... params)必须在UI线程中调用。
-
- 不要手动调用onPreExecute(),doInBackground(),onProgressUpdate(),onPostExecute()这几个方法。
-
- 不能在doInBackground()中更改UI组件的信息。
-
- 一个任务实例只能执行一次,如果执行第二次会抛出异常。
2.AsyncTask的源码分析
AsyncTask的构造函数:
public AsyncTask() { this((Looper) null); }
public AsyncTask(@Nullable Looper callbackLooper) {
mHandler = callbackLooper == null || callbackLooper == Looper.getMainLooper()
? getMainHandler()
: new Handler(callbackLooper);
mWorker = new WorkerRunnable() {
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;
}
};
mFuture = new FutureTask(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);
}
}
};
}
在构造函数中,主要是初始化了3个成员变量, mHandler,mWorker,mFuture。并在初始化mFutrue的时候,mWorker作为参数传入。 mWorker是一个Callable对象,mFuture是以一个FutureTask对象。FutureTask实现了Runnable接口。
mWorker中的call()方法执行了耗时操作,即result = doInBackground(mParams);,然后把得到的结果通过postResult(result);传递给内部的Handler跳转到主线程中。这里实际是在实例化变量,并没有开启执行任务。
postResult()方法源码:
private Result postResult(Result result) {
@SuppressWarnings("unchecked")
Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
new AsyncTaskResult(this, result));
message.sendToTarget();
return result;
}
mFuture对象被加载线程池中,并加载的过程。
new DownloadTask().execute();
其中execute()就是执行了这一操作。
execute()源码:
public final AsyncTask execute(Params... params) {
return executeOnExecutor(sDefaultExecutor, params);
}
@MainThread
public final AsyncTask executeOnExecutor(Executor exec,
Params... params) {
mStatus = Status.RUNNING;
onPreExecute();
mWorker.mParams = params;
exec.execute(mFuture);
return this;
}
可以看出,execute()
方法,实际上是执行了executeOnExecutor()
方法,先执行了onPreExecute(),然后具体执行耗时任务是 exec.execute(mFuture);
。对象exec是sDefaultExecutor,往上追溯就是SerialExecutor的实例化对象。
private static class SerialExecutor implements Executor {
final ArrayDeque mTasks = new ArrayDeque();
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);
}
}
}
SerialExecutor
是个内部静态内部类,是所有实例化的AsyncTask
对象共有的SerialExecutor
,内部维护了一个队列,通过锁使得保证AsyncTask
中的任务是串行执行的,即多个任务需要一个个加到该队列中。
这个方法中主要有两个步骤。
-
- 向队列中加入一个新的任务,即之前实例化的mFuture对象。
- 2.调用
scheduleNext()
,调用THREAD_POOL_EXECUTOR
执行队列头部任务。
由此可以知道SerialExecutor
仅仅是为了保持任务执行队列是串行的实际执行交给了THREAD_POOL_EXECUTOR
。
THREAD_POOL_EXECUTOR源码:
public static final Executor THREAD_POOL_EXECUTOR;
static {
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE_SECONDS, TimeUnit.SECONDS,
new SynchronousQueue(), sThreadFactory);
threadPoolExecutor.setRejectedExecutionHandler(sRunOnSerialPolicy);
THREAD_POOL_EXECUTOR = threadPoolExecutor;
}
实际上就是个线程池,开启了一定数量的核心线程和工作线程。然后调用线程池的execute()方法,执行具体的耗时任务,即开头构造函数mWorker
中的call()方法。先执行doInBackground()方法,然后再执行postResult()方法。
在postResult()方法中,向在AsyncTask
构造函数中初始化的mHandler发送了一个消息。
在构造函数中通过调用getMainHandler(),实例化mHandler的源码:
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;
}
}
}
在InternalHandler
中,
- 如果收到的消息是
MESSAGE_POST_PROGRESS
, 回调onProgressUpdate()方法, 更新进度。 - 如果收到的消息是
MESSAGE_POST_RESULT
,即执行完了doInBackground()方法并传递结果,那就调用AsyncTask.finish()方法。
private void finish(Result result) {
if (isCancelled()) {
onCancelled(result);
} else {
onPostExecute(result);
}
mStatus = Status.FINISHED;
}
如果任务已经取消了,就回调onCancelled()方法,否则就回调onPostExecute()方法。
InternalHandler
是一个静态类, 为了能够将执行环境切换到主线程, 因此这个类必须在主线程中进行加载。 所以变相要求AsyncTask的类必须在主线程中进行加载。到此为止, 从任务执行的开始到结束都从源码分析完了。
AsyncTask的串行和并行:
默认情况下因为有SerialExecutor
类来维持保证队列的串行。如果想要使用并行执行任务,那么可以直接跳过SerialExecutor
类,使用executeOnExecutor()来执行任务。
3. AsyncTask使用不当的后果
- 1)生命周期
AsyncTask不与任何组件绑定生命周期,所以在Activity或Fragment中创建执行AsyncTask时候,最好在Activity/Fragment的onDestroy()方法中调用cancle(boolean)方法。 - 2)内存泄漏
如果AsyncTask被声明为Activity的非静态的内部类,那么AsyncTask会保留一个对创建了AsyncTask的Activity引用。如果Activity已经被销毁,AsyncTask的后台线程还在执行,它将继续在内存中保存这个引用,导致Activity无法被回收,导致内存泄漏。 - 3)结构丢失
屏幕旋转或者Activity在后台被系统杀死等情况会导致Activity的重新创建,之前运行的AsyncTask(非内部静态类)会持有之前的Activity的引用,这个引用已经无效,这时调用onPostExecute()再去更新界面将不会再生效。