Android(安卓)AsyncTask源码简单分析

分析看的4.0的源码，3.0下会有不同，简单分析一下，记录下学习过程，从熟悉的方法开始分析，逐渐深入。
1.首先从构造方法开始分析
构造方法：

  public AsyncTask() {        mWorker = new WorkerRunnable() {            public Result call() throws Exception {                mTaskInvoked.set(true);                Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);                Result result = doInBackground(mParams);                Binder.flushPendingCommands();                return postResult(result);            }        };        mFuture = new FutureTask(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);                }            }

主要就是初始化mWorker和mFuture对象，看下这两个的定义。

    private final WorkerRunnable mWorker;    private final FutureTask mFuture;    private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {        Params[] mParams;    }

mWorker是一个Callable对象，mFuture是FutureTask，java并发包提供的，关于这两个类的介绍看这里，这里mWorker传给了mFuture的构造方法，真正执行的是mWorker里的call方法。call方法里面的逻辑，主要是doInBackground和postResult，其中前一个方法就是我们自定义的后台处理，比如下载任务等等。

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

可以看到这个result就是异步任务的结果，它把这个结果是传给了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());        }        @Override        public void handleMessage(Message msg) {            AsyncTaskResult<?> result = (AsyncTaskResult<?>) msg.obj;            switch (msg.what) {                case MESSAGE_POST_RESULT:result.mTask.finish(result.mData[0]);                    break;                case MESSAGE_POST_PROGRESS:                    result.mTask.onProgressUpdate(result.mData);                    break;            }        }    }     private static class AsyncTaskResult<Data> {        final AsyncTask mTask;        final Data[] mData;        AsyncTaskResult(AsyncTask task, Data... data) {            mTask = task;            mData = data;        }    }

这里handler调用的是result.mTask.finish(result.mData[0]) ，其实也就是AsyncTask的finish()。

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

finsh()会先判断是否是取消了，如果不是，则调用onPostExecute，否则调用onCancelled，并把状态设置为已完成。onPostExecute这个就是最后开发者需要重写的方法，任务执行完成，回调这个方法，后续处理开发者自定义。同理onCancelled也是一样。
从构造方法开始分析，已经分析完了后台任务的执行和结束的回调。

2.分析execute()方法
上面的分析已经知道任务的执行是通过mWorker和mFuture执行的，通过AsyncTask的用法就知道后台任务肯定是子线程执行，看下execute是怎么做的。

     public final AsyncTask<Params, Progress, Result> execute(Params... params) {        return executeOnExecutor(sDefaultExecutor, params);    }     public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,            Params... params) {        /×省略了异常的判断×/        mStatus = Status.RUNNING;        onPreExecute();        mWorker.mParams = params;        exec.execute(mFuture);        return this;    }

可以看到最终执行的是executeOnExecutor，先是把状态设置为running，在是调用了onPreExecute方法，现在为止，代码的执行还是在主线程中，所以在onPreExecute中我们可以做控件的初始化操作，然后把参数赋给mWorker，最后sDefaultExecutor执行execute(mFuture)。上面分析过，mFuture里就是我们后台任务的执行逻辑，sDefaultExecutor是一个线程池，看看它怎么做的。关于这里SDK3.0一下会有不同，后面再说。

    public static final Executor SERIAL_EXECUTOR = new SerialExecutor();    private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;    private static class SerialExecutor implements Executor {        final ArrayDeque mTasks = new ArrayDeque();        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);            }        }    }

可以看到sDefaultExecutor就是一个线程池，它的execute方法接受一个Runnable，代码里传的就是mFuture，mTasks是一个队列，储存所有的任务，mActive代表当前执行的任务，在execute方法里，首先把传参的run方法包装了一下，然后入队，第一次执行这里的时候，mActive为空，所以执行scheduleNext(),这个方法里，先出队一个任务，然后THREAD_POOL_EXECUTOR.execute(mActive);，看下THREAD_POOL_EXECUTOR。

  public static final Executor THREAD_POOL_EXECUTOR            = new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,                    TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);

它设置了线程池的最大数量，同时能运行的线程数等信息。它才是真正调用任务执行线程的地方。为什么这里存在两个线程池呢，第一个线程池好像没作用啊，其实第一个线程池的作用就在于它对任务的包装，在它包装的Runnable里，结尾都加了一句scheduleNext()，还是try-finally包围，也就是这句代码必须执行，也就是说当一个任务完成之后，再次调用这个方法，继续出队，继续执行下一个任务，执行完后，继续执行scheduleNext()，继续出队…….直到任务全部执行完毕，分析这个过程，可以得到结论，多个任务执行不是并行的，而是一个执行完之后再执行下一个，每个时刻只有一个任务在执行。
之前说3.0之前这里不同，3.0之前的源码我没看，但通过查资料得知，其实3.0以前没有第一个线程池，只有第二个，所以执行任务是并行的，这和前面分析的第一个线程池的作用吻合。但是这里又存在一个问题，源码里，对第二个线程池设置了最大任务的数量128，超过这个数量会报错。
那怎么在3.0之后的AsyncTask执行任务是并行的呢？只要把第一个线程池覆盖或者不调用它就好了。
1.调用setDefaultExecutor(Executor exec)方法。可以自己写一个线程池，也可以用第二个线程池，传AsyncTask.THREAD_POOL_EXECUTOR就好了
2.调用的时候不调用execute()而是调用executeOnExecutor(Executor exec,
Params… params)，第一个参数可以自定义，也可以用THREAD_POOL_EXECUTOR。

3.总结
还有一个方法，onProgressUpdate(Progress…)显示进度信息的，在上面的分析中，handler里，其实有处理，开发者调用publishProgress()方法时，其实内部就是跟handler发了个msg，然后回调onProgressUpdate，开发者自己处理。
大概流程分析的差不多了，简单分析而已。学习查看源码，很重要，从熟悉的方法，逐渐深入。路漫漫其修远兮。

参考：
http://www.cnblogs.com/dolphin0520/p/3949310.html
http://blog.csdn.net/singwhatiwanna/article/details/17596225

更多相关文章

随机推荐