Android9.0 AsyncTask源码分析

最新推荐文章于 2021-06-20 22:17:56 发布

网络卷毛

最新推荐文章于 2021-06-20 22:17:56 发布

阅读量147

点赞数

分类专栏： Android基础

本文链接：https://blog.youkuaiyun.com/yuemingxingxing/article/details/111248464

版权

Android基础专栏收录该内容

65 篇文章

订阅专栏

一.基本使用

public class MainActivity extends AppCompatActivity {

    private static final String TAG = MainActivity.class.getSimpleName();

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

        MyTask myTask = new MyTask();
        myTask.execute();

    }

    static class MyTask extends AsyncTask<String,Integer,Integer> {

        @Override
        protected void onPreExecute() {
            super.onPreExecute();
            Log.d(TAG,"loading start");
        }

        @Override
        protected Integer doInBackground(String... strings) {
            int progress = 0;
            for ( progress = 0; progress <= 100; progress++) {
                publishProgress(progress);
            }
            return progress;
        }


        @Override
        protected void onProgressUpdate(Integer... values) {
            super.onProgressUpdate(values);
            Log.d(TAG, "progress = " + values[0]);
        }


        @Override
        protected void onPostExecute(Integer s) {
            super.onPostExecute(s);
            Log.d(TAG,"result  progress = " + s);
        }

        @Override
        protected void onCancelled() {
            super.onCancelled();
            Log.d(TAG, "cancell");
        }

    }

}

二.源码分析

1.从myTask.exectue()执行逻辑开始，进入源码

   @MainThread
    public final AsyncTask<Params, Progress, Result> execute(Params... params) {
        return executeOnExecutor(sDefaultExecutor, params);
    }

    @MainThread
    public final AsyncTask<Params, Progress, Result> 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;
    }

可以看到最终调用了exec.execute(mFuture)来在线程中执行逻辑，在线程开启前，会调用onPreExecute()方法，我们可以在这里处理预置操作，比如弹起Loading提示。我们看到开启线程是通过线程池来实现到，线程池的定义为

    private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;

是叫SERIAL_EXECUTOR的线程池赋值，我们再看它的初始化

    public static final Executor SERIAL_EXECUTOR = new SerialExecutor();

看下SerialExecutor的定义

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

我们看到调用execute方法时，通过队列ArrayDeque把线程执行事件进入队列，并且用synchronized修饰，则事件是按照串行的方式入队的，在事件入队后，判断mActive=null，没有任务在执行，则调用scheduleNext()方法，而THREAD_POOL_EXECUTOR.execute(mActive)中的THREAD_POOL_EXECUTOR是真正的线程池去执行事件的，它执行完一个事件后,在finally后，我们看到又执行了schduleNext()方法，取出队列下一个事件执行，直到队列中没有事件结束.我们这里看下THREAD_POOL_EXECUTO线程池是怎么生成的。

public static final Executor THREAD_POOL_EXECUTOR;

    static {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE_SECONDS, TimeUnit.SECONDS,
                new SynchronousQueue<Runnable>(), sThreadFactory);
        threadPoolExecutor.setRejectedExecutionHandler(sRunOnSerialPolicy);
        THREAD_POOL_EXECUTOR = threadPoolExecutor;
    }

在AsyncTask创建的时候，就初始化了线程池.这样我们就知道了事件的执行是通过线程池去创建线程执行的，那么接下来看下具体事件是怎么执行的。

2.第一步我们看到exec.execute(mFuture)执行了事件，我们看下mFuture是什么

    @UnsupportedAppUsage
    private final FutureTask<Result> mFuture;

 mFuture = new FutureTask<Result>(mWorker) {
            @Override
            protected void done() {
                try {
                    postResultIfNotInvoked(get());
                } catch (InterruptedException e) {
                    android.util.Log.w(LOG_TAG, e);
                } catch (ExecutionException e) {
                    throw new RuntimeException("An error occurred while executing doInBackground()",
                            e.getCause());
                } catch (CancellationException e) {
                    postResultIfNotInvoked(null);
                }
            }
        };

