AsyncTask源码分析

一、简介
    AsyncTask允许你执行后台耗时操作，并将结果发布到UI线程。整个实现过程不需要多个Thread或者Handler。
    AsyncTask是被设计来替代Handler与Thread组合的一种方式，它不需要构建通用的线程框架。
    AsyncTask理想的情况下是用来执行短时间的操作，例如几秒种操作。如果需要执行一些长时间的耗时操作，推荐使用并发执行框架，例如Executor框架和ThreadPoolExecutor以及FutureTask。
    一个异步任务主要是在后台执行计算操作，并把计算结果发布到UI线程。一个异步任务主要通过三种类型参数：Params、Progress、Result和4步操作：onPreExecute()、doInBackground()、onProgressUpdate()、onPreExecute()来定义的。
    AsyncTask必须被子类化才能使用，并且必须覆写doInBackground()方法。通常的情况下，还可以覆写onPreExecute(）方法。

    这里有个一AsyncTask的使用示例：

private class DownloadFileTask extends AsyncTask<URL,Integer,Long>{@Overrideprotected 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));if (isCancelled()){break;}}return totalSize;}@Overrideprotected void onProgressUpdate(Integer... progress) {setProgress(progress[0]);}@Overrideprotected void onPostExecute(Long result) {showDialog("DownLoaded" + result + " tytes");}}

一旦一个AsyncTask被创建完之后，任务执行很简单，只需调用new DownloadFileTask().execute(url1,url2,url3)方法就可以开始执行任务。

AsyncTask包含三种类型的参数：

Param参数：发送给任务执行的参数类型；

Progress参数：在后台计算时，显示任务处理的进度单元；

Result参数：后台计算出结果的参数类型；

上面的三个参数并不是每个参数都被使用，当不需要使用时，可以简单声明为一个Void类型。例如AsyncTask<Void，Void，Void>。

当异步任务AsyncTask执行时，将会经历以下4步：

1.onPreExecute();该方法在UI线程被触发执行，该方法经常被用来做一些初始化操作，初始化任务执行，例如初始化一个进度条。

2.doInBackground();该方法在子线程中执行，在执行完onPreExecute方法之后，就开始执行该方法。该方法用来执行后台耗时的操作，参数是通过AsyncTask传递进来，并且该方法将计算结果返回给onPostExecute方法，做后续的进一步处理。在该方法中，还可以调用publishProcess方法将该任务执行的进度发布的UI线程中。publishProcess方法将任务执行结果发送到onProgressUpdate方法中，用来更新UI任务执行的进度。

3.onProgressUpdate();该方法在UI线程中执行，在调用publishProcess方法后，将触发该方法在UI线程中执行。该方法主要用来显示任务执行的进度。

4.onPostExecute();该方法在UI线程中执行，当后台任务执行完成后，将调用该方法。doInBackground方法返回的结果将作为该函数的参数传递给该函数处理。

任务的取消

    一个任务可以在任何时候被取消，通过调用cancel(boolean)方法。触发了cancel方法之后，将会导致后续查询isCancelled方法时返回true。

    在调用了Cancel方法之后，在doInBackground方法返回时，将调用onCancel方法而不是onPostExecute方法。为了尽快的让一个任务可以被取消，应该在doInBackground方法中定期地检查isCancelled方法返回的值，及时的取消任务的执行。

线程规则

    在使用AsyncTask时，有一些线程规则需要被遵循：

    1.AsyncTask必须在UI线程上加载执行。AsyncTask必须在UI线程上创建，execute()方法必须在UI线程中执行。

    2.不要手动去调用onPreExecute()、doInBackground()、onProgressUpdate()、onPostExecute()方法。

    3.AsyncTask任务只能被执行一次，如果执行多次，将会抛出异常。

内存一致性

    AsyncTask保证所有的回调函数调用将同步：

    在构造器中或是在onPreExecute方法中设置的变量可以在doInBackground中安全的使用；

    在doInBackground中设置的变量可以在onProgressUpdate()或者onPostExecute()方法中安全的使用。

执行的顺序

    当AsyncTask刚被引入时，AsyncTask任务是在一个后台线程中顺序执行的。从Android 1.6版本以后，改变为一个线程池了，允许多个任务并发的执行。从Android3.0开始，任务被执行在单个线程中，避免由并发执行引发的应用程序错误。如果想并发执行的话，可以通过调用AsyncTask的executeOnExecutor()方法来指定THREAD_POOL_EXECUTOR。

二、源码分析

1.任务的执行

任务的执行可以通过两种方式实现，一种是任务顺序执行；另外一种是任务并发的执行；

