本文详细解析了Android中AsyncTask的工作原理及执行流程，包括线程池配置、构造函数初始化、execute方法执行过程等关键环节。
首先在AS创建以下示例代码：
new myAsyncTask().execute("testTask");
private class myAsyncTask extends AsyncTask<String, Integer, String> {
//默认的构造函数
public myAsyncTask() {
super();
}
// UI线程
@Override
protected void onPreExecute() {
super.onPreExecute();
}
//子线程
@Override
protected String doInBackground(String... strings) {
return null;
}
//UI线程
@Override
protected void onPostExecute(String s) {
super.onPostExecute(s);
}
}
复制代码开始分析代码整个流程
1、静态代码块初始化参数
// CPU核可用数量
private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
// 核心线程数量：最少2个，最多4个，而且比CPU核数少一个
private static final int CORE_POOL_SIZE = Math.max(2, Math.min(CPU_COUNT - 1, 4));
// 线程池最大数量：CPU*2+1
private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;
// 线程保活时间30s
private static final int KEEP_ALIVE_SECONDS = 30;
// 线程池工作队列，初始化容量128个
private static final BlockingQueue<Runnable> sPoolWorkQueue = new LinkedBlockingQueue<Runnable>(128);
// 线程工厂，创建新线程
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());
}
};
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;
}
复制代码2、默认构造函数初始化
// 通过源码发现，带有参数的构造函数有@hide，所以只能调用无参构造函数
public AsyncTask() {
this((Looper) null);
}
public AsyncTask(@Nullable Looper callbackLooper) {
// 无参构造函数=》 callbackLooper = null
// 所以 mHandler = getMainHandler()=>sHandler;
mHandler = callbackLooper == null || callbackLooper == Looper.getMainLooper()
? getMainHandler()
: new Handler(callbackLooper);
// 创建任务线程
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 {
// ②
// 回调到 sHandler里面的handleMessage()
postResult(result);
}
return result;
}
};
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);
}
}
};
}
//getMainHandler
private static InternalHandler sHandler;
private static Handler getMainHandler() {
synchronized (AsyncTask.class) {
if (sHandler == null) {
// 绑定与主线程关联的Looper对象
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;
}
}
}
//postResult
private Result postResult(Result result) {
@SuppressWarnings("unchecked")
// getHandler() = mHandler = sHandler
Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
new AsyncTaskResult<Result>(this, result));
message.sendToTarget();
return result;
}
private Handler getHandler() {
return mHandler;
}
// postResultIfNotInvoked
// mTaskInvoked在之前设置true，理解是该方法没有被调用
private void postResultIfNotInvoked(Result result) {
final boolean wasTaskInvoked = mTaskInvoked.get();
if (!wasTaskInvoked) {
postResult(result);
}
}
// finish
private void finish(Result result) {
// mCancelled 只有在出现异常和主动取消的时候设置为 mCancelled.set(true);
if (isCancelled()) {
onCancelled(result);
} else {
// 执行结果
onPostExecute(result);
}
// 任务状态变成已完成
mStatus = Status.FINISHED;
}
复制代码3、执行execute()
private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
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() {
// THREAD_POOL_EXECUTOR.execute(mActive);在执行之后
// 任务开始进行，然后从线程池里面取出任务再执行
// 这样就形成任务串行执行
try {
r.run();
} finally {
scheduleNext();
}
}
});
// 当前任务还未有执行任务时，获取任务队列中的任务并执行
if (mActive == null) {
scheduleNext();
}
}
//获取任务队列中队首任务并且执行该任务
protected synchronized void scheduleNext() {
if ((mActive = mTasks.poll()) != null) {
THREAD_POOL_EXECUTOR.execute(mActive);
}
}
}
@MainThread
public final AsyncTask<Params, Progress, Result> execute(Params... params) {
// 默认任务执行器
return executeOnExecutor(sDefaultExecutor, params);
}
public enum Status {
/**
* 任务未被执行
*/
PENDING,
/**
*任务正在运行
*/
RUNNING,
/**
* 任务已完成
*/
FINISHED,
}
@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;
// 可以做一些简单操作：showLoadingDialog，参数初始化等等
onPreExecute();
// mWorker与mFuture在之前的无参构造函数中已经初始化呢
mWorker.mParams = params;
// 调用SerialExecutor.execute()方法
exec.execute(mFuture);
return this;
}
复制代码最后总结一下
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
