AsyncTask底层实现
1.了解AsyncTask
onPreExecute() :任务执行之前,做一些准备工作,运行于主线程,比如弹出一个进度条
doInBackground(Params…):异步任务开始在这里执行,运行与子线程
progressUpdate(Progress):主动调用,用于更新进度
onProgressUpdate(Progress…):显示任务执行的进度,运行于主线程
onPostExecute(Result):异步任务执行完毕,调用,运行于主线程
onCancel():调用cancel()取消时,会回调该方法
2.源码解析
观看顺序:构造器->调用的地方execute()->调用逻辑
public AsyncTask() { mWorker = new WorkerRunnable<Params, Result>() { public Result call() throws Exception { mTaskInvoked.set(true); Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND); //noinspection unchecked Result result = doInBackground(mParams); Binder.flushPendingCommands(); return postResult(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); } } }; }
构造器中初始化了一个WorkerRunnable(mWorker)和FutureTask(mFuture)对象,来看看mWorker
private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> { Params[] mParams; }
可以看出,其实是一个实现了Callable的抽象类,里面是我们传入的参数AsyncTask<Params,...>
接下来看一下execute()方法
@MainThread public final AsyncTask<Params, Progress, Result> execute(Params... params) { return executeOnExecutor(sDefaultExecutor, params); }
里面调用了executeOnExecutor()方法,首先看一下sDefaultExecutor
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() { try { r.run(); } finally { scheduleNext(); } } }); if (mActive == null) { scheduleNext(); } } protected synchronized void scheduleNext() { if ((mActive = mTasks.poll()) != null) { THREAD_POOL_EXECUTOR.execute(mActive); } } }
数组队列mTasks调用offer()方法,在末尾插入了一个Runnable对象,在try中调用了参数r.run(),在finally中调用了scheduleNext()方法,第一次调用execute()方法,mActive为null,所以会调用scheduleNext()方法,
public static final Executor THREAD_POOL_EXECUTOR = new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE, TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);
THREAD_POLL_EXECUTOR是一个线程池,调用它的execute()方法,线程正式开始执行
让我们回到构造方法
public AsyncTask() { mWorker = new WorkerRunnable<Params, Result>() { public Result call() throws Exception { mTaskInvoked.set(true); Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND); //noinspection unchecked Result result = doInBackground(mParams); Binder.flushPendingCommands(); return postResult(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); } } }; }
线程开始执行,会调用call()方法,接着
private final AtomicBoolean mTaskInvoked = new AtomicBoolean();
mTaskInvoked.set(true);
然后调用doInBackgound(),开始处理子线程的任务,当执行完毕,调用postResult()
private Result postResult(Result result) { @SuppressWarnings("unchecked") Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT, new AsyncTaskResult<Result>(this, result)); message.sendToTarget(); return result; }
getHandler()获取内部的一个Handler对象
private static Handler getHandler() { synchronized (AsyncTask.class) { if (sHandler == null) { sHandler = new InternalHandler(); } return sHandler; } }
private static class InternalHandler extends Handler { public InternalHandler() { super(Looper.getMainLooper()); } @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; } } }
message.sendToTarget()是Message的一个方法
public void sendToTarget() { target.sendMessage(this); }
target是一个Message内部的Handler对象,其实指的是InternalHanlder
接着看InternalHanlder中的handleMessage()方法
@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; } }
doInBackground()方法执行完毕,发送了MESSAGE_POST_RESULT的消息,然后handler收到就会调用handleMessage()方法,走到result.mTask.finish()方法,看一下AsyncTaskResult
private static class AsyncTaskResult<Data> { final AsyncTask mTask; final Data[] mData; AsyncTaskResult(AsyncTask task, Data... data) { mTask = task; mData = data; } }
可以知道,msg.obj是一个AsyncTaskResult对象
result.mTask.finish()其实调用的就是该AsyncTask的finish()方法
private void finish(Result result) { if (isCancelled()) { onCancelled(result); } else { onPostExecute(result); } mStatus = Status.FINISHED; }
看一下isCancelled
public final boolean isCancelled() { return mCancelled.get(); }
private final AtomicBoolean mCancelled = new AtomicBoolean();
public final boolean cancel(boolean mayInterruptIfRunning) { mCancelled.set(true); return mFuture.cancel(mayInterruptIfRunning); }
如果主动调用AsyncTask的cancle()方法,那么mCancelled就置为true,所以在finish()中会走onCancel()方法,否则调用onpostExecute()
@MainThread protected void onPostExecute(Result result) { }
接着看publishProgress(Progress),主要在doInBackground()中,用于更新进度等
@WorkerThread protected final void publishProgress(Progress... values) { if (!isCancelled()) { getHandler().obtainMessage(MESSAGE_POST_PROGRESS, new AsyncTaskResult<Progress>(this, values)).sendToTarget(); } }之后会调用handleMessage中的onProgressUpdate()
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; } }整个过程就比较清楚了