调用AsyncTask的execute方法，任务将顺序的执行；

调用AsyncTask的executeOnExecutor()方法，并指定执行器Executor，任务将并发的执行。

/* *任务执行 *params是任务执行所需要的参数     *如果想任务并发的执行，可以使用executeOnExecutor方法，指定THREAD_POOL_EXECUTOR或者是自定义的executor。 *该方法在UI线程中执行，并且只能被调用一次。 */@MainThreadpublic final AsyncTask<Params, Progress, Result> execute(Params... params) {// sDefaultExecutor是一个顺序执行器，任务在单个后台线程中顺序执行return executeOnExecutor(sDefaultExecutor, params);}/**该方法可以允许任务并发的执行，但是任务并发的执行，经常会出现一些意想不到的错误，使用时需要特别谨慎*该方法经常搭配THREAD_POOL_EXECUTOR参数使用，也可以使用用户自定义的Executor执行器*如果想任务顺序的执行，可以使用SERIAL_EXECUTOR执行器。*该方法必须在UI线程中执行*/@MainThreadpublic final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec, Params... params) {// 该判断保证了executeOnExecutor方法只能被执行一次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)");}}//将任务的执行状态设置为RUNNINGmStatus = Status.RUNNING;//在执行任务前，调用onPreExecute()方法onPreExecute();//将参数传递给执行的任务mWorker.mParams = params;//开始执行任务exec.execute(mFuture);return this;}

2.任务执行器Executor
顺序执行器SERIAL_EXECUTOR

//顺序执行Executorpublic static final Executor SERIAL_EXECUTOR = new SerialExecutor();private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;private static class SerialExecutor implements Executor {//双端数组，允许元素在数组的两端插入和删除final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();Runnable mActive;    public synchronized void execute(final Runnable r) {//将Runnable添加到队列的末尾mTasks.offer(new Runnable() {public void run() {try {r.run();} finally {//触发调用下一个任务scheduleNext();}            }        });//第一次执行时，mActive为空，触发调用下一个任务执行。后续的任务执行，是通过scheduleNext()来触发执行的if (mActive == null) {scheduleNext();}}}/**该方法从任务队列中取出任务，然后通过THREAD_POOL_EXECUTOR执行任务，执行完任务之后，就开始下一个任务执行，*这样就保证了任务一个接一个在后台执行。SerialExecutor可以添加多个任务，但任务的执行还是顺序的执行，一个接一个执行。*/protected synchronized void scheduleNext() {if ((mActive = mTasks.poll()) != null) {THREAD_POOL_EXECUTOR.execute(mActive);}    }}

并发执行器THREAD_POOL_EXECUTOR

//并发执行的Executorpublic 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;}//CPU的数量private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();//cool pool至少需要2个线程，至多4个线程private static final int CORE_POOL_SIZE = Math.max(2, Math.min(CPU_COUNT - 1, 4));private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;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());}};

3.任务的执行状态

任务的执行状态有三种，分别是等待执行，正在执行，执行完成

private volatile Status mStatus = Status.PENDING;//指示当前任务执行的状态，每个状态只在整个任务生命周期内执行一次。public enum Status {//指示任务等待被执行的状态PENDING,//指示任务正在执行的状态RUNNING,//指示任务已经执行完成了FINISHED,}//返回的任务执行状态public final Status getStatus() {return mStatus;}

4.任务执行的回调方法

/**需要被覆写的方法，在后台线程执行任务的方法；*执行任务的参数params是在调用execute方法时传入的；*在该方法中，可以调用publishProgress()方法，来更新UI线程中任务执行的进度。*/@WorkerThreadprotected abstract Result doInBackground(Params... params);/**在主线程中执行*在调用doInBackground方法之前调用。*/@MainThreadprotected void onPreExecute() {}/**在主线程中执行*在调用doInBackground方法之后调用*result参数的值是doInBackground方法返回的值*如果任务被取消了，则该方法不会被调用*/@MainThreadprotected void onPostExecute(Result result) {}/**在主线程中执行*在执行完publishProgress方法之后，调用该方法*参数values的值是传递给publishProgress()方法参数的值*/@MainThreadprotected void onProgressUpdate(Progress... values) {}

5.任务的封装

    在构建执行AsyncTask构造器的时，创建了两个变量mWorker和mFuture。mWorker是对执行任务的包装，而mFuture是对mWorker的封装，表示在执行框架中执行的任务。

// 具体执行任务，Params为执行任务传入的参数，Result为执行任务后返回结果的参数private final WorkerRunnable<Params, Result> mWorker;private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {Params[] mParams;}private final FutureTask<Result> mFuture;public AsyncTask() {mWorker = new WorkerRunnable<Params, Result>() {public Result call() throws Exception {mTaskInvoked.set(true);Result result = null;try {                Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);//在后台线程执行doInBackground方法，mParams参数在调用execute方法时传入该参数。result = doInBackground(mParams);Binder.flushPendingCommands();} catch (Throwable tr) {mCancelled.set(true);throw tr;} finally {//执行完doBackground方法之后，将结果投递到UI线程中postResult(result);}return result;}};mFuture = new FutureTask<Result>(mWorker) {@Overrideprotected void done() {try {//任务执行完成后，将任务执行结果投递到UI线程中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);}}};}

    当调用任务执行框架的execute()方法时，开始任务的执行。在WorkerRunnable的call方法中，执行doInBackground方法。由于任务的执行是在子线程中执行，所以doInBackground方法也是在子线程中执行。doInBackground()方法中的参数是在调用AsyncTask的execute（)方法时传递进来的。doInBackground()方法执行的结果，将通过postResult()方法投递到UI线程中。

