我正在参与「启航计划」

00、 前言

在之前的文章，我现已剖析过了 Handler 这种线程间通讯。今日咱们来谈谈另外一种线程间通讯吧—— AsyncTask。

01、 什么是 AsyncTask

通过构词法反向操作——拆解，a-sync-task ，即异步使命。

这是一个在 API 3 引进，但在 API 30 被抛弃的一个抽象类。尽管被抛弃了，但是不妨碍咱们学习一下。由于 API 30 才被抛弃的，尽管咱们自己或许不会再用了。但指不定还会在别人项目中看到，也好了解。同时，训练咱们看源码的才能。

02、怎么使用 AsyncTask

在看源码前，先看看它一般是怎么被使用的吧。举一个使用场景：假如你需要从长途/本地先获取数据（数据量比较大），然后将数据展示出来。

这时，如果咱们直接在 UI 线程去获取数据的话，很有或许会呈现 ANR 的情况。所以，这儿咱们就选用今日的主角—— AsyncTask 吧。

前面讲到了，AsyncTask 是一个抽象类。所以咱们需要继承完成一下它。

private class RequestMoney extends AsyncTask<Uri,Integer,Long>{
    @Override
    protected void onPreExecute() {
        //做耗时使命前
        super.onPreExecute();
    }
    @Override
    protected Long doInBackground(Uri... uris) {
        //在后台做一些耗时操作
        int count = uris.length;
        long totalSize = 0;
        for (int i = 0; i < count; i++){
            totalSize = totalSize+Downloader.downloadMoney(uris[i]);
            publishProgress((int) ((i / (float) count) * 100)); //标识 0
            if (isCancelled()) break;
        }
        return totalSize;
    }
    @Override
    protected void onPostExecute(Long aLong) {
        //使命完毕后
        super.onPostExecute(aLong);
    }
    @Override
    protected void onProgressUpdate(Integer... values) {
        //加载进程
        super.onProgressUpdate(values);
    }
}

上面现已创立好了一个异步使命，那么在需要的地方调用即可了。

String url = "https://www.iwanttoberich.com";
Uri uri = Uri.parse(url);
RequestMoney money = new RequestMoney();
money.execute(uri);//标识 1

这样就可以了，看上去是不是还挺便利的呢？那至于为什么会被弃用了？官方给出的答复是：简单导致内存走漏；忘记回调；横竖屏切换会导致溃散等等。

03、源码

接下来，咱们看看源码中它是怎么完成的吧。

首先看一下结构办法。

【Android】线程间通信 - AsyncTask
【Android】线程间通信 - AsyncTask

可以看到它一共有三个参数，分别是【入参】，【进度】，【结果】。

通过图中的标示，咱们很简单知道后面两个参数主要是用于咱们更新加载进程和结果的。

那这三个参数最终都是去哪了呢？在上面 RequestMoney 中，咱们重写了 4 个办法。其中有 3 个办法是有参数的。刚好对应着上面的三个参数。

接下来就看看它是怎么在主线程和子线程来回作业的。咱们看到上面的标识 1，咱们跟进一下吧。

//AsyncTask.java
@MainThread
public final AsyncTask<Params, Progress, Result> execute(Params... params) {
    return executeOnExecutor(sDefaultExecutor, params);//标识 2
}
//跟进标识 2
@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); //标识 3
    return this;
}
//跟进标识 3
@MainThread
public static void execute(Runnable runnable) {
    sDefaultExecutor.execute(runnable);
}

至于中间进程，也就通过线程池的办法，调用 Runnable。这也不是本章的要点。咱们直接看到 mWorker。这儿的 mWorker 是什么？本质上是一个 Callable。是在咱们创立 AsyncTask 时分创立的。

public AsyncTask(@Nullable Looper callbackLooper) {
    //...
    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); //这就会调用到咱们重写的 dOInBackground 办法。
                Binder.flushPendingCommands();
            } catch (Throwable tr) {
                mCancelled.set(true);
                throw tr;
            } finally {
                postResult(result); //标识 5
            }
            return result;
        }
    };
    //...
}

在 doInBackground() 后，无论怎么都会调用 postResult()。那咱们看看这儿边做了哪些作业吧。

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

这儿就太熟悉了，是 Handler ! 那咱们直接看到 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]); //标识 6
                    break;
                case MESSAGE_POST_PROGRESS: //标识 7
                    result.mTask.onProgressUpdate(result.mData);
                    break;
            }
        }
    }

//跟进标识 6
    private void finish(Result result) {
        if (isCancelled()) {
            onCancelled(result);
        } else {
            onPostExecute(result);
        }
        mStatus = Status.FINISHED;
    }

到这儿，就正式完毕了。最好在未撤销的情况下，会调用 onPostExecute() 。

doInBackground(), onPostExecute() 都讲到了。但好像把 onProgressUpdate() 给忘了。是的，咱们回过头看看咱们自己重写的 doInBackground() 中调用了 publishProgress()。

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

最终这个音讯就发送到标识 7 处理，然后调用了 onProgressUpdate()。

04、总结

最终怕上面的文字把大家绕晕了，写两个流程图理一下思路。

【Android】线程间通信 - AsyncTask

【Android】线程间通信 - AsyncTask