Android AsyncTask实现机制详细介绍及实例代码

Android AsyncTask实现机制
示例代码：

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（）;mWorker.mParams = params;exec.execute（mFuture）;return this;}

execute先调用onPreExecute（）（可见，onPreExecute是自动调用的）然后调用exec.execute（mFuture）

 public interface Executor {void execute（Runnable command）;}

这是一个接口，具体实现在

 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）;}}}

从上面可知，AsyncTask执行过程如下：先执行onPreExecute，然后交给SerialExecutor执行。在SerialExecutor中，先把Runnable添加到mTasks中。

如果没有Runnable正在执行，那么就调用SerialExecutor的scheduleNext。同时当一个Runnable执行完以后，继续执行下一个任务
AsyncTask中有两个线程池，THREAD_POOL_EXECUTOR和SERIAL_EXECUTOR，以及一个Handler–InternalHandler

 /** * An {@link Executor} that can be used to execute tasks in parallel. */public static final Executor THREAD_POOL_EXECUTOR= new ThreadPoolExecutor（CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory）;/** * An {@link Executor} that executes tasks one at a time in serial * order. This serialization is global to a particular process. */public static final Executor SERIAL_EXECUTOR = new SerialExecutor（）;private static InternalHandler sHandler;

SERIAL_EXECUTOR用于任务的排列，THREAD_POOL_EXECUTOR真正执行线程，InternalHandler用于线程切换
先看构造函数

public AsyncTask（） {mWorker = new WorkerRunnable<Params, Result>（） {public Result call（） throws Exception {mTaskInvoked.set（true）;Process.setThreadPriority（Process.THREAD_PRIORITY_BACKGROUND）;//noinspection uncheckedreturn postResult（doInBackground（mParams））;}};mFuture = new FutureTask<Result>（mWorker） {@Overrideprotected 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）;}}};}

看到了熟悉的doInBackground了吧，然后调用postResult

 private Result postResult（Result result） {@SuppressWarnings（"unchecked"）Message message = getHandler（）.obtainMessage（MESSAGE_POST_RESULT,new AsyncTaskResult<Result>（this, result））;message.sendToTarget（）;return result;}

主线程中创建InternalHandler并发送MESSAGE_POST_RESULT消息，然后调用finish函数

 private static class InternalHandler extends Handler {public InternalHandler（） {super（Looper.getMainLooper（））;}@SuppressWarnings（{"unchecked", "RawUseOfParameterizedType"}）@Overridepublic void handleMessage（Message msg） {AsyncTaskResult<?> result = （AsyncTaskResult<?>） msg.obj;switch （msg.what） {case MESSAGE_POST_RESULT:// There is only one resultresult.mTask.finish（result.mData[0]）;break;case MESSAGE_POST_PROGRESS:result.mTask.onProgressUpdate（result.mData）;break;}}}private void finish（Result result） {if （isCancelled（）） {onCancelled（result）;} else {onPostExecute（result）;}mStatus = Status.FINISHED;}

finish中调用onPostExecute。
AsyncTask工作流程：new MyThread（）.execute（1）;

先构造函数，然后execute
构造函数只是准备了mWorker和mFuture这两个变量

execute中调用onPreExecute，然后exec.execute（mFuture），其中响应了call函数，call中调用doInBackground，然后将结果传给Handler然后finish掉，finish函数调用onPostExecute

你可能会奇怪，为什么没有onProgressUpdate，有注解可以解释

 /** * Runs on the UI thread after {@link #publishProgress} is invoked. * The specified values are the values passed to {@link #publishProgress}. * * @param values The values indicating progress. * * @see #publishProgress * @see #doInBackground */@SuppressWarnings（{"UnusedDeclaration"}）protected void onProgressUpdate（Progress... values） {}

也就是说必须调用publishProgress才会自动调用onProgressUpdate。
那如何调用publishProgress呢？

 /** * Override this method to perform a computation on a background thread. The * specified parameters are the parameters passed to {@link #execute} * by the caller of this task. * * This method can call {@link #publishProgress} to publish updates * on the UI thread. * * @param params The parameters of the task. * * @return A result, defined by the subclass of this task. * * @see #onPreExecute（） * @see #onPostExecute * @see #publishProgress */protected abstract Result doInBackground（Params... params）;

doInBackground说的很明确，在doInBackground函数里面显示调用publishProgress即可。

publishProgress源码：

 protected final void publishProgress（Progress... values） {if （！isCancelled（）） {getHandler（）.obtainMessage（MESSAGE_POST_PROGRESS,new AsyncTaskResult<Progress>（this, values））.sendToTarget（）;}}private static class InternalHandler extends Handler {public InternalHandler（） {super（Looper.getMainLooper（））;}@SuppressWarnings（{"unchecked", "RawUseOfParameterizedType"}）@Overridepublic void handleMessage（Message msg） {AsyncTaskResult<?> result = （AsyncTaskResult<?>） msg.obj;switch （msg.what） {case MESSAGE_POST_RESULT:// There is only one resultresult.mTask.finish（result.mData[0]）;break;case MESSAGE_POST_PROGRESS://****************************************在这里调用result.mTask.onProgressUpdate（result.mData）;break;}}}

感谢阅读，希望能帮助到大家，谢谢大家对本站的支持！