AysncTask源码解析

new AsyncTask<String, String, String>() {
            @Override
            protected void onPreExecute() {
                //线程执行前对应调用方法
                super.onPreExecute();
            }

            @Override
            protected String doInBackground(String... params) {
                //线程执行方法
                return null;
            }

            @Override
            protected void onPostExecute(String result) {
                //线程执行获取结果后调用方法
                super.onPostExecute(result);
            }
        }.execute("参数1","参数二");

    public final AsyncTask<Params, Progress, Result> execute(Params... params) {
          ....
        //在线程开启前所做的预备操作
        onPreExecute();

        //mWorker?
        //sExecutor?
        //mFuture？

        mWorker.mParams = params;
        //开启线程的操作(sExecutor管理线程的类)
        sExecutor.execute(mFuture);

        return this;
    }


    //AsyncTask构造方法

    public AsyncTask() {
        mWorker = new WorkerRunnable<Params, Result>() {
            public Result call() throws Exception {
                ....
                //开启线程去请求网络
                return doInBackground(mParams);
            }
        };

        //FutureTask继承制Runnabel，run方法必须重写
        mFuture = new FutureTask<Result>(mWorker) {
            @Override
            protected void done() {
                Message message;
                Result result = null;
                ...
                //其实获取到的就是doInBackground的一个返回值result
                result = get();
                  ...
                //发送消息，
                //第一个就是当前消息的一个状态码，AsyncTaskResult封装了doInBackground返回值的对象

                message = sHandler.obtainMessage(MESSAGE_POST_RESULT,
                        new AsyncTaskResult<Result>(AsyncTask.this, result));
                message.sendToTarget();
            }
        };
    }

    //WorkerRunnable实现Callable接口，mWorker是Callable的子类对象
    private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {
        Params[] mParams;
    }

    //FutureTask接受Callable子类对象的构造方法
    public FutureTask(Callable<V> callable) {
        ...
        sync = new Sync(callable);
    }

    //将mWorker作为参数传递给当前Sync，全局变量
    Sync(Callable<V> callable) {
        this.callable = callable;
    }

    //FutureTask继承制Runnabel，run方法必须重写
    public void run() {
        sync.innerRun();
    }

    //innerRun对应实现

    void innerRun() {
           ...
        //调用mWorker对应的call方法，在call方法中实现了调用doInBackground（）；
        //开启线程会有一个返回值
        result = callable.call();
        ...
        //将当前的result作为一个值，进行存储
        set(result);
        ...
    }

    //set方法
    protected void set(V v) {
        //转调innerset方法
        sync.innerSet(v);
    }

    //
    void innerSet(V v) {
        ....
        //当前done方法即是调用，AsyncTask构造方法中，创建FutureTask对象的时候，要去实现的方法
        done();
        ...
    }

    //第一个参数就是AsyncTask对应对象，第二个参数即为doInBackground返回结果
    private static class AsyncTaskResult<Data> {
        final AsyncTask mTask;
        final Data[] mData;

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

    private static class InternalHandler extends Handler {
        @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;
            }
        }
    }

    //将doInBackground返回结果作为参数传递进来
    private void finish(Result result) {
        ...
        //请求网络完成后，填充视图
        onPostExecute(result);
        mStatus = Status.FINISHED;
    }