AsyncTask源码分析

网上已经有太多的AsyncTask源码分析，而且大牛们都写的比我好，但是我还是决定尝试自己写一篇，因为这是我第一次尝试去阅读源码，写这篇blog的目的是为了巩固下。

正文

AsyncTask 需要传入三个泛型参数，分别是表示传入的参数Params，用于表示进度的Progress，和返回结果Result。
一个简单的模版：

class DownloadTask extends AsyncTask<Void, Integer, Boolean> {  
  
    @Override  
    protected void onPreExecute() {  
        //用于任务执行前的UI操作 
    }  
  
    @Override  
    protected Boolean doInBackground(Void... params) {  
        
       //后台费时任务的 执行
    }  
  
    @Override  
    protected void onProgressUpdate(Integer... values) {  
      //用于后台任务的执行中反馈 进度到UI界面
    }  
  
    @Override  
    protected void onPostExecute(Boolean result) {  
       //任务结束后，对UI的操作
    }
}

以下开始分析源码：

首先进入构造函数

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

必须在UI线程中构建，其中的WorkerRunnable 继承了CallBack，只不过多传一个参数进去。再将WorkerRunnable 的对象mWorker以参数形式传给了FutureTask的对象mFuture.
在这里面，并没有进行任何操作，只是进行了赋值而已。

接着，要执行该任务的时候，需要调用execute()，这里的源码为：

1
2
3

public final AsyncTask<Params, Progress, Result> execute(Params... params) {
    return executeOnExecutor(sDefaultExecutor, params);
}

再跳到其中的executeOnExecutor()的看下：

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

这里我们能发现，调用了onPreExecute(),因为此时还没有进入子线程，还存于主线程UI 线程中，所以可以在onPreExecute()中处理一些UI 操作，如弹出一个进度条之类的。
然后，程序进入到exec.execute(mFuture); 其中的mFuture中包含了传进来的参数，和传出去的result。
这里的exec 为上图中的sDefaultExecutor，而这个sDefaultExecutor在前面其实已经定义过了，看一下定义的代码：

1	private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;

而其中的SERIAL_EXECUTOR 又已提前定义好了是：

1	public static final Executor SERIAL_EXECUTOR = new SerialExecutor();

所以exec其实为内部的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);
        }
    }
}

代码也是很简单的，运行代码的部分就在r.run()中，接下来就一定会走到scheduleNext()函数中，而这个函数也很明显，就是单纯的指向下一个任务而已。
这里需要注意的是这两个方法都是用synchronized 修饰过的方法，这就说明如果每次只能响应一个任务，当任务池总有很多任务时，会一个任务接着一个任务的执行，并不会并发执行。
如果你需要并发执行的话，你需要传入一个自定义的Executor。
再回到刚才的说到的r.run()函数中，可以发现r是一个Runable型的参数，而这参数其实就是mFuture中的runable。
而mFuture是FutureTask的实例，那接下就是看FutureTask的run()的具体实现：

public void run() {
     if (state != NEW ||
         !U.compareAndSwapObject(this, RUNNER, null, Thread.currentThread()))
         return;
     try {
         Callable<V> c = callable;
         if (c != null && state == NEW) {
             V result;
             boolean ran;
             try {
                 result = c.call();
                 ran = true;
             } catch (Throwable ex) {
                 result = null;
                 ran = false;
                 setException(ex);
             }
             if (ran)
                 set(result);
         }
     } finally {
         // runner must be non-null until state is settled to
         // prevent concurrent calls to run()
         runner = null;
         // state must be re-read after nulling runner to prevent
         // leaked interrupts
         int s = state;
         if (s >= INTERRUPTING)
             handlePossibleCancellationInterrupt(s);
     }
 }

看到result = c.call()这行，这个call 应该就是一开始初始化的mWork对象。
我们再去找其中的call()的实现部分。
这就又回到构造函数，构造函数中有一段：

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

如果程序运行到这里，将标志这个任务已经激活，在这里执行了doInBackground(),因为是执行在runnable中的，所以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;
}

这里就是Handler发送了一条Message，看看其中的getHandler()函数：

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的Handler是内部的InternalHandler()。这个内部也十分熟悉，就是根据标志位，分别处理对应的finishe()函数和其中的onProgressUpdate()函数。
而其中的finish()的内部为：

private void finish(Result result) {
    if (isCancelled()) {
        onCancelled(result);
    } else {
        onPostExecute(result);
    }
    mStatus = Status.FINISHED;
}

其中调用了onPostExecute()。
而之前提到过onPostExecute() 和onProgressUpdate()都是对UI的操作，所以操作必须回到主线程中。
这里注意到该函数是静态函数，而静态函数在类第一次加载时，就会调用，所以这就解释了为什么AsyncTask 一定要在主线程创建的原因。

到这里，AsyncTask 大致流程已经全部走了一遍。