android AsyncTask原理解析

  Asynctask是一个轻量级的异步任务类，可直接继承Asynctask使用，使用起来简单快捷，比较方便，可以在线程池中执行一些任务，然后将任务的结果反馈到主线程中，可以根据反馈的结果做一些更新UI以及一些其他的操作。

  Asynctask中主要包含了一下几个方法:

  onPreExecute():该方法是在主线程中调用，用于做一些任务开始前的一些准备以及初始化工作。

  doInBackground():该方法在线程池中执行，用于执行一些具体的任务。

  onProgressUpdate():该方法在主线程中执行，可以通过publishProgress()方法来调用此方法，用于更新一些任务进度的改变。

  onPostExecute():该在主线程中执行，接收doInBackground()方法返回的结果作为参数，可以根据返回的结构，在此方法中做一些改变UI或是一些其他的操作。

  onCancelled():该方法在主线程中调用，当任务被取消的时候会调用该方法。

public abstract class AsyncTask<Params, Progress, Result>

根据以上代码可以看出AsyncTask是一个抽象的泛型类，其中Params、Progress,Result分别代表了传递参数的类型、执行进度的类型、返回结果的类型，也可以这么说，Params是doInBackground()方法的参数类型，把Progress看成是onProgressUpdate()方法的参数类型，Result是onPostExecute()方法的参数类型。如果不需要传递一些参数的话，可以传递Void来代替，注意Void和void是不同的，区分开头字母的大小写。

下面是我之前demo使用AsyncTask的一个小例子:

private class NewsAsyncTask extends AsyncTask<String,Void,Bitmap>{

        private String mUrl;

        public NewsAsyncTask(String url) {
            mUrl = url;
        }

        @Override
        protected Bitmap doInBackground(String... params) {
            String url = params[0];
            //从网络中获取图片
            Bitmap bitmap = getBitmapFromURL(params[0]);
            if(bitmap != null){
                //将不在缓存的图片加入缓存
                addBitmapToCache(url , bitmap);
            }
            return bitmap;
        }

        @Override
        protected void onPostExecute(Bitmap bitmap) {
            super.onPostExecute(bitmap);
            ImageView imageView = (ImageView)mListView.findViewWithTag(mUrl);
            //对ImageView设置Bitmap
            if (imageView != null && bitmap != null){
                imageView.setImageBitmap(bitmap);
            }
        }
    }

  以上实例中，我没有给出某些具体方法的实现代码，不过我也用注释标出了方法的作用，主要是让读者了解一下AsyncTask的使用方式，我们只需要通过new NewsAsyncTask().execute()就可以执行AsyncTask，注意:如果有参数的话，需要在execute()方法里传递具体的参数， 本文的重点是想讲述AsyncTask的具体的执行过程，也就是AsyncTask偏底层一点的实现原理，如果读者看了上面的例子对AsyncTask的使用还有不懂的地方，还请读者去百度一下其他的关于AsyncTask使用的资料，网上应该有很多，谢谢！

  我们通过调用AsyncTask对象的execute()方法，就可以执行一个AsyncTask任务了，首先我们可以先看一下这个execute()方法内部的实现。

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

我们可以看到，在AsyncTask的execute()方法的内部调用了executeOnExecutor()方法，我们可以看到，在execute()方法中，对 executeOnExecutor()方法传递了两个参数，其中第二个参数就是我们通过调用AsyncTask对象的execute()方法传递过来的参数，而 第一个参数其实sDefaultExecutor实际上是一个线程池对象，内部维护了一个队列，用来存储要执行的任务，稍后会具体的介绍内部的实现。

也就是说，execute()方法会执行executeOnExecutor()方法，下面来看一下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;
    }

在 executeOnExecutor()方法中，会调用onPreExecute()方法，上文中提到过这个方法，用于做一些准备以及初始化的操作。之后，mWorker.mParams = params相对于把我们传递的参数为WorkerRunnable对象的mParams对象赋值，之后就会调用线程池的execute()方法，也就是sDefaultExecutor对象的execute()方法，而execute()方法的参数mFuture，其实是一个FutureTask的对象，该对象是在AsyncTask的构造方法中进行实例化的，下面是AsyncTask构造方法的代码:

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

  其实FutureTask对象我理解在这里充当了Runnable的作用，我们可以看到，在AsyncTask的构造方法中，首先会构造出了WorkRunnable的对象mWorker，并且重写了它的call()方法，在构造FutureTask对象mFuture的时候，会把FutureTask对象与WorkRunnable的对象mWorker关联起来，之后会在某个时候调用WorkRunnable对象的方法，稍后会提到,并且重写了它的done()方法。

