AsyncTask源码分析

AsyncTask大家都不会陌生吧，当然现在有比如RxJava这种替代方案，但是AsyncTask我们还是要去分析的，这样我们能更好的理解Android系统是怎样运行的。AsyncTask内部封装了Thread和Handler，简化了他们的使用，我们都知道子线程中是不能更新UI的，我们需要在子线程中计算然后在主线程中更新UI，AsyncTask就提供了这么一种简便的实现方式。

简要说明AsyncTask的重要的一些函数

• AsyncTask定义的三种泛型类型
  Params：启动任务执行的输入参数，比如一下下载任务的Url。
  Progress：异步任务的执行的百分比。
  Result：后台任务执行完成返回的结果，比如下载完成返回文件的path路径。
• doInBackground()：运行在后台线程，做耗时操作，可以通过 publishProgress()方法更新进度，子线程。
• onPostExecute()：获取到doInBackground()中的result然后做出处理，比如更新UI，主线程。
• onProgressUpdate(Progress…)：更新任务进度；
• onPreExecute()：在调用Excute之前调用，可以显示进度对话框；
• onCancelled()：用户调用取消时要做的操作。

一个简单的示例，部分伪代码

public class ProgressAsyncTask extends AsyncTask {
    @Override
    protected String doInBackground(String... params) {
        //url代表下载地址
        String url = params[0];
        long totalSize = 0;
        long currentSize = 0;
        String filePath="";
        //... URLConnection做下载操作
        totalSize = 1228339;
        //更新 currentSize
        publishProgress(((int) (currentSize / totalSize*100)));
        return filePath;
    }
    @Override
    protected void onProgressUpdate(Integer... values) {
        super.onProgressUpdate(values);
        //progressDialog.setProgress(values[0]);
    }
    @Override
    protected void onPreExecute() {
        super.onPreExecute();
        //showProgressDialog();
    }
    @Override
    protected void onPostExecute(String s) {
        super.onPostExecute(s);
        //showDialog("下载完成，下载地址："+s);
    }
}

AsyncTask源码分析

public abstract class AsyncTask {
    private static final String LOG_TAG = "AsyncTask”;
    //cpu核心数    
    private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
    //核心线程数的区间是[2,4]
    private static final int CORE_POOL_SIZE = Math.max(2, Math.min(CPU_COUNT - 1, 4));
    //线程池最大容量
    private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;
    //当一个线程空闲30秒后就会被取消
    private static final int KEEP_ALIVE_SECONDS = 30;
    //线程工厂 通过工厂方法newThread来创建新的线程
    private static final ThreadFactory sThreadFactory = new ThreadFactory() {
    //原子整数 可以在高并发下正常工作
        private final AtomicInteger mCount = new AtomicInteger(1);

        public Thread newThread(Runnable r) {
            return new Thread(r, "AsyncTask #" + mCount.getAndIncrement());
        }
    };

    //静态阻塞式队列，用来存放待执行的任务，初始容量：128个  
    private static final BlockingQueue sPoolWorkQueue =
            new LinkedBlockingQueue(128);