//将任务的执行结果返回到UI线程中private Result postResult(Result result) {@SuppressWarnings("unchecked")    Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,new AsyncTaskResult<Result>(this, result));message.sendToTarget();    return result;}@SuppressWarnings({"RawUseOfParameterizedType"})private static class AsyncTaskResult<Data> {final AsyncTask mTask;    final Data[] mData;AsyncTaskResult(AsyncTask task, Data... data) {mTask = task;mData = data;}}

在AsyncTask中，定义了一个Hanlder来接收处理子线程发送过来的消息事件。

//UI线程Handler，根据后台返回的消息类型，进行相应的处理private static InternalHandler sHandler;private static final int MESSAGE_POST_RESULT = 0x1;private static final int MESSAGE_POST_PROGRESS = 0x2;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:// 后台执行完成了，返回执行结果，在doInBackground()方法执行完成后，// 会发送MESSAGE_POST_RESULT消息到UI线程，执行相应的处理，如果任务没有被取消，则执行onPostExecute方法// 如果任务取消了，则执行onCanclled方法result.mTask.finish(result.mData[0]);break;case MESSAGE_POST_PROGRESS:// 在后台执行的过程中，通过调用publishProcess()方法，发送MESSAGE_POST_PROGRESS消息到UI线程，// 在UI线程中执行onProgressUpdate方法，完成后台任务执行进度更新。result.mTask.onProgressUpdate(result.mData);break;}    }}private static Handler getHandler() {synchronized (AsyncTask.class) {if (sHandler == null) {sHandler = new InternalHandler();}return sHandler;}}

    postResult方法发送MESSAGE_POST_RESULT消息到UI线程中，UI线程对任务执行返回的结果进行相应的处理，最终调用finish()方法。如果任务已经被取消了，则执行onCancelled方法；如果任务没有被取消，则执行onPostExecute方法。

//执行doInBackground()操作后的相关操作private void finish(Result result) {//任务被取消了，执行onCancelled方法if (isCancelled()) {        onCancelled(result);} else {//任务没有被取消，则执行onPostExecute()方法onPostExecute(result);}mStatus = Status.FINISHED;}

6.任务的取消

