Android AsyncTask源码简单分析

最新推荐文章于 2021-05-26 23:55:38 发布

孤独正患者

最新推荐文章于 2021-05-26 23:55:38 发布

阅读量511

点赞数

分类专栏： android学习文章标签： android 源码 asynctask android asynctask

本文链接：https://blog.csdn.net/noaboutfengyue/article/details/49590179

版权

android学习专栏收录该内容

19 篇文章 1 订阅

订阅专栏

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

  public AsyncTask() {
        mWorker = new WorkerRunnable<Params, Result>() {
            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<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);
                }
            }

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

    private final WorkerRunnable<Params, Result> mWorker;
    private final FutureTask<Result> 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<Result>(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<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);
            }
        }
    }

可以看到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