- 类的简介
- 示例
- 代码浅析
- 优缺点总结
AsyncTask 支持正确、方便使用UI线程。不必去操作线程或者Handler,就可以把线程任务的结果返回到UI线程中来。注意哦,这里并没有用高并发、异步等词汇。
抽象类AsyncTask
public abstract class AsyncTask<Params, Progress, Result> {
...
@WorkerThread
protected abstract Result doInBackground(Params... params);
...
}
首先AsyncTask是一个抽象类,而且需要确定三个泛型
- Params :数据源,如URL,IO流等。
- Progress:处理的进度,如任务完成百分比等。
- Result:任务处理完成,需要返回的结果类型。如需要返回一个List等。
类中有个抽象方法,doInBackground,运行在后台线程中。根据这个方法我们可以看到和其它方法的一些关系。
我们继承一AsyncTask
public class MyAsyncTask extends AsyncTask<List, Integer, String> {
/**
* 在doInBackground之前调用。运行在UI线程中
* 一般做些初始化操作
*/
@Override
protected void onPreExecute() {
super.onPreExecute();
}
/**
* 具体处理任务的方法,在子线程中运行
*
* @param list
* @return 任务处理完的时候返回的结果
*/
@Override
protected String doInBackground(List... list) {
int length = list.length;
for (int i = 0; i < length; i++) {
List list1 = list[i];
list1.add("你好");
//把当前进度转到onProgressUpdate,UI线程中
publishProgress(list1.size());
}
return "完成喽";
}
/**
* 调用publishProgress之后会调用此方法并。
* 内部是利用Handler进行消息处理,实现回调,并传入参数
* 运行在UI线程中
*
* @param values
*/
@Override
protected void onProgressUpdate(Integer... values) {
super.onProgressUpdate(values);
int length = values.length;
for (int i = 0; i < length; i++) {
Log.i("task", "values: " + values[i] + " i:" + i);
}
}
/**
* 不调用cancel方法并且doInBackground执行完成会回调
* 回调的完成也是通过handler,并传入参数
*
* @param s
*/
@Override
protected void onPostExecute(String s) {
super.onPostExecute(s);
}
/**
* 调用cancel方法并且doInBackground执行完成会回调
* 回调的完成也是通过handler,并传入参数
*
* @param s
*/
@Override
protected void onCancelled(String s) {
super.onCancelled(s);
}
}
//Activity中执行的话
MyAsyncTask myAsyncTask = new MyAsyncTask();
myAsyncTask.execute(new ArrayList());
方法注释的很清楚了。运行起来看log吧,或者可以配合一些控件看看,最适合的就是读写文件的操作,看进度条。而且它里面的调用线程切换基本都是通过handler。毕竟Android里面handler就是专门干这个的。
源码浅析。
先从执行处开始,看看他的execute方法
@MainThread
public final AsyncTask<Params, Progress, Result> execute(Params... params) {
//直接调用了一个需要Execute的参数的方法
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)");
}
}
//状态设置为正在执行
mStatus = Status.RUNNING;
//准备的方法
onPreExecute();
mWorker.mParams = params;
exec.execute(mFuture);
return this;
}
之后,最终会调用传入的Execute的execute方法。
而这个Execute其实是一个内部类SerialExecutor
private static class SerialExecutor implements Executor {
//内部一个Object数组,实现一个队列的效果
final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
Runnable mActive;
public synchronized void execute(final Runnable r) {
//入队一个Runnable,run方法跑的是之前传进去的WorkerRunnable的参数
mTasks.offer(new Runnable() {
public void run() {
try {
//先执行当前run方法
r.run();
} finally {
//再取出队列中的第一个
scheduleNext();
}
}
});
if (mActive == null) {
scheduleNext();
}
}
protected synchronized void scheduleNext() {
//取出队列的第一个Runnable
if ((mActive = mTasks.poll()) != null) {
//AsyncTask内部的线程池,执行Runnable
THREAD_POOL_EXECUTOR.execute(mActive);
}
}
}
我们把数据源交给AsyncTask,然后它通过execute方法最终调用了交给了添加到Runnable中交给线程池处理,但是从代码中可以看出,必须前面一个任务执行完成后,才能执行下一个任务。
既然他是线程切换,肯定少不了handler和runnable实现。这些都在一个构造方法中,看代码:
/**
* Creates a new asynchronous task. This constructor must be invoked on the UI thread.
*
* @hide
*/
public AsyncTask(@Nullable Looper callbackLooper) {
//创建一个handler,有looper就根据looper,没有就默认是UI线程。
mHandler = callbackLooper == null || callbackLooper == Looper.getMainLooper()
? getMainHandler()
: new Handler(callbackLooper);
//创建一个WorkerRunnable,这个也是内部类
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
//调用doInBackground,在线程池中调用
result = doInBackground(mParams);
Binder.flushPendingCommands();
} catch (Throwable tr) {
//关闭
mCancelled.set(true);
throw tr;
} finally {
正常结束
postResult(result);
}
return result;
}
};
//FutureTask,实现了Runnable接口
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);
}
}
};
}
//返回结果
private void postResultIfNotInvoked(Result result) {
final boolean wasTaskInvoked = mTaskInvoked.get();
if (!wasTaskInvoked) {
//最终利用handler
postResult(result);
}
}
//
private Result postResult(Result result) {
@SuppressWarnings("unchecked")
Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
new AsyncTaskResult<Result>(this, result));
message.sendToTarget();
return result;
}
//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;
}
}
}
当然,我们只能调用无参构造方法,另外两个都被/**@hide*/了线程池处理任务,handler负责线程间通信。
总结
- 优点:
- AsyncTask 通过线程池和handler,帮我们封装好了子线程处理任务到UI线程的返回过程。
- 五个方法
onPreExecute:开启任务线程前执行。运行在UI线程
doInBackground:任务线程中执行,运行中任务线程。
publishProgress:在doInBackground调用,把任务进度传递到UI线程。如果被关闭的话不再回调onProgressUpdate。
onProgressUpdate:调用publishProgress,并且没有被关闭的情况下执行,运行在UI线程。
onPostExecute:没有调用cancel方法并且doInBackground执行完成会回调,运行在UI线程。
onCancelled:调用cancel方法并且doInBackground执行完成会回调,运行在UI线程。
publishProgress:
@WorkerThread
protected final void publishProgress(Progress... values) {
//没有关闭发送MESSAGE_POST_PROGRESS
if (!isCancelled()) {
getHandler().obtainMessage(MESSAGE_POST_PROGRESS,
new AsyncTaskResult<Progress>(this, values)).sendToTarget();
}
}
finish:
private void finish(Result result) {
if (isCancelled()) {
//关闭后的回调
onCancelled(result);
} else {
//没有关闭的回调
onPostExecute(result);
}
mStatus = Status.FINISHED;
}
- 可能你会有疑问,AsyncTask只能调用一次execute方法,那还要线程池干嘛呢?
其实这个只能调用一次execute,是针对AsyncTask对象的。我们可以多new一些对象。而线程池是静态的。
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);
//静态Executor持有线程池的引用
THREAD_POOL_EXECUTOR = threadPoolExecutor;
}
- 缺点
现在我们在doInBackground中添加如下代码
@Override
protected String doInBackground(List... list) {
StringBuffer stringBuffer = new StringBuffer();
for (int i = 0; i < 5; i++) {
String s = "i: " + i + " threadName: " + Thread.currentThread().getName();
stringBuffer.append(s + "\n");
publishProgress(s);
}
return stringBuffer.toString();
}
写一个5次循环,i++,打印i值和线程名字,并把字符串传递出去
@Override
protected void onProgressUpdate(String... values) {
super.onProgressUpdate(values);
int length = values.length;
for (int i = 0; i < length; i++) {
Log.i("task", values[i]);
}
}
onProgressUpdate打印接收到的内容,执行五个任务。看下结果,如图:
不看不知道一看吓一跳,有木有。虽然创建了五个线程,但是线程是按顺序执行的,并不是并发执行的。
原因就在于AsyncTask默认的任务加入线程池的方式是串行的方式加入的,也就是内部类SerialExecutor,前面有提到
public synchronized void execute(final Runnable r) {
//入队一个Runnable,run方法跑的是之前传进去的WorkerRunnable的参数
mTasks.offer(new Runnable() {
public void run() {
try {
//先执行当前run方法
r.run();
} finally {
//再取出队列中的第一个
scheduleNext();
}
}
});
if (mActive == null) {
scheduleNext();
}
}
如果要改变的话,只能修改Executor了,但是…
/** @hide */
public static void setDefaultExecutor(Executor exec) {
sDefaultExecutor = exec;
}
修改的方法又被隐藏了,外界无法调用。但是我们还有一个executeOnExecutor:
并发执行
public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,
Params... params) {}
该方法多接收了一个Executor对象。咱们传入一个线程池就行。这样就是并行了。
new MyAsyncTask().executeOnExecutor(THREAD_POOL_EXECUTOR, new ArrayList());
07-11 16:24:28.907 2050-2050/com.example.study I/task: i: 0 threadName: AsyncTask #1
07-11 16:24:28.907 2050-2050/com.example.study I/task: i: 1 threadName: AsyncTask #1
07-11 16:24:28.907 2050-2050/com.example.study I/task: i: 2 threadName: AsyncTask #1
07-11 16:24:28.907 2050-2050/com.example.study I/task: i: 3 threadName: AsyncTask #1
07-11 16:24:28.907 2050-2050/com.example.study I/task: i: 4 threadName: AsyncTask #1
07-11 16:24:28.907 2050-2050/com.example.study I/task: i: 0 threadName: AsyncTask #6
07-11 16:24:28.907 2050-2050/com.example.study I/task: i: 1 threadName: AsyncTask #6
07-11 16:24:28.907 2050-2050/com.example.study I/task: i: 0 threadName: AsyncTask #1
07-11 16:24:28.907 2050-2050/com.example.study I/task: i: 2 threadName: AsyncTask #6
07-11 16:24:28.907 2050-2050/com.example.study I/task: i: 1 threadName: AsyncTask #1
07-11 16:24:28.907 2050-2050/com.example.study I/task: i: 3 threadName: AsyncTask #6
07-11 16:24:28.907 2050-2050/com.example.study I/task: i: 0 threadName: AsyncTask #2
07-11 16:24:28.907 2050-2050/com.example.study I/task: i: 4 threadName: AsyncTask #6
07-11 16:24:28.907 2050-2050/com.example.study I/task: i: 1 threadName: AsyncTask #2
07-11 16:24:28.907 2050-2050/com.example.study I/task: i: 2 threadName: AsyncTask #2
07-11 16:24:28.907 2050-2050/com.example.study I/task: i: 3 threadName: AsyncTask #2
07-11 16:24:28.907 2050-2050/com.example.study I/task: i: 4 threadName: AsyncTask #2
07-11 16:24:28.917 2050-2050/com.example.study I/task: i: 2 threadName: AsyncTask #1
07-11 16:24:28.917 2050-2050/com.example.study I/task: i: 3 threadName: AsyncTask #1
07-11 16:24:28.917 2050-2050/com.example.study I/task: i: 4 threadName: AsyncTask #1
07-11 16:24:28.917 2050-2050/com.example.study I/task: i: 0 threadName: AsyncTask #7
07-11 16:24:28.917 2050-2050/com.example.study I/task: i: 1 threadName: AsyncTask #7
07-11 16:24:28.917 2050-2050/com.example.study I/task: i: 2 threadName: AsyncTask #7
07-11 16:24:28.917 2050-2050/com.example.study I/task: i: 3 threadName: AsyncTask #7
07-11 16:24:28.917 2050-2050/com.example.study I/task: i: 4 threadName: AsyncTask #7
所以:
- AsyncTask的任务执行是并行和串行根据自己选择。
- 串行的时候,所以无法进行太耗时的操作,如图片加载库等。