可见mFutrue是FutureTask，而FutureTask真正执行的是构造函数中的Callable，也就是mWorker，我们看下mWorker的实现

    @UnsupportedAppUsage
    private final WorkerRunnable<Params, Result> mWorker;

 mWorker = new WorkerRunnable<Params, Result>() {
            public Result call() throws Exception {
                mTaskInvoked.set(true);
                Result result = null;
                try {
                    Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
                    //noinspection unchecked
                    result = doInBackground(mParams);
                    Binder.flushPendingCommands();
                } catch (Throwable tr) {
                    mCancelled.set(true);
                    throw tr;
                } finally {
                    postResult(result);
                }
                return result;
            }
        };

从中可以看到我们熟悉的方法result = doInBackground(mParams);这样doInBackgroud()方法就实现了在线程中执行，其传入的值mParams，我们可追溯下面

      public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,
            Params... params) {
           
         ...
        mStatus = Status.RUNNING;
        onPreExecute();

        mWorker.mParams = params;
        exec.execute(mFuture);
       

        return this;
    }

在线程池执行事件前mWorker.mParams = params传入了。我们看到doInBackgroud()方法执行完后，在finally最后调用了postResult(result)方法,我们看下其实现


    private Result postResult(Result result) {
        @SuppressWarnings("unchecked")
        Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
                new AsyncTaskResult<Result>(this, result));
        message.sendToTarget();
        return result;
    }

可见其内部用Handler发送标志为MESSAGE_POST_RESULT的Message，我们先看下getHandler()的实现

  public AsyncTask(@Nullable Looper callbackLooper) {
        mHandler = callbackLooper == null || callbackLooper == Looper.getMainLooper()
            ? getMainHandler()
            : new Handler(callbackLooper);
        ...
}

这里在AsyncTask构造方法中定义了Handler，如果没有传入Looper，则用UI线程的Looper，也就是Handler在UI线程中接收信息。看完Handler的定义，我们接着看MESSAGE_POST_RESULT在哪里接收的

 private static class InternalHandler extends Handler {
        public InternalHandler(Looper looper) {
            super(looper);
        }

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

可见收到MESSAGE_POST_RESULT的Message，执行了result.mTask.finish(result.mData[0]),其finish方法我们进入看

private void finish(Result result) {
        if (isCancelled()) {
            onCancelled(result);
        } else {
            onPostExecute(result);
        }
        mStatus = Status.FINISHED;
    }

这里看出如果Task执行Cancell方法，则调用onCancelled(result)结束，否则就调用onPostExecute(result)完成事件的执行。

这样我们从事件开始前onPreExecute(),到线程执行doInBackground()，到执行完事件到onPostExecute()流程就清楚了。

3.我们看到还有publishProgress()，onProgressUpdate()方法进程在项目中使用，那它们是怎么执行的呢,我们进入publishProgress()方法看下

 protected final void publishProgress(Progress... values) {
        if (!isCancelled()) {
            getHandler().obtainMessage(MESSAGE_POST_PROGRESS,
                    new AsyncTaskResult<Progress>(this, values)).sendToTarget();
        }
    }

   private static class InternalHandler extends Handler {
        public InternalHandler(Looper looper) {
            super(looper);
        }

        @SuppressWarnings({"unchecked", "RawUseOfParameterizedType"})
        @Override
        public void handleMessage(Message msg) {
            AsyncTaskResult<?> result = (AsyncTaskResult<?>) msg.obj;
            switch (msg.what) {
                 ...
                case MESSAGE_POST_PROGRESS:
                    result.mTask.onProgressUpdate(result.mData);
                    break;
            }
        }
    }

从这，我们就很清楚知道了Progress的valuse值也是通过Handler传递了Message，最终执行 result.mTask.onProgressUpdate(result.mData)，更新onProgressUpdate()。