AsyncTask使用

AsyncTask是一个泛型类，它提供了Params，Progress，Result三个泛型参数。Params用来指定异步任务的参数类型，Progress指定后台任务执行进度的参数类型，Result指定后台任务返回的参数类型，它有以下4个主要方法：

• onPreExecute()主线程中执行，开始异步任务之前调用，用于准备工作
• doInBackground(Params...params) 执行在线程池中，执行异步任务的主要方法。它内部可以调用publishProgress(Progress...values)来通知onProgressUpdate更新进度，它还需要返回Result给onPostExecute(Result result)方法
• onProgressUpdate(Progress...values) 主线程中执行，主要用于更新进度
• onPostExecute(Result result) 主线程中执行，异步任务执行结束后调用

除此之外，它还提供了一个onCancelled()方法，当异步任务被取消时此方法被调用，并且onPostExecute(Result result) 不再执行。

典型的AsyncTask用法如下：

//自定义Task
class MyTask extends AsyncTask<String,Float, Bitmap> {

        @Override
        protected void onPreExecute() {
            super.onPreExecute();
        }
        @Override
        protected Bitmap doInBackground(String... params) {
            InputStream is = null;
            ByteArrayOutputStream baos = null;
            byte[] data = null;
            try {
                HttpURLConnection connection = (HttpURLConnection)new URL(params[0]).openConnection();
                is = connection.getInputStream();
                int totalLength =0;
                totalLength = connection.getContentLength();
                baos = new ByteArrayOutputStream();
                byte[] buf = new byte[128];
                int length ;
                int count = 0;
                while ((length = is.read(buf)) != -1) {
                    baos.write(buf, 0, length);
                    count += length;
                    publishProgress(count * 1.0f / totalLength);
                }
                data = baos.toByteArray();
            } catch (IOException e) {
                e.printStackTrace();
            }finally {
                try {
                    baos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            Bitmap bitmap= BitmapFactory.decodeByteArray(data, 0, data.length);
            //Bitmap bitmap = BitmapFactory.decodeStream(is);//返回null
            Log.d("mytask", "BitMap is " + bitmap);
            return bitmap;
        }

        @Override
        protected void onProgressUpdate(Float... values) {
            Log.d("mytask", "Progress is " + values[0]*100 + "%");
        }
        @Override
        protected void onPostExecute(Bitmap bitmap) {
            MyImage.setImageBitmap(bitmap);
        }
    }
//主线程中调用task：
new MyTask().execute("http://192.168.1.105:8080/largeicon.png");

使用AsyncTask有几点注意事项：

• Asynctask对象必须在主线程创建
• execute方法必须在主线程调用
• 不要在外部手动调用AsyncTask的四个主要内部方法
• 一个AsyncTask对象只能执行一次，否则会报错
• AsyncTask的执行除了execute之外，还有executeOnExecutor方法

AsyncTask源码解析：

我们从execute方法作为入口，开始一步一步看一下AsyncTask是怎样工作的，execute源码如下：

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

可以看到，调用AsyncTask的execute方法之后，除了我们传入的参数之外，它另外加了一个sDefaultExecutor，这是一个调度任务用的串行线程池，稍后会详细介绍，实际上执行的是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;
    }

首先会进入状态判断，如果任务已经在执行，或者执行过了，会抛出异常，这也就是为什么一个AsyncTask只能执行一次的原因了。

继续往下，onPreExecute() 在这里执行了，此时还没有出现与线程相关的操作，所以onPreExecute()一定是运行在主线程的。

下面的两句就是执行异步任务的核心了，首先将传入的参数赋值给了mWorker.mParams，然后调用exec.execute(mFuture)，这里的exec默认情况下是sDefaultExecutor，这里调用了它的execute方法。

上面已经提到了，sDefaultExecutor是一个执行调度任务的线程池，它指向的是AsyncTask类中的静态变量，SERIAL_EXECUTOR，也就是说，所有的AsyncTask对象，都是通过一个线程池来调度的，它就是SERIAL_EXECUTOR。

从名字就可以看出，SERIAL_EXECUTOR是串行的，源码如下：

//定义SERIAL_EXECUTOR 
public static final Executor SERIAL_EXECUTOR = new SerialExecutor();

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

逐步分析一下SerialExecutor 的内容，首先定义了一个队列mTasks，用来存放它接收到的任务。在execute方法中，首先在队列mTasks的尾部添加一个任务，这个任务的内容包括两个部分：

1. 执行参数Runnable对象的run方法（这里的参数是mFuture，稍后会查看run方法的内容）
2. 执行scheduleNext。

注意，mTasks.offer(.....);这一步只是将任务添加到队列的尾部，实际上并未执行。

直到if (mActive == null)，执行任务之前会进行判断。如果这是AsyncTask对象的第一次执行，那么条件成立，调用scheduleNext，在这里先将mActive指向下一个任务，然后又调用了THREAD_POOL_EXECUTOR的execute方法，在这里异步任务将得到最终的执行。

注意synchronized 的存在，使得线程池只能有一个线程来执行Runnable对象，从而保证了任务会按添加顺序串行执行。

异步任务开始执行以后，由于mTasks的任务中包含了scheduleNext，所以，只要队列中还有任务，执行完一个之后会继续执行下一个，直到任务全部执行完毕。

这里我们先不分析THREAD_POOL_EXECUTOR，只需要知道，它是AsyncTask的最终执行者。再回到mTasks，可以看到执行任务时调用的是mFuture的run方法。

相关的关键代码如下：

//AsyncTask构造函数中对mWorker ，和mFuture赋值
//mWorker是一个Runnable对象，封装了doInBackground和postResult方法，等待执行。只有它内部封装的方法会在子线程执行
mWorker = new WorkerRunnable<Params, Result>() {
            public Result call() throws Exception {     ---------->###1
                mTaskInvoked.set(true);
                Result result = null;
                try {
                    Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
               //后台任务执行方法
                    result = doInBackground(mParams);
                    Binder.flushPendingCommands();
                } catch (Throwable tr) {
                    mCancelled.set(true);
                    throw tr;
                } finally {
                    postResult(result);//该方法通过Handler将消息发送到主线程
                }
                return result;
            }
        };

        mFuture = new FutureTask<Result>(mWorker) {
            @Override
            protected void done() {
                try {
                 ......
        };

//mFuture 对应FutureTask类，主要方法如下
//mFuture 赋值时调用此构造函数，将mWorker传递给了成员变量callable ；
 public FutureTask(Callable<V> callable) {
        if (callable == null)
            throw new NullPointerException();
        this.callable = callable;
        this.state = NEW;       // ensure visibility of callable
    }

//mFuture 的run方法
public void run() {
        if (state != NEW ||
            !U.compareAndSwapObject(this, RUNNER, null, Thread.currentThread()))
            return;
        try {
//取出callable，实际上就是传入的mWorker
            Callable<V> c = callable;
            if (c != null && state == NEW) {
                V result;
                boolean ran;
                try {
//执行mWorker的call方法，并返回结果，call方法在AsyncTask构造函数中对mWorker赋值时覆写，上文###1处
                    result = c.call();
                    ran = true;
                } catch (Throwable ex) {
                    result = null;
                    ran = false;
                    setException(ex);
                }
                if (ran)
                    set(result);
            }
        } finally {
......
        }

到这里，整个逻辑就清楚了。 AsyncTask将doInBackground方法封装到mWorker中 ，mFuture 又接管了mWorker 的执行，最后将mFuture 交给THREAD_POOL_EXECUTOR的execute方法，最后doInBackground会在THREAD_POOL_EXECUTOR中运行。

THREAD_POOL_EXECUTOR

通过名字我们也能大致猜到，这是一个线程池。它的创建代码如下：

public static final Executor THREAD_POOL_EXECUTOR;

    static {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE_SECONDS, TimeUnit.SECONDS,
                sPoolWorkQueue, sThreadFactory);
        threadPoolExecutor.allowCoreThreadTimeOut(true);
        THREAD_POOL_EXECUTOR = threadPoolExecutor;

实际上，AsyncTask中构建了一个核心线程数等于CPU核心数+1，最大线程数为CPU核心数2倍的线程池，用来执行AsyncTask任务。

通过上边的分析，我们可以看到，虽然AsyncTask任务最终是在线程池中执行的，但是由于SerialExecutor的存在，线程会被丢进队列中，从第一个开始排队执行，所以仍然是串行的。

实际上Android在这里有过几次变动，在Android1.6之前是串行的，1.6-3.0采用线程池并行处理，3.0以后又改为串行处理了，但是我们可以通过executeOnExecutor来指定AsyncTask使用线程池来并行处理：

new MyTask().executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR,"http://192.168.1.105:8080/largeicon.png");