AsncTask源码解析

-------------------------------------AsncTask源码解析-----------------------------------
class AsyncTask<Params, Progress, Result> //从这里可以看出它上面有三个泛型


    public static final Executor SERIAL_EXECUTOR = new SerialExecutor();//这里创建一个线程执行器
    private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
    private final WorkerRunnable<Params, Result> mWorker;//这主要用来保存参数们和实现Callable接口
    private final FutureTask<Result> mFuture;//这主要进行程序错误处理它构造方法里面传入了mWorker
     public static final Executor THREAD_POOL_EXECUTOR= new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);//这里创建一个线程池


    private volatile Status mStatus = Status.PENDING;//这个属性是个枚举


   public AsyncTask() {//从这里可以看出它在构造方法中进行一些的初始化
        mWorker = new WorkerRunnable<Params, Result>() {//它其实封装了参数和实现Callabe方法它主要做两件事运行doInBackgroud方法和把结果发送给handler


            public Result call() throws Exception {
                 ......
                Result result = doInBackground(mParams);//这里把doInBackground放入线程池中执行
                return postResult(result);//这里间接调用消息机制来发送消息给主线程
            }
        };


        mFuture = new FutureTask<Result>(mWorker) {//这个类其实和WorkRunnable一样只是在下面方法进行了错误判断
            @Override
            protected void done() {
              ...
            }
        };
    }


    //这里是它的execute方法它其实会调用executeOnExecutor方法
    public final AsyncTask<Params, Progress, Result> execute(Params... params) {
        return executeOnExecutor(sDefaultExecutor, params);
    }


    public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,Params... params) {
        if (mStatus != Status.PENDING) {//这里对它的状态进行判断如果不是PENDING就抛异常
           ...
        }
        //先修改它的标记为RUNNING防止它被再次调用
        mStatus = Status.RUNNING;


        onPreExecute();//从这里可以看出它是运行在主线程中


        mWorker.mParams = params;//保持参数
        exec.execute(mFuture);//这里会调用该进的线程池。从上面可以知道他是SERIAL_EXECUTOR;它传入的参数是Callable的实现类 WorkerRunnable
        return this;
    }


     protected final void publishProgress(Progress... values) {//这个方法也是采用消息来更新UI界面
        if (!isCancelled()) {
            getHandler().obtainMessage(MESSAGE_POST_PROGRESS,new AsyncTaskResult<Progress>(this, values)).sendToTarget();
        }
    }


   private Result postResult(Result result) {//这里也是采用消息来更新UI界面
      
        Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,new AsyncTaskResult<Result>(this, result));//这里传入了两个参数（第一个为你创建的异步任务对象，第二个为结果）
        message.sendToTarget();//向handler发送一个消息（这个handler其实就是InternalHandler ）
        return result;
    }


  private void finish(Result result) {
        if (isCancelled()) {
            onCancelled(result);
        } else {
            onPostExecute(result);//这里调用你写的onPaostExecute方法
        }
        mStatus = Status.FINISHED;//修改标记为完成状态FINISHED
    }


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






额外知识：(这里都是在AsyncTask的里面要么是内部类要么是嵌套类)
 public enum Status { PENDING, RUNNING,FINISHED,}


 private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {//这里只是添加里一个属性
        Params[] mParams;
    }


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


 private static class AsyncTaskResult<Data> {//它里面保持一个时AsncTask一个时数据
        final AsyncTask mTask;//它是个AsyncTask对象
        final Data[] mData;//要发送的数据


        AsyncTaskResult(AsyncTask task, Data... data) {
            mTask = task;
            mData = data;
        }
    }
 private static class InternalHandler extends Handler {
        public InternalHandler() {
            super(Looper.getMainLooper());
        }


        @Override
        public void handleMessage(Message msg) {
            AsyncTaskResult<?> result = (AsyncTaskResult<?>) msg.obj;
            switch (msg.what) {
                case MESSAGE_POST_RESULT:
                    
                    result.mTask.finish(result.mData[0]);//它调用AsyncTask
                    break;
                case MESSAGE_POST_PROGRESS:
                    result.mTask.onProgressUpdate(result.mData);//这里对进度条进行更新
                    break;
            }
        }
    }