    //静态并发线程池，可以用来并行执行任务，3.0开始，AsyncTask默认是串行执行任务，我们可以构造并行的AsyncTask
    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;
    }
    //静态串行的任务执行器，内部实现了线程控制，循环的一个个取出任务交给并发线程池去执行
    public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
    //消息类型 结果
    private static final int MESSAGE_POST_RESULT = 0x1;
    //消息类型 进度
    private static final int MESSAGE_POST_PROGRESS = 0x2;
    //默认的任务执行器，这里使用的是串行的任务执行器，所以AsyncTask是串行的
    private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
    //静态的Handler，AsyncTask必须在UI线程中执行是因为Handler用的是UI线程的Looper，子线程没有Looper
    private static InternalHandler sHandler;

    private final WorkerRunnable mWorker;
    private final FutureTask mFuture;

    //任务状态 默认为挂起 标识为易变的volatile
    private volatile Status mStatus = Status.PENDING;
    //原子布尔型 高并发支持 任务是否被取消
    private final AtomicBoolean mCancelled = new AtomicBoolean();
    //任务是否贝执行过
    private final AtomicBoolean mTaskInvoked = new AtomicBoolean();

   //串行的任务执行器，当asyncstask执行的时候会加入到任务队列中一个个执行
    private static class SerialExecutor implements Executor {
      //线性的双向队列 用来存储所有的AsyncTask任务
        final ArrayDeque mTasks = new ArrayDeque();
        //当前正在执行的任务
        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);
            }
        }
    }

    //任务的状态  等待执行，正在执行，执行完成
    public enum Status {
        PENDING,
        RUNNING,
        FINISHED,
    }

    //同步锁 初始化Handler
    private static Handler getHandler() {
        synchronized (AsyncTask.class) {
            if (sHandler == null) {
                sHandler = new InternalHandler();
            }
            return sHandler;
        }
    }

    /** @hide */
    //隐藏的类 设置默认线程执行器
    public static void setDefaultExecutor(Executor exec) {
        sDefaultExecutor = exec;
    }

   //AsyncTask的构造函数
    public AsyncTask() {
        mWorker = new WorkerRunnable() {
            public Result call() throws Exception {
                //...
                //result = doInBackground(mParams);
                //...
                return result;
            }
        };

        mFuture = new FutureTask(mWorker) {
            @Override
            protected void done() {
                //...
            }
        };
    }

    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(this, result));
        message.sendToTarget();
        return result;
    }
    //返回当前任务状态
    public final Status getStatus() {
        return mStatus;
    }
    //抽象类  在子线程中执行
    @WorkerThread
    protected abstract Result doInBackground(Params... params);

    //在Execute之前执行 
    @MainThread
    protected void onPreExecute() {
    }

    //任务完毕 返回结果 
    @MainThread
    protected void onPostExecute(Result result) {
    }
    
    //更新任务进度
    @MainThread
    protected void onProgressUpdate(Progress... values) {
    }
    //Cancel被调用并且doInBackground执行完毕，onCancelled被调用，表示任务取消，onPostExecute不会被调用
    @MainThread
    protected void onCancelled(Result result) {
        onCancelled();
    }    
    
    @MainThread
    protected void onCancelled() {
    }

    public final boolean isCancelled() {
        return mCancelled.get();
    }
  
    //取消正在执行的任务
    public final boolean cancel(boolean mayInterruptIfRunning) {
        mCancelled.set(true);
        return mFuture.cancel(mayInterruptIfRunning);
    }

    public final Result get() throws InterruptedException, ExecutionException {
        return mFuture.get();
    }

    //sDefaultExecutor默认串行执行器 如果我们要改成并发的执行方式直接使用executeOnExecutor这个方法
    @MainThread
    public final AsyncTask execute(Params... params) {
        return executeOnExecutor(sDefaultExecutor, params);
    }
    //可以指定执行器
    @MainThread
    public final AsyncTask 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;
    }

    //更新任务进度  onProgressUpdate会被调用
    @WorkerThread
    protected final void publishProgress(Progress... values) {
        if (!isCancelled()) {
            getHandler().obtainMessage(MESSAGE_POST_PROGRESS,
                    new AsyncTaskResult(this, values)).sendToTarget();
        }
    }

    //任务执行完毕  如果没有被取消执行onPostExecute()方法
    private void finish(Result result) {
        if (isCancelled()) {
            onCancelled(result);
        } else {
            onPostExecute(result);
        }
        mStatus = Status.FINISHED;
    }
    //AsyncTask内部Handler
    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;
            }
        }
    }

    private static abstract class WorkerRunnable implements Callable {
        Params[] mParams;
    }
    @SuppressWarnings({"RawUseOfParameterizedType"})
    private static class AsyncTaskResult {
        final AsyncTask mTask;
        final Data[] mData;
        AsyncTaskResult(AsyncTask task, Data... data) {
            mTask = task;
            mData = data;
        }
    }
}

好了，源码我们分析完毕，请仔细看注释和重要函数的执行位置。其实梳理了下AsyncTask源码我们发现，它其实是内部封装了Thead和Handler，这样对外暴露一些必要的方法，符合我们六大设计原则中的迪米特原则，也就是最少知识原则，我们在使用的过程中不必关心它的内部实现，只需要在doInBackground()中做计算操作，onProgressUpdate()中更新UI就可以了。

AsyncTask的一些问题

• API 16 以前必须在主线程加载 AsyncTask，API 16 以后就不用了;
• 因为每个AsyncTask只能执行一次，多次调用同一个AsyncTask对象会出现异常。但如果要处理多个后台任务，你需要创建多个AsyncTask并执行execute()；
• API 4-11 默认是AsnckTask任务并发执行，API11后默认是顺序执行，任务是顺序执行，必须等一个任务结束才能执行下一个。但是可以通过executeOnExecutor（AsyncTask.THREAD_POOL_EXECUTOR）来进行并行执行任务，在并行执行任务时，有最大执行个数的限制
• AsyncTask需要在UI线程调用execute()函数，因为onPreExecute()在UI线程执行

参考
任玉刚《Android开发艺术探索》
基于最新版本的AsyncTask源码解读及AsyncTask的黑暗面