Android AsyncTask 源代码分析

AsyncTask源代码分析

public abstract class AsyncTask<Params, Progress, Result> {

    //日志TAG
    private static final String LOG_TAG = "AsyncTask";

    //池中所保存的线程数，包括空闲线程。
    private static final int CORE_POOL_SIZE = ;
    //池中允许的最大线程数。
    private static final int MAXIMUM_POOL_SIZE = ;
    //当线程数大于核心时，此为终止前多余的空闲线程等待新任务的最长时间。
    private static final int KEEP_ALIVE = ;

    //一个线程工厂，用来创建新线程 没啥好说的。
    private static final ThreadFactory sThreadFactory = new ThreadFactory() {
        //这个类是一个线程安全的计数器，用到Unsafe直接与底层打交道。
        private final AtomicInteger mCount = new AtomicInteger();

        //接口实现的方法，就是给线程起了个名字。
        public Thread newThread(Runnable r) {
            return new Thread(r, "AsyncTask #" + mCount.getAndIncrement());
        }
    };

    //一个固定长度的LinkedBlockingQueue(队列)，长度为10。
    private static final BlockingQueue<Runnable> sPoolWorkQueue =
            new LinkedBlockingQueue<Runnable>();

    //一个线程池，关于这个类的细节可以单独研究，这里不细说，就跟连接池的思想一样
    //里面维护着一些线程 可以同时处理一些任务。
    public static final Executor THREAD_POOL_EXECUTOR
            = new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,
                    TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);

    //创建一个实现了Executor接口的类 这个类的介绍在下面
    public static final Executor SERIAL_EXECUTOR = new SerialExecutor();

    //Message的消息类型
    private static final int MESSAGE_POST_RESULT = 0x1;
    private static final int MESSAGE_POST_PROGRESS = 0x2;

    //通知主线程的Handler，细节在下面有解释
    private static final InternalHandler sHandler = new InternalHandler();

    //就是把上面的SERIAL_EXECUTOR拿过来了，和上面的一样
    private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;

    //实现了Callable接口 添加了一个参数Params
    private final WorkerRunnable<Params, Result> mWorker;

    //封装具体的任务，这个类的细节可以单独研究 这里也不做细说。
    //这个类的特点就是可以取消并且可以监控任务状态
    private final FutureTask<Result> mFuture;

    //将状态设置成【还没开始执行】的状态
    private volatile Status mStatus = Status.PENDING;

    //标记任务是否已经取消，后面的一些方法需要用到。
    private final AtomicBoolean mCancelled = new AtomicBoolean();
    //标记任务是否已经执行，后面的一些方法需要用到。
    private final AtomicBoolean mTaskInvoked = new AtomicBoolean();

    //实现Executor接口 对Runnable(任务)在进行一次封装
    //这样的实现可以使任务保持连续，即第一个任务执行完毕接着会执行第二个任务
    //第二个任务执行在执行第三个任务，以此类推。
    private static class SerialExecutor implements Executor {
        //一个数组双端队列没有容量限制
        final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
        //当前正在执行的任务
        Runnable mActive;

        //这里进行了synchronized，因为ArrayDeque不是线程安全的，对它的操作需要同步。
        public synchronized void execute(final Runnable r) {
            //对任务进行包装，然后加入队列的末尾。
            mTasks.offer(new Runnable() {
                public void run() {
                    try {
                        //执行具体任务
                        r.run();
                    } finally {
                        //执行下一个任务【编号001】
                        scheduleNext();
                    }
                }
            });
            //如果当前没有执行的任务，则调用scheduleNext开始执行任务
            //如果不为null 说明已经有任务在执行，那么就不需要调用scheduleNext
            //因为当前任务会被上一个任务在完成时调用。即在【编号001】的位置。
            if (mActive == null) {
                scheduleNext();
            }
        }

        //从队列的头部拿出一个元素，然后执行。这里的任务是在上面包装过的。
        //它会先执行具体任务,然后再执行下一个任务
        protected synchronized void scheduleNext() {
            if ((mActive = mTasks.poll()) != null) {
                THREAD_POOL_EXECUTOR.execute(mActive);
            }
        }
    }

    //当前类的状态
    public enum Status {
        //还没开始执行
        PENDING,
        //执行中
        RUNNING,
        //任务完成
        FINISHED,
    }

    //没啥用
    public static void init() {
        sHandler.getLooper();
    }

    //没啥用
    public static void setDefaultExecutor(Executor exec) {
        sDefaultExecutor = exec;
    }

    //构造参数必须运行在UI线程
    public AsyncTask() {
        //创建一个WorkerRunnable实例
        //这里用到了FutureTask与Callable相关技术。需要自己去研究下
        mWorker = new WorkerRunnable<Params, Result>() {
            public Result call() throws Exception {
                //一旦具体任务执行，就将这个标记置为true
                mTaskInvoked.set(true);//【编号002】
                //设置当前线程优先级为后台线程
                Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
                //首先调用doInBackground这个方法 就是我们需要复写的方法。
                //然后调用postResult方法 并将doInBackground的返回值传入。
                return postResult(doInBackground(mParams));
            }
        };

        //创建一个任务FutureTask,并将上面的mWorker通过构造参数传入。
        mFuture = new FutureTask<Result>(mWorker) {
            //覆写了done方法，这样当任务的状态发生变化时可以进行监控。
            //当任务完成时或取消都进入该方法
            @Override
            protected void done() {
                try {
                    //通过get方法获取任务的返回结果
                    //下面就分2中情况
                    //1-如果上面的call方法正确被调用 那么就执行postResultIfNotInvoked方法
                    //2-如果任务被取消或者任务执行过程中出现异常则会抛出异常，在下面catch到在进行处理
                    postResultIfNotInvoked(get());
                } catch (InterruptedException e) {
                    android.util.Log.w(LOG_TAG, e);
                } catch (ExecutionException e) {
                    //如果在doInBackground方法中存在异常 这里会继续抛出
                    throw new RuntimeException("An error occured while executing doInBackground()",
                            e.getCause());
                } catch (CancellationException e) {
                    //如果方法被取消,那么调用postResultIfNotInvoked并传入null
                    postResultIfNotInvoked(null);
                }
            }
        };
    }

    private void postResultIfNotInvoked(Result result) {
        final boolean wasTaskInvoked = mTaskInvoked.get();
        //这里判断wasTaskInvoked标记，判断任务是否已经正常结束
        //如果在mWorker的call方法正确执行 那么在【编号002】的位置会把wasTaskInvoked设置为true
        //这样的话在done()方法中的postResultIfNotInvoked(get());方法才不会重复执行
        //也就是说方法如果在mWorker的call方法中执行了 那么在done()中在调用postResultIfNotInvoked(get());
        //方法在执行到这的话就不会执行了，反之亦然。
        if (!wasTaskInvoked) {
            postResult(result);
        }
    }

    //该方法是把任务结果发送给UI线程去执行
    //就是Looper Handler Message 没啥好说的
    private Result postResult(Result result) {
        @SuppressWarnings("unchecked")
        Message message = sHandler.obtainMessage(MESSAGE_POST_RESULT,
                new AsyncTaskResult<Result>(this, result));
        message.sendToTarget();
        return result;
    }

    //过去当前任务的执行状态
    public final Status getStatus() {
        return mStatus;
    }

    //需要子类付覆写的方法，后台线程运行。
    protected abstract Result doInBackground(Params... params);

    //在doInBackground方法执行运行，UI线程运行该方法。
    //可以启动个进度条之类的操作可以写在这里。
    protected void onPreExecute() {
    }

    //UI线程执行，在doInBackground放执行以后执行。
    //要注意的是在任务没有出现异常 也没有被取消的情况下才会执行
    //否则执行onCancelled
    @SuppressWarnings({"UnusedDeclaration"})
    protected void onPostExecute(Result result) {
    }

    //运行在UI线程 通过在doInBackground中调用publishProgress方法通知UI线程做一些处理
    //比如更新带百分比的进度条等
    @SuppressWarnings({"UnusedDeclaration"})
    protected void onProgressUpdate(Progress... values) {
    }

    @SuppressWarnings({"UnusedParameters"})
    protected void onCancelled(Result result) {
        onCancelled();
    }    

    //一般子类覆写这个方法 就是cancel方法被调用后 任务被取消 则会执行该方法
    protected void onCancelled() {
    }

    //获取任务是否取消
    public final boolean isCancelled() {
        return mCancelled.get();
    }

    //终止任务
    //参数的意义是这样的
    //如果线程还没有被启动,那么无论mayInterruptIfRunning是啥 任务都会被取消
    //如果任务已经启动 那么如果mayInterruptIfRunning=true 那么会调用线程的
    //interrupt方法，这个方法是的解释可以看API 太多了 这里不细说。
    public final boolean cancel(boolean mayInterruptIfRunning) {
        mCancelled.set(true);
        return mFuture.cancel(mayInterruptIfRunning);
    }

    //这个方法获取任务的结果，是一个阻塞方法
    //属于FutureTask的范畴
    public final Result get() throws InterruptedException, ExecutionException {
        return mFuture.get();
    }

    //同上
    public final Result get(long timeout, TimeUnit unit) throws InterruptedException,
            ExecutionException, TimeoutException {
        return mFuture.get(timeout, unit);
    }

    //启动任务
    public final AsyncTask<Params, Progress, Result> execute(Params... params) {
        //调用executeOnExecutor
        return executeOnExecutor(sDefaultExecutor, params);
    }

    //这个方法是AsyncTask的启动方法，用来启动任务
    public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,
            Params... params) {
        //判断任务的状态 如果不是PENDING状态则抛出异常
        //也就是说任务只能启动一次，不可重复启动。
        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)");
            }
        }

        //设置任务状态为RUNNING
        mStatus = Status.RUNNING;
        //调用预处理方法上面解释过。
        onPreExecute();
        //给mWorker设置参数
        mWorker.mParams = params;
        //将任务加入到sDefaultExecutor当中去执行
        exec.execute(mFuture);
        //返回自己
        return this;
    }

    //这个方法是用过sDefaultExecutor执行直接执行一个Runnable接口，去AsyncTask没啥关系
    //无非就是用到了sDefaultExecutor
    public static void execute(Runnable runnable) {
        sDefaultExecutor.execute(runnable);
    }

    //这个方法可以通知UI线程更新进度
    protected final void publishProgress(Progress... values) {
        if (!isCancelled()) {
            sHandler.obtainMessage(MESSAGE_POST_PROGRESS,
                    new AsyncTaskResult<Progress>(this, values)).sendToTarget();
        }
    }

    //任务完成后调用的方法，会根据isCancelled()的返回值判断任务是否被取消或者正常执行成功。
    private void finish(Result result) {
        if (isCancelled()) {
            onCancelled(result);
        } else {
            onPostExecute(result);
        }
        mStatus = Status.FINISHED;
    }

    //Handler没啥好说的
    private static class InternalHandler extends Handler {
        @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[]);
                    break;
                case MESSAGE_POST_PROGRESS:
                    result.mTask.onProgressUpdate(result.mData);
                    break;
            }
        }
    }

    //一个抽象类实现了Callable<Result>接口 添加了参数。
    private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {
        Params[] mParams;
    }

    //一个用于封装任务与结果的类
    @SuppressWarnings({"RawUseOfParameterizedType"})
    private static class AsyncTaskResult<Data> {
        final AsyncTask mTask;
        final Data[] mData;

        AsyncTaskResult(AsyncTask task, Data... data) {
            mTask = task;
            mData = data;
        }
    }
}

AsyncTask 核心原理大概如下

InternalHandler sHandler = new InternalHandler(); 这个handler是主线程初始化的，用来调用更新UI的方法。

THREAD_POOL_EXECUTOR 一个线程池用来处理异步任务。

sPoolWorkQueue 一个任务队列，我们发起的所有任务都会放到这个队列当中，由THREAD_POOL_EXECUTOR 它来进行处理。

流程就是当我们创建一个AsyncTask实例 ，那么AsyncTask会生成一个任务对象(Runnable)放入sPoolWorkQueue 这个队列当中，然后有THREAD_POOL_EXECUTOR 线程池去进行异步处理，在处理的过程中通过sHandler 通知主线程去调用我们复写的那几个方法更新UI。

这个类在设计当中还使用到了 FutureTask

关于这个类的源码分析请看我的另外一个博客：http://www.cnblogs.com/daxin/p/3802392.html