private final AtomicBoolean mCancelled = new AtomicBoolean();/**尝试取消一个任务*如果任务已经完成了，或者是已经被取消了，或者是由于其他原因不能被取消，则取消操作将返回失败。*如果任务还未开始，当执行完cancel操作后，该任务不会再执行*如果任务已经开始了，那么mayInterruptIfRunning参数将决定是否执行该任务的线程应该被中断*/public final boolean cancel(boolean mayInterruptIfRunning) {// 设置取消标志为truemCancelled.set(true);// 调用Future.cancel方法，取消任务的执行return mFuture.cancel(mayInterruptIfRunning);}/**在主线程中执行*在cancel方法被触发执行，并且doInBackground()方法完成后，将调用该方法*默认的onCancelled()方法将忽略该执行结果，如果需要自定义实现该方法，不要调用super.onCancelled(result)方法。*/@MainThreadprotected void onCancelled(Result result) {    onCancelled();}/**该方法被默认的onCancelled(Object)方法实现调用*该方法在主线程中执行，在cancel方法被触发执行，并且doInBackground()方法完成后，将调用该方法*/@MainThreadprotected void onCancelled() {}/**如果任务在执行前被取消了，则返回true*如果调用了Cancel方法来取消任务时，应该在doInBackground方法中调用该方法定期地检查任务是否被取消了，以尽快的结束任务。*/public final boolean isCancelled() {return mCancelled.get();}

7.后台执行进度的更新
    当需要更新后台任务执行进度时，可以在doInBackground方法中调用publishProgress()方法，将后台任务执行进度更新到UI线程中。publishProgress方法将发送MESSAGE_POST_PROGRESS消息到UI线程，在UI线程中调用onProgressUpdate方法。

/**该方法可以在doInBackground方法中调用，将任务执行的进度发布的UI线程中*执行该方法将会触发onProgressUpdate()方法在UI线程中执行*如果任务被取消了，则onProgressUpdate()方法不会被调用*/@WorkerThreadprotected final void publishProgress(Progress... values) {if (!isCancelled()) {getHandler().obtainMessage(MESSAGE_POST_PROGRESS,new AsyncTaskResult<Progress>(this, values)).sendToTarget();}case MESSAGE_POST_PROGRESS://在后台执行的过程中，通过调用publishProcess()方法，发送MESSAGE_POST_PROGRESS消息到UI线程，// 在UI线程中执行onProgressUpdate方法，完成后台任务执行进度更新。result.mTask.onProgressUpdate(result.mData);    break;

三、总结

   AsyncTask允许你执行后台耗时操作，并将结果发布到UI线程。

  当调用AsyncTask.execute()方法时，采用的是默认的顺序执行器，任务是在后台线程中顺序执行的。如果想任务在后台并发地执行，则需要调用AsyncTask.executeOnExecutor()方法，并指定Executor执行器。

AsyncTask任务执行的一般流程如下：

图中深色的部分表示在后台线程执行的操作，其余的都是在主线程中执行的操作。

四、AsyncTask使用示例

import android.app.Activity;import android.app.ProgressDialog;import android.content.Context;import android.os.AsyncTask;import android.os.Bundle;import android.util.Log;import android.view.View;import android.widget.Button;import android.widget.Toast;public class MainActivity extends Activity {private static final String TAG = "MainActivity";    private ProgressDialog mDialog;    private MyAsyncTask mTask;@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.activity_main);mDialog = new ProgressDialog(this);mDialog.setMax(100);mDialog.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);mTask = new MyAsyncTask(this);//开始执行任务Button start = (Button) findViewById(R.id.start);start.setOnClickListener(new View.OnClickListener() {@Overridepublic void onClick(View view) {                Log.i(TAG,"start task");mTask.execute();}        });//取消任务执行Button cancel = (Button) findViewById(R.id.cancel);cancel.setOnClickListener(new View.OnClickListener() {@Overridepublic void onClick(View view) {Log.i(TAG,"cancel task");mTask.cancel(false);}        });}private class MyAsyncTask extends AsyncTask<Void,Integer,Void>{private Context mContext;        public MyAsyncTask(Context context){mContext = context;}@Overrideprotected void onPreExecute() {Log.i(TAG, "onPreExecute()...on: " + Thread.currentThread().getName());mDialog.show();}@Overrideprotected Void doInBackground(Void... params) {            Log.i(TAG,"doInBackground()...on: " + Thread.currentThread().getName());//模拟后台执行for (int i = 0;i < 100; i++){//如果任务被取消了，则直接返回if (isCancelled()){break;}try {                    Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}publishProgress(i);}return null;}@Overrideprotected void onProgressUpdate(Integer... values) {Log.i(TAG, "onProgressUpdate()...on: " + Thread.currentThread().getName());mDialog.setProgress(values[0]);}@Overrideprotected void onPostExecute(Void result) {Log.i(TAG,"onPostExecute()...on: " + Thread.currentThread().getName());mDialog.dismiss();Toast.makeText(mContext,"任务执行完成",Toast.LENGTH_LONG).show();}@Overrideprotected void onCancelled(Void result) {            Log.i(TAG,"onCancelled()...on: " + Thread.currentThread().getName());mDialog.dismiss();Toast.makeText(mContext,"任务被取消了",Toast.LENGTH_LONG).show();}}}

布局文件activity_main.xml

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"android:layout_width="match_parent"android:layout_height="match_parent">    <Buttonandroid:id="@+id/start"android:layout_width="match_parent"android:layout_height="wrap_content"android:text="开始任务"/>    <Buttonandroid:id="@+id/cancel"android:layout_width="match_parent"android:layout_height="wrap_content"android:layout_below="@+id/start"android:text="取消任务"/></RelativeLayout>

Demo地址：https://github.com/qiubing/AsyncTaskDemo.git