因为在executeOnExecutor()方法中又调用了线程池对象sDefaultExecutor的execute()，下面我们来看一下这个方法:

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

我们可以看到，在该线程池的代码中，维护了一个队列mTasks，用于存放AsyncTask任务，所有的AsyncTask任务都会存放在这个队列中排队执行，在execute()方法中，首先会把传递过来的Runnable对象，也就是上文中FutureTask对象放到这个队列中去，相当于把AsyncTask任务放到这个队列中，然后就去执行scheduleNext()方法，在这个方法中会调用另一个线程池的execute方法去执行这个任务，也就是THREAD_POOL_EXECUTOR.execute(mActive)这句代码的作用，同时，当一个任务执行完毕的时候，会继续调用 scheduleNext()方法来执行下一个任务，到目前为止已经涉及到两个线程池，一个是SerialExecutor，这个线程池的作用仅仅只是存放我们将要执行的AsyncTask任务，并不会去执行，真正执行任务的是另一个线程池THREAD_POOL_EXECUTOR。

当THREAD_POOL_EXECUTOR去执行这个任务的时候，肯定是要去执行这个Runnable的run()方法，也就是FutureTask的run方法，以下是该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);
        }
    }

上述代码中的callable对象就是构造FutureTask对象时，传递的WorkRunnable对象，在 FutureTask的run方法中回去调用WorkRunnable对象的call()方法。关于WorkRunnable的call()方法是在AsyncTask的构造方法中，实例化WorkRunnable对象的时候重写的，上文已经提到过并给出了代码，下面只给出call()方法的实现代码:

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

在call()中，首先mTaskInvoked.set(true)的作用应该就是把该任务标记为已经调用过了（ 查了下单词的意思才知道）,之后就会调用doInBackground(mParams)方法，最后会把doInBackground()方法的返回值作为参数传递给postResult()方法。下面是postResult()方法的代码:

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

所以，postResult()的作用只是通过一个getHandler()获得了一个Handler，并发送了一个消息。以下是getHandler()的代码:

private static Handler getHandler() {
        synchronized (AsyncTask.class) {
            if (sHandler == null) {
                sHandler = new InternalHandler();
            }
            return sHandler;
        }
    }

getHandler()方法返回了一个Handler对象sHandler，而sHandler对象是一个InternalHandler对象,下面是InternalHandler的相关代码:

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

通过InternalHandler发送的消息会在以上代码的handleMessage()中去执行，在handleMessage()方法中，会对传递过来的数据做判断，如果是MESSAGE_POST_RESULT的话，就会去执行AsyncTask的finish()方法，以下是finish()方法的代码:

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

在这个方法中，首先会去判断这个AsyncTask任务是否被取消掉了，如果被取消了，就去执行onCancelled()方法，否则的话就去执行onPostExecute()这个方法，通过Hanlder的机制，就使得onPostExecute()方法是在主线程中执行的。这就是我理解的整个AsyncTask的执行过程。

这里要多提一点:之前在写Volley的那边博客的时候，我提到过，取消一个Volley网络请求的时候，并不会马上的就取消，而是等到在请求的队列中执行到该请求的时候去做一个判断，如果该请求已经被取消了，那么就去把这个请求finish掉，在AsyncTask中也是这样的，以下是AsyncTask的cancel()方法的代码:

public final boolean cancel(boolean mayInterruptIfRunning) {
        mCancelled.set(true);
        return mFuture.cancel(mayInterruptIfRunning);
    }

从上述代码我们可以看出，通过mCancelled.set(true)相当于设置了一个标记，代表这个AsyncTask任务已经取消掉了，然后再finish()方法中，首先会调用isCancelled()判断这个AsyncTask任务是否被取消了，如果被取消的话，就去执行onCancelled()这个方法。
。。。。。。。。。。。。。。。。。。

写完了，累死宝宝了！！！基本上我理解的就是这样的，如果哪里写的不对的话，欢迎大家批评指正啊！！！