特点及注意事项
AsyncTask类必须在主线程中加载。在4.1后,在ActivityThread的main方法中系统会调用AsyncTask的init,用于在主线程中加载该类。 AsyncTask的对象必须在主线程中创建。 execute必须在主线程。 一个AsyncTask对象只能执行一次,即只能调用一次execute方法。 3.0以前,最大支持128个线程的并发,10个任务的等待。在3.0以后,无论有多少任务,都会在其内部单线程执行。 必须在主线程初始化,原因是内部的静态Handler使用的是主线程的Looper,如果不在主线程加载那么就不会把数据发送到主线程来加载。
源码分析
静态成员变量说明
// cpu 数量
private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
// 定义线程池的核心线程数量
private static final int CORE_POOL_SIZE = CPU_COUNT + 1;
// 最大线程数
private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;
// 线程回收时间
private static final int KEEP_ALIVE = 1;
// 线程工厂
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());
}
};
// 任务队列,最大为128个
private static final BlockingQueue<Runnable> sPoolWorkQueue =
new LinkedBlockingQueue<Runnable>(128);
// 定义执行任务的线程池
public static final Executor THREAD_POOL_EXECUTOR
= new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,
TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);
// 任务排队线程池
public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
// 实现Callable 内部有Params
private final WorkerRunnable<Params, Result> mWorker;
// 实现了Runnable
private final FutureTask<Result> mFuture;
private volatile Status mStatus = Status.PENDING;
private final AtomicBoolean mCancelled = new AtomicBoolean();
private final AtomicBoolean mTaskInvoked = new AtomicBoolean();
// 可以看出这是一个穿行线程池,这个线程池用于管理任务
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);
}
}
}
构造方法
public AsyncTask() {
// 初始化Callable
mWorker = new WorkerRunnable<Params, Result>() {
public Result call() throws Exception {
mTaskInvoked.set(true);
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
//noinspection unchecked
// 执行doInbackground讲数据返回,传入postResult()方法中
return postResult(doInBackground(mParams));
}
};
// 把mWroker作为参数初始化FutureTask
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 occured while executing doInBackground()",
e.getCause());
} catch (CancellationException e) {
postResultIfNotInvoked(null);
}
}
};
}
FutureTask 和 Worker关系
// FutureTask 实现了Runnable ,run方法中执行了callable的call方法,在call方法中执行doInBackground方法拿到结果,再执行postResult()
public void run() {
if (state != NEW ||
!UNSAFE.compareAndSwapObject(this, runnerOffset,
null, Thread.currentThread()))
return;
try {
Callable<V> c = callable;
if (c != null && state == NEW) {
V result;
boolean ran;
try {
// 执行callable的call方法
result = c.call();
ran = true;
} catch (Throwable ex) {
result = null;
ran = false;
setException(ex);
}
if (ran)
set(result);
}
} finally {
// runner must be non-null until state is settled to
// prevent concurrent calls to run()
runner = null;
// state must be re-read after nulling runner to prevent
// leaked interrupts
int s = state;
if (s >= INTERRUPTING)
handlePossibleCancellationInterrupt(s);
}
}
postResult()
private Result postResult(Result result) {
@SuppressWarnings("unchecked")
// 发送消息到主线程
Message message = sHandler.obtainMessage(MESSAGE_POST_RESULT,
// 发送的内容在AsyncTaskResult object中
new AsyncTaskResult<Result>(this, result));
message.sendToTarget();
return result;
}
sHandler类如下
private static class InternalHandler extends Handler {
@SuppressWarnings({"unchecked", "RawUseOfParameterizedType"})
@Override
public void handleMessage(Message msg) {
// 取出Object
AsyncTaskResult result = (AsyncTaskResult) msg.obj;
switch (msg.what) {
case MESSAGE_POST_RESULT:
// There is only one result
// 调用AsyncTask的finish
result.mTask.finish(result.mData[0]);
break;
case MESSAGE_POST_PROGRESS:
// 如果我们在doInBackground中调用了publishProgress(Progress...values)方法,就会收到这个消息
result.mTask.onProgressUpdate(result.mData);
break;
}
}
}
finish
private void finish(Result result) {
if (isCancelled()) {
onCancelled(result);
} else {
// 如果没有cancel掉,就回调onPostExecute方法
onPostExecute(result);
}
// 标志位设置为结束
mStatus = Status.FINISHED;
}
publishProgress
protected final void publishProgress(Progress... values) {
if (!isCancelled()) {
// 发送消息到主线程更新进度
sHandler.obtainMessage(MESSAGE_POST_PROGRESS,
new AsyncTaskResult<Progress>(this, values)).sendToTarget();
}
}
execute
public final AsyncTask<Params, Progress, Result> execute(Params... params) {
// 调用了executeOnExecutor,默认是串行的
return executeOnExecutor(sDefaultExecutor, params);
}
public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,
Params... params) {
// 如果mStatus不是准备状态就抛异常
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 , callable的params赋值
mWorker.mParams = params;
// 默认情况下加入穿行线程池sDefaultExecutor去排队执行
exec.execute(mFuture);
return this;
}