AsyncTask原理分析

AsyncTask原理

InternalHandler handler
ThreadPool pool 线程池

AsyncTask的默认构造函数如下：

   public AsyncTask() {
        //实例化mWorker WorkerRunnable的代码看1步
        //mWorker 是 Callable类型
        mWorker = new WorkerRunnable<Params, Result>() {
            public Result call() throws Exception {
                。。。
            }
        };


        // Future
        mFuture = new FutureTask<Result>(mWorker) {
            @Override
            protected void done() {
               。。。
            }
        };
    }
    //1步
     private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {
        Params[] mParams;
    }

### AsyncTask的 execute方法
    public final AsyncTask<Params, Progress, Result> execute(Params... params) {


        mStatus = Status.RUNNING; .
        //主线中调用onPreExecute
        onPreExecute();

        //mWorker Callable类型，把execute方法参数赋值给mWorker对象

        mWorker.mParams = params;
        // sExecutor 线程池
        //mFuture
        sExecutor.execute(mFuture);

        return this;
    }

FutureTask的构造函数

        if (callable == null)
            throw new NullPointerException();
        //callable 就是 mWorker
        sync = new Sync(callable);
    }

Sync类的Callable参数构造函数：

    //callable 还是 mWorker
    Sync(Callable<V> callable) {
            this.callable = callable;
    }

FutureTask的run方法

public void run() {
        sync.innerRun();
    }

Sync类的innerRun方法

     void innerRun() {
             。。。。
                V result;
                try {
                   //子线程的执行结果
                    //1.mWorker.call
                    result = callable.call();//mworker
                } catch (Throwable ex) {
                    setException(ex);
                    return;
                }
                //3.处理result.内部内访问外部类的方法
                set(result);
            } else {
                releaseShared(0); // cancel
            }
        }
        // 1. mWorker的 call方法
         public Result call() throws Exception {
                Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
                //2.子线程执行
                return doInBackground(mParams);
         }

       //4.set(result)保存result，FutureTask类的set方法:
       protected void set(V v) {
          //5. Sync里innerSet方法保存result
          sync.innerSet(v);
      }


      //6.
        //v  就是result
        void innerSet(V v) {
            for (;;) {
                ...
                    result = v;
                    //7. done
                    done();
                    return;

            }
      //8.done方法  在AsyncTask的构造函数中覆盖该方法，代码：
      @Override
            protected void done() {
                Message message;
                Result result = null;

                try {
                   //9.get()
                    result = get();
                }... 
                // 10到12看下面 13.获取Message
                message = sHandler.obtainMessage(MESSAGE_POST_RESULT,
                        new AsyncTaskResult<Result>(AsyncTask.this, result));
                message.sendToTarget();
            }
        };
    //14.InternalHandler的实现(sHandler是其实例)
    private static class InternalHandler extends Handler {
        @SuppressWarnings({"unchecked", "RawUseOfParameterizedType"})
        //15.
        @Override
        public void handleMessage(Message msg) {
            AsyncTaskResult result = (AsyncTaskResult) msg.obj;
            switch (msg.what) {
                case MESSAGE_POST_RESULT:
                    // There is only one result
                    //16.
                    result.mTask.finish(result.mData[0]);
                    break;
                case MESSAGE_POST_PROGRESS:
                    result.mTask.onProgressUpdate(result.mData);
                    break;
                case MESSAGE_POST_CANCEL:
                    result.mTask.onCancelled();
                    break;
            }
        }
    }
    // 17.
      @SuppressWarnings({"RawUseOfParameterizedType"})
    private static class AsyncTaskResult<Data> {
        final AsyncTask mTask;
        final Data[] mData;

        AsyncTaskResult(AsyncTask task, Data... data) {
            mTask = task;
            mData = data;
        }
    }
    // 18. AsyncTask类的finish()方法
    private void finish(Result result) {
        if (isCancelled()) result = null;
        // 调用处理result，主线程
        onPostExecute(result);
        mStatus = Status.FINISHED;
    }
    //10.调用get（）取结果
    public V get() throws InterruptedException, ExecutionException {
        //11.调用sync的innerGet方法
        return sync.innerGet();
    }
    //12.sync.innerGet()
     V innerGet() throws InterruptedException, ExecutionException {
            //返回result，赋值的代码看6步
            return result;
        }

AsyncTask的原理：

1.
onPreExecute()；在主线程中执行，在doInbackground方法之前
2.
result = doInbackground（）;在线程池中执行（子线程）
3，
onPostExecute()；处理result，在主线程中执行（handler机制）

说白了,绕来绕去就只有三个方法,下面根据核心来写个Demo帮助理解:
MyAsyncTask

package com.itheima.asynctaskdemo;

import android.os.Handler;
import android.os.Message;

public abstract class MyAsyncTask {
    private Handler handler = new Handler(){
        public void handleMessage(android.os.Message msg) {
            onPostExecute((String)msg.obj);
        };
    };
    //执行之前初始化，在主线程中执行
    public abstract void onPreExecute();

    //在子线程中执行
    public abstract String doInBackground(String... params);

    //在主线程中执行，处理结果doInBackground的返回结果
    public abstract void onPostExecute(String res);


    public void execute(final String... params){
        //主线程
        onPreExecute();

        new Thread(){
            public void run(){
                //在子线程中执行
                String res = doInBackground(params);
                //在主线程中执行

                Message msg = handler.obtainMessage();
                msg.obj = res;
                msg.sendToTarget();
            }
        }.start();
    }
}

测试类

package com.itheima.asynctaskdemo;

import android.app.Activity;
import android.os.Bundle;
import android.os.SystemClock;
import android.view.Menu;

public class MainActivity extends Activity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        new MyAsyncTask() {

            @Override
            public void onPreExecute() {
                System.out.println(Thread.currentThread().getName() + ": onPreExecute");
            }

            @Override
            public void onPostExecute(String res) {
                System.out.println(Thread.currentThread().getName() + ": onPostExecute" + res);
            }

            @Override
            public String doInBackground(String... params) {
                System.out.println(Thread.currentThread().getName() + ": doInBackground");
                SystemClock.sleep(2000);
                return "去死";
            }
        }.execute("账上","没有","钱");
    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        // Inflate the menu; this adds items to the action bar if it is present.
        getMenuInflater().inflate(R.menu.main, menu);
        return true;
    }

}