AsyncTask源码解析，简单使用

空城丶

于 2017-06-13 17:19:08 发布

阅读量287

点赞数

分类专栏：异步请求文章标签： AsyncTask

本文链接：https://blog.csdn.net/qq_31552599/article/details/73177067

版权

异步请求专栏收录该内容

5 篇文章 0 订阅

订阅专栏

也是很久没有更新博客，今天看完AsyncTask源码，把学到的东西分享一下

AsyncTask 介绍

一个处理异步操作的类。

为了更方便的在子线程中更新UI，Android 1.5版本引入了AsyncTask类，使子线程非常灵活方便的切换到UI线程(主线程）；

AsyncTask 主要方法介绍

onProExecute()

这个方法会在任务执行之前调用，一般都是做初始化，dialog提示这类的操作。

doInBackground()

这个方法会在子线程中运行，不进行UI更新操作，我们应该把耗时的任务放到这个里面执行。任务过程中的结果，继续给onProgressUpdate调用进行UI更新操作。如果doInBackground第三个参数是void,则不用返回结果。

onProgressUpdate()

这个方法可以更新UI，根据doInBackground过程中结果，做相应的UI处理。

onPostExecute()

当后台的任务执行完毕，调用这个方法，根据return返回来的结果做出相应的处理，比如，关闭对话框，Toast提示等等。。

分析AsyncTask源码

首先我们从AsyncTask.execute()方法入手,因为这是启动异步的入口

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

发现三个参数Params,Progerss.Result，一个executeonExecutor()方法

Params 传入参数

Progersss, 任务更新进度值

Result 任务执行完毕的返回值

在进入executeonExecutor()方法

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

发现AsyncTask一个核心方法onProExecute().这就是为什么onProExecute(）方法会第一个运行。在接着一个exec.execute(mFuture)方法出现并且里面带一个mFuture参数。先不管mFuture参数，直接看exec.

exec这个参数是通过executeOnExecutor(Executorexec,Params params)方法传过来的，那么Executor又是哪里赋值呢，继续往上面走，你会发现其实这个Executor是通过executeOnExecutor(sDefaultExecutor,params）中的sDefaultExecutor赋值，然后我们找到sDefaultExecutor

    public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
    private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;

sDefaultExecutor通过SerialExecutor()赋值。这里就清楚了其实exec这个参数间接就是SerialExecutor。然后我们在回到上面的exec.execute(mFuture)方法，也就是SerialExecutor.execute()方法

public synchronized void execute(final Runnable r) {
            mTasks.offer(new Runnable() {
                public void run() {
                    try {
                        r.run();
                    } finally {
                        scheduleNext();
                    }
                }
            });
            if (mActive == null) {
                scheduleNext();
            }
        }

发现一个r.run()，r是execute(Runable r)传过来的，往回看因为SerialExecutot.execute(Runable r) = exec.execute(mFuture)；所以这个mFuture就是execute(Runable r)里面的参数。那么mFuture又是什么呢！

	private final FutureTask<Result> mFuture;

理所当然mFuture.run()

 public void run() {
        if (state != NEW ||
            !U.compareAndSwapObject(this, RUNNER, null, Thread.currentThread()))
            return;
        try {
            Callable<V> c = callable;
            if (c != null && state == NEW) {
                V result;
                boolean ran;
                try {
                    result = c.call();
                    ran = true;
                } catch (Throwable ex) {
                    result = null;
                    ran = false;
                    setException(ex);
                }
                if (ran)
                    set(result);
            }
        } finally {
            // runner must be non-null until state is settled to
            // prevent concurrent calls to run()
            runner = null;
            // state must be re-read after nulling runner to prevent
            // leaked interrupts
            int s = state;
            if (s >= INTERRUPTING)
                handlePossibleCancellationInterrupt(s);
        }
    }

活捉一直c.call()那么问题来了c = callable ,callable又是什么鬼。不要慌车到山前必有路。其实就是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);
                }
            }
        };

只不过这个callable有点坏，伪装成了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;
            }
        };

原来如此，是这个doInBackground(mParams)作祟，AsyncTask第二个主要方法终于是看到了。那么第三个还会远么？当然是否定的。继续往下面看，因为doInBackground(mParams)是子线程，那怎么跟UI线程交互呢，二话不说先调用publishProgerss();

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

子线程跟UI线程通信怎么少得了Handler, 发送MESSAGE_POST_PROGRESS, 接收消息

                case MESSAGE_POST_PROGRESS:
                    result.mTask.onProgressUpdate(result.mData);
                    break;

AsyncTask第三个方法也出来，onProgressUpdate(result,mDate)是不是很兴奋马上就能真相大白了。

不浮躁回到刚刚那个mWorker初始化的地方，你会发现除了有一个doInBackground()方法外，还有一个 finally不管怎么样都会实现里面的代码 postRsult (result)，到底是怎么一个重要的角色，风雨无阻呢！

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

发送一条MESSAGE_POST_RESULT,然后接收信息

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

mTask.finish();一看就知道这个是AsyncTask

  final AsyncTask mTask;

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

一切真相大白，AsyncTask第四个方法 onPostExecute(result);