AsyncTask介绍
首先从Android3.0开始,系统要求网络访问必须在子线程中进行,否则网络访问将会失败并抛出NetworkOnMainThreadException
这个异常,这样做是为了避免主线程由于耗时操作所阻塞从而出现ANR现象。
AsyncTask封装了线程池和Handler。简化了异步任务的开发。
一般使用步骤
1.自定义类继承 AsyncTask,例如下面的代码。
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");
}
}
2.执行请求
new DownloadFilesTask().execute(url1, url2, url3);//传递变长参数
AsyncTask 源码分析
AsyncTask 源码如下,基于Andorid-21版本,为了便于理解,加入了较为详细的注释:
package android.os;
import java.util.ArrayDeque;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.Callable;
import java.util.concurrent.CancellationException;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;
public abstract class AsyncTask<Params, Progress, Result> {
private static final String LOG_TAG = "AsyncTask";
//CPU核心数量
private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
//核心线程数CPU核心数+1
private static final int CORE_POOL_SIZE = CPU_COUNT + 1;
//最大线程数CPU核心数的2倍+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);
//串行的线程池,一个进程中所有的AsyncTask全部在这个串行的线程池中排队执行
public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
//用于handler 处理的msg.what 分支变量
private static final int MESSAGE_POST_RESULT = 0x1;
private static final int MESSAGE_POST_PROGRESS = 0x2;
//内部的handler
private static final InternalHandler sHandler = new InternalHandler();
//任务排队线程池,默认串行化执行
private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
//
private final WorkerRunnable<Params, Result> mWorker;
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 enum Status {
//任务尚未执行
PENDING,
//任务正在运行
RUNNING,
//任务完成
FINISHED,
}
//初始化方法,获取sHandler关联的Looper
public static void init() {
sHandler.getLooper();
}
//设置默认的排队线程池
public static void setDefaultExecutor(Executor exec) {
sDefaultExecutor = exec;
}
//无参构造函数,创建一个新的异步任务,应该在UI线程中调用
public AsyncTask() {
//初始化mWorker
mWorker = new WorkerRunnable<Params, Result>() {
public Result call() throws Exception {
//设置任务被调用状态为true
mTaskInvoked.set(true);
//设置线程优先级为后台线程 Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
//noinspection unchecked
return postResult(doInBackground(mParams));
}
};
//初始化futureTask对象
mFuture = new FutureTask<Result>(mWorker) {
//执行完毕后,传递结果,用于doInbackground方法返回Result
@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);
}
}
};
}
//如果尚未被调用则开始调用
private void postResultIfNotInvoked(Result result) {
final boolean wasTaskInvoked = mTaskInvoked.get();
if (!wasTaskInvoked) {
postResult(result);
}
}
//将Result结果封装成Message对象发送至Handler用于后续任务处理
private Result postResult(Result result) {
@SuppressWarnings("unchecked")
Message message = sHandler.obtainMessage(MESSAGE_POST_RESULT,
new AsyncTaskResult<Result>(this, result));
message.sendToTarget();
return result;
}
//返回任务执行状态
public final Status getStatus() {
return mStatus;
}
//doInBackground,后台执行任务
protected abstract Result doInBackground(Params... params);
//运行在UI线程,在doInBackground之前执行
protected void onPreExecute() {
}
//运行在UI线程,在doInBackground执行完后调用
@SuppressWarnings({"UnusedDeclaration"})
protected void onPostExecute(Result result) {
}
//运行在UI线程,当后台任务的执行进度发生改变时此方法将会被调用
@SuppressWarnings({"UnusedDeclaration"})
protected void onProgressUpdate(Progress... values) {
}
//在任务被取消时调用
@SuppressWarnings({"UnusedParameters"})
protected void onCancelled(Result result) {
onCancelled();
}
//任务取消时被调用
protected void onCancelled() {
}
//返回任务是否被取消
public final boolean isCancelled() {
return mCancelled.get();
}
/**
* 试图取消对此任务的执行。如果任务已完成、或已取消,或者由于某些其他原因而无法取消,则此尝试将失败。当调用 cancel 时,如果调用成功,而此任务尚未启动,则此任务将永不运行。如果任务已经启动,则 mayInterruptIfRunning 参数确定是否应该以试图停止任务的方式来中断执行此任务的线程。
此方法返回后,对 Future.isDone() 的后续调用将始终返回 true。如果此方法返回 true,则对 Future.isCancelled() 的后续调用将始终返回 true。
*/
public final boolean cancel(boolean mayInterruptIfRunning) {
//取消标志设为true
mCancelled.set(true);
return mFuture.cancel(mayInterruptIfRunning);
}
//取得执行结果
public final Result get() throws InterruptedException, ExecutionException {
return mFuture.get();
}
//如有必要,最多等待timeout时间长后取得结果
public final Result get(long timeout, TimeUnit unit) throws InterruptedException,
ExecutionException, TimeoutException {
return mFuture.get(timeout, unit);
}
//执行入口函数
public final AsyncTask<Params, Progress, Result> execute(Params... params) {
return executeOnExecutor(sDefaultExecutor, params);
}
//默认串行执行
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
onPreExecute();
mWorker.mParams = params;
exec.execute(mFuture);
return this;
}
//执行方法
public static void execute(Runnable runnable) {
sDefaultExecutor.execute(runnable);
}
//在doInBackground方法中被调用,
protected final void publishProgress(Progress... values) {
if (!isCancelled()) {
sHandler.obtainMessage(MESSAGE_POST_PROGRESS,
new AsyncTaskResult<Progress>(this, values)).sendToTarget();
}
}
//finish方法,如果任务被取消,调用onCancelled(result),
//否则回调onPostExecute(result)方法
private void finish(Result result) {
if (isCancelled()) {
onCancelled(result);
} else {
onPostExecute(result);
}
mStatus = Status.FINISHED;
}
//内部私有静态类InternalHandler用于接受子线程发送的数据, 并用此数据配合主线程更新UI。
private static class InternalHandler extends Handler {
@SuppressWarnings({"unchecked", "RawUseOfParameterizedType"})
@Override
public void handleMessage(Message msg) {
AsyncTaskResult result = (AsyncTaskResult) msg.obj;
switch (msg.what) {
case MESSAGE_POST_RESULT:
//回调finish方法
result.mTask.finish(result.mData[0]);
break;
case MESSAGE_POST_PROGRESS:
//回调onProgressUpdate方法
result.mTask.onProgressUpdate(result.mData);
break;
}
}
}
private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {
Params[] mParams;
}
@SuppressWarnings({"RawUseOfParameterizedType"})
private static class AsyncTaskResult<Data> {
final AsyncTask mTask;
final Data[] mData;
AsyncTaskResult(AsyncTask task, Data... data) {
mTask = task;
mData = data;
}
}
}
重点说明
AsyncTask涉及的线程池
AsyncTask有两个线程池:SerialExecutor
和THREAD_POOL_EXECUTOR
。
前者是用于任务的排队,默认是串行的线程池:后者用于真正的执行任务。AsyncTask还有一个Handler,叫InternalHandler,用于将执行环境从线程池切换到主线程。AsyncTask内部就是通过InternalHandler来发送任务执行的进度以及执行结束等消息。
AsyncTask排队执行过程
AsyncTask排队执行过程:系统先把参数Params封装为FutureTask对象,它相当于Runnable,接着FutureTask交给SerialExcutor的execute方法,它先把FutureTask插入到任务队列tasks中,如果这个时候没有正在活动的AsyncTask任务,那么就会执行下一个AsyncTask任务,同时当一个AsyncTask任务执行完毕之后,AsyncTask会继续执行其他任务直到所有任务都被执行为止。
线程池特别说明
关于线程池,AsyncTask对应的线程池ThreadPoolExecutor都是进程范围内共享的,都是static的,所以是AsyncTask控制着进程范围内所有的子类实例。由于这个限制的存在,当使用默认线程池时,如果线程数超过线程池的最大容量,线程池就会爆掉(3.0默认串行执行,不会出现这个问题)。针对这种情况。可以尝试自定义线程池,配合AsyncTask使用。