Android AsyncTask原理解析

前言：AsyncTask是对Handler异步消息处理的一层封装，方便开发者便捷使用异步处理的一个类。

源码：6.0

AsyncTask的使用

 /**
     * 1. Params
     在执行AsyncTask时需要传入的参数，用于在后台任务(doInBackground)中使用。
     2. Progress
     后台任务执行时，如果需要在界面上显示当前的进度(onProgressUpdate)，使用这里指定的泛型作为进度单位。
     3. Result
     当任务执行完毕后，如果需要对结果进行返回(onPostExecute)，使用这里指定的泛型作为返回值类型。
     */
    class DownTasg extends AsyncTask<String,Integer,Boolean>{
        @Override
        protected void onPreExecute() {
            super.onPreExecute();
            //任务准备开始执行 UI线程
        }

        @Override
        protected Boolean doInBackground(String... params) {
            //进行耗时操作 工作线程

            //这里的返回值在onPostExecute() 使用
            return null;
        }


        @Override
        protected void onProgressUpdate(Integer... values) {
            //进度回调  UI线程
            super.onProgressUpdate(values);
        }

        @Override
        protected void onPostExecute(Boolean aBoolean) {
            //任务执行结果， doInBackground() 的执行结果   UI线程
            super.onPostExecute(aBoolean);
        }
    }

这里就不啰嗦了。

源码分析

先来看看它的构造方法

public AsyncTask() {
        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
                    result = doInBackground(mParams);
                    Binder.flushPendingCommands();
                } catch (Throwable tr) {
                    mCancelled.set(true);
                    throw tr;
                } finally {
                    postResult(result);
                }
                return 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);
                }
            }
        };
    }

WorkerRunnable

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

这里可以看见初始化了一个WorkerRunnable以及FutureTask，WorkerRunnable其实是一个Callable；
FutureTask则是异步任务使用。
FutureTask一个可取消的异步计算，FutureTask 实现了Future的基本方法，提空 start cancel 操作，可以查询计算是否已经完成，
并且可以获取计算的结果。结果只可以在计算完成之后获取，get方法会阻塞当计算没有完成的时候，一旦计算已经完成，
那么计算就不能再次启动或是取消。
一个FutureTask 可以用来包装一个 Callable 或是一个runnable对象。因为FurtureTask实现了Runnable方法，所以一个 FutureTask可以提交给一个Executor执行
注意：FutureTask的使用必须配合Executor。
Java功底扎实的其实看见初始化函数大致就清楚AsyncTask是怎么一个回事了，AsyncTask其实是使用了线程池来进行异步操作，

先看

 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的回调done()方法执行了postResultIfNotInvoked()

//这个值在初始化WorkRunnable时赋值为true
  private final AtomicBoolean mTaskInvoked = new AtomicBoolean();

   private void postResultIfNotInvoked(Result result) {
        final boolean wasTaskInvoked = mTaskInvoked.get();
        if (!wasTaskInvoked) {
            postResult(result);
        }
    }

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

postResultIfNotInvoked方法做了一个判断，只有在初始化AsyncTask也就是mTaskInvoked变量为false时才会去调用；初始化先分析到这里。
现在来看看AsyncTask是怎么执行的

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

执行AsyncTask必须调用execute() 方法（方法上面加了注解，必须在MainThread调用），这里只是调用了executeOnExecutor()方法。

 @MainThread
    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;

        //1。准备执行
        onPreExecute();

        mWorker.mParams = params;
        //2.这个对象是一个Executor参数mFuture是AsyncTask初始化创建的
        exec.execute(mFuture);

        return this;
    }

这里进行了各种状态检查，以及设置，注释1处调用onPreExecute()方法，然后在注释2调用Executor对象的的execute()方法。
重点来了：

  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() {
                //2
                    try {
                        r.run();
                    } finally {
                        scheduleNext();
                    }
                }
            });
            //1
            if (mActive == null) {
                scheduleNext();
            }
        }

        protected synchronized void scheduleNext() { 
            if ((mActive = mTasks.poll()) != null) {
                //注意这个Executor对象是static代码块创建的 
                THREAD_POOL_EXECUTOR.execute(mActive);
            }
        }
    }

首先这里先自定义了了一个变量sDefaultExecutor，注意他的声明 static volatile 这样保证了每new一个AsyncTask都保证Executor对象在并发情况下的同步，volatile关键字有不理解的可以看关于volatile

下面来看看自定义的这个SerialExecutor内部类，先用ArrayDeque队列来存储Runnable对象，当调用execute方法的时候，先把Runnable插入ArrayDeque队列的对尾，执行注释1处mActive == null判断，然后再调用注释2处Runnable对象的run()方法，无论run()是否执行过了，都会调用scheduleNext()方法，而这个scheduleNext()方法就是把类中的Runnable对象赋值成为队列中的第一个值。
注意代码执行顺序

其实说了那么多：
就是干了一件事，维护一个Runnable对象的队列，通过递归的方式来遍历这个队列，而且注意execute()方法使用synchronized关键字修饰；保证并发操作链表数据的一致性；
接着来看scheduleNext()这个方法

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

这里直接使用了ThreadPoolExecutor类来定义线程池。
回到SerialExecutor.execute()方法，这里的r.run()执行了我们最开始分析的那块代码

 public AsyncTask() {
        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
                    //1.这里是SerialExecutor.execute()执行的所以是工作线程，可以执行异步操作。
                    result = doInBackground(mParams);
                    Binder.flushPendingCommands();
                } catch (Throwable tr) {
                    mCancelled.set(true);
                    throw tr;
                } finally {
                    //2.具体执行
                    postResult(result);
                }
                return 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);
                }
            }
        };
    }

这里注意注释 1 调用了doInBackground；注释2则是具体执行
postResult

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

这里是使用Handler把处理过的结果发送出去；
来看接收
InternalHandler

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

这里分别执行了finish 和onProgressUpdate()这个方法就是进度回调的方法了。
来看finish

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

也是进行了结束或者取消的回调。

关于AsyncTask3.0以前版本的问题

在Android 3.0之前是没有SerialExecutor这个类的，那个时候是直接在AsyncTask中构建了一个sExecutor常量，并对线程池总大小，同一时刻能够运行的线程数做了规定

private static final int CORE_POOL_SIZE = 5;  
private static final int MAXIMUM_POOL_SIZE = 128;  
private static final int KEEP_ALIVE = 10;  
……  
private static final ThreadPoolExecutor sExecutor = new ThreadPoolExecutor(CORE_POOL_SIZE,  
        MAXIMUM_POOL_SIZE, KEEP_ALIVE, TimeUnit.SECONDS, sWorkQueue, sThreadFactory);  

可以看到，这里规定同一时刻能够运行的线程数为5个，线程池总大小为128。也就是说当我们启动了10个任务时，只有5个任务能够立刻执行，另外的5个任务则需要等待，当有一个任务执行完毕后，第6个任务才会启动，以此类推。而线程池中最大能存放的线程数是128个，也就是说，当我们添加第129个任务时，程序就会崩溃了。

而3.0之后提供的是一个executeOnExecutor()方法，如果不想使用默认的SerialExecutor则可以

Executor exec = new ThreadPoolExecutor(10, 100, 10,  
        TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>());  
new DownloadTask().executeOnExecutor(exec);  

这样可以更灵活的使用了。

总结

• AsyncTask使用了线程池+Handler机制来执行异步操作。
• 3.0以上默认的SerialExecutor其实是维护了一个单一线程池。
• Android 3.0之前是没有SerialExecutor这个类的，而是直接在AsyncTask中构建了一个sExecutor常量，并对线程池总大小，同一时刻能够运行的线程数做了规定，这样的后果就是，当超出线程池大小的值时，程序就会崩溃。