笔记_AsyncTask

AsyncTask简单使用过程：

1. AsyncTask是一个抽象类，继承它然后实现抽象方法：DoInBackGround、onPreExecute，等
2. 通过构造器创建实例
3. 调用实例的execute方法，传入参数。

从构造器开始，我一般用的比较多的是空参构造，但是不影响他最后都会调用到

AsyncTask(@Nullable Looper callbackLooper)

这个构造方法，这个方法上面的注释说这个方法必须在UI thread中调用

下面是这个方法的大概内容

public AsyncTask(@Nullable Looper callbackLooper) {
        //这个mHandler是运行在主线程中的.作用自然是子线程和主线程通信
        mHandler = callbackLooper == null || callbackLooper == Looper.getMainLooper()
            ? getMainHandler()
            : new Handler(callbackLooper);

        //这个mWorker其实是Callable对象，WorkerRunnable和Callable的区别在于,       
        //WorkerRunnable里面有一个成员变量Params[] mParams用于持有用户传入的参数，除此之外他没 
        //有实现任何方法包括Callable的call方法，所以他还是一个抽象类，下面是对这个call方法的实现.
        mWorker = new WorkerRunnable<Params, Result>() {
            public Result call() throws Exception {
                mTaskInvoked.set(true);
                Result result = null;
                try {
                    Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
                    //noinspection unchecked

                    //call方法被调用时实际上已经在工作线程中，doInBackground方法是由AsncTask具体子类进行实现的方法
                    result = doInBackground(mParams);

                    Binder.flushPendingCommands();
                } catch (Throwable tr) {
                    mCancelled.set(true);
                    throw tr;
                } finally {
                    //之后对执行的结果进行提交处理
                    postResult(result);
                }
                return result;
            }
        };
        //上面定义了mWorker的变量，但是在执行时不是直接执行mWorker的call方法
        //而是经过mFuture执行来对mWorker进行调用，通过继承关系可知道这个mFuture是
        //一个Runnable
        mFuture = new FutureTask<Result>(mWorker) {

            //这个方法可以不用关心，在mWorker的方法执行完成之后会走下面的done
            @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);
                }
            }
        };
    }

总的来说，构造方法中得到三个东西：mHandler（子线程和主线程通信），mWorker（Callable），mFuture（Runnable）

经过构造方法后我们得到一个实例，然后是调用这个实例的execute方法，并传入参数，方法如下：

public final AsyncTask<Params, Progress, Result> execute(Params... params) {
        //sDefaultExecutor 是一个线程池，implement自Executor，在其内部会维护一个
        //Deque队列，队列存放的元素类型是Runnable，可以说就是等待执行的Runnable对象
        //所以这个线程池可以简单理解为任务队列，每次执行任务都从这个队列中取出下一个任务
        //而具体任务执行的地方则是在另一个线程池中，而不是在这里，另一个线程池会在后面看到

        //params 就是用户传入的参数啦
        return executeOnExecutor(sDefaultExecutor, params);
    }

然后会走

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，在这里持有参数
        mWorker.mParams = params;
        //然后开始执行，注意这里传入的是mFuture对象，它里面持有了上面的mWorker，同时他是一个
        //runnable
        //这里的exec就是上面提到的任务队列线程池，实现Excutor接口，因此有一个execute方法
        //入参是一个runnable，这个方法里面主要是将mFuture加入到任务队列中排队，下面也给出了
        //他的具体实现
        exec.execute(mFuture);

        return this;
    }
//上面提到的exec ，也就是sDefaultExecutor
private static class SerialExecutor implements Executor {
        //这个队列维护了一系列的任务
        final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
        Runnable mActive;

        public synchronized void execute(final Runnable r) {

            //这里将 r 经过处理加入任务队列中
            //执行的逻辑就是先执行入参的runnable r 的run方法
            //然后通过scheduleNext取出下一个runnable来执行，从这里可以断定AsyncTask默认是串行执行的，但是实际上是可以自定义任务的执行方式，
            //不知道你有没有注意到，上面那个executeOnExecutor方法是public的，入参分别是Executor和参数列表，假如你选择默认的Executor，也就是现在这里这个线程池，那么它就是串行执行，但是如果你自定义了一个别的线程池然后直接调用executeOnExecutor方法执行任务，是不是也可以改变它的执行方式呢，感觉理论上是可行的，不过我功力不够深，还做不到这一点..
            mTasks.offer(new Runnable() {
                public void run() {
                    try {
                        r.run();
                    } finally {
                        scheduleNext();
                    }
                }
            });
            //mActive 是一个runnable，在开始的时候定义了，表示正在执行的任务
            if (mActive == null) {//如果当前没有任务在执行就安排下一个任务
                scheduleNext();
            }
        }

        //安排新任务去执行
        protected synchronized void scheduleNext() {
            if ((mActive = mTasks.poll()) != null) {
                //在这里终于出现真正执行任务的线程池了
                //我们知道线程池实现的是线程的并发，里面有核心线程，普通线程，线程等待队列以及线程存活时间的概念，这里就不深入讨论了
                //只需要知道任务在这里面会被安排到一个空闲线程上执行等等...
                THREAD_POOL_EXECUTOR.execute(mActive);
            }
        }
    }

上面的asyncTask通过execute提交的任务最终会在线程池中执行，还记得我们最开始的mWorker吗，我猜它在执行的时候最终会走到call方法里执行，可以回头看看这个call方法，我们比较关心的是DoInBackGround 和 postResult这两个调用.

而DoInBackGround就是我们自实现的逻辑，这个是在子线程中走的，不用管，然后是postResult方法，我们通过这个方法来提交运行结果，就是说在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;
    }

getHandler 得到的其实就是我们最开始在构造方法中得到的mHandler，通过这个Handler发了一条消息，接下来就要看看这个Handler是在哪里处理消息的，最终我找到了这样的一个类：

private static class InternalHandler extends Handler {
        public InternalHandler(Looper looper) {
            super(looper);
        }

        @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
                    //这里的mTask就是AsyncTask对象，这里调用了他的finish方法，在下面也给出了
                    result.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;
    }

我们知道，当DoInBackGround执行完后就会走postResult方法，里面通过handler发送的消息是

MESSAGE_POST_RESULT

但是在handler的handleMessage方法中好像还有另一种消息

MESSAGE_POST_PROGRESS

好像没有出现过，很明显这个消息的作用就是用来更新任务执行进度的，但是他是在哪里发送的呢，我们知道，更新任务进度实际上是我们用户自己来选择的，我们在实现DoInBackGround这个方法时，会在里面调用

publishProgress(Progress... values)

这个方法，不知道各位有没有印象，就是说，asyncTask本身是没有调用它的，而这个方法的源码是这样的：

@WorkerThread
    protected final void publishProgress(Progress... values) {
        if (!isCancelled()) {
            getHandler().obtainMessage(MESSAGE_POST_PROGRESS,
                    new AsyncTaskResult<Progress>(this, values)).sendToTarget();
        }
    }

现在应该知道了吧.

 

到这里就把我所认识的AsyncTask描述了一遍，应该没有忽略比较重要的内容，看完源码之后感觉也没有这么难（？），可以自己手动写一个AsyncTask。