安卓学习笔记之AsyncTask机制浅析

Posted 2020-08-07 pecuyu

一、相关基础

1 用途

用于快速开启异步任务,处理耗时操作。在线程池中处理异步任务，同时可以将进度和处理结果提交到主线程处理。

2 AsyncTask 泛型参数-Params, Progress, Result

Params 表示传入doInBackground参数的类型
Progress 表示后台任务执行进度的类型
Result 表示后台任务执行完成后返回结果的类型

若不需要传入具体的参数，传入Void即可

3 常见方法

onPreExecute 执行任务之前，UI线程，在doInBackground执行之前
doInBackground 执行后台任务，子线程，can call publishProgress to publish updates on the UI thread
onProgressUpdate 进度更新，UI线程
onPostExecute 任务完成时，UI线程
onCancelled 任务取消时，并且onPostExecute不会执行，UI线程

4 几个重要名词

InternalHandler AsyncTask内部Handler，处理任务的提交与更新的消息
SerialExecutor 串行线程池，用于任务调度，任务排队，一次只能执行一个任务
THREAD_POOL_EXECUTOR 线程池的实现者，用于真正执行任务
WorkerRunnable 实现了Callable接口，用于后台计算

5 大致流程

1、 onPreExecute ， 执行任务之前，运行在UI线程，在doInBackground执行之前

2、 Result = doInBackground() ， 执行后台任务，返回执行结果，在线程池中执行，配合publishProgress来更新任务进度

3、 onProgressUpdate ， 在doInBackground方法中调用publishProgress方法，用于进度更新，运行在UI线程（通过内部handler切换到主线程）

4、 onPostExecute ， 运行在UI线程，处理运行结果（通过内部handler切换到主线程）

二、 执行流程浅析

1. 首先构造AsyncTask对象，此构造器必须在主线程调用

/**
 * Creates a new asynchronous task. This constructor must be invoked on the UI thread.
 */
public AsyncTask() {
//实例化WorkerRunnable对象
    mWorker = new WorkerRunnable<Params, Result>() {
        public Result call() throws Exception {
            mTaskInvoked.set(true);

            Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
            //noinspection unchecked
            return postResult(doInBackground(mParams));
        }
    };

// 实例化FutureTask
    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 occured while executing doInBackground()",
                        e.getCause());
            } catch (CancellationException e) {
                postResultIfNotInvoked(null);
            }
        }
    };
}

mWorker即WorkerRunnable对象，它是一个抽象类，并实现了Callable接口,用于计算一个任务

 private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {
    Params[] mParams;
}

mFuture即FutureTask对象，下面用到了如下构造，

  public FutureTask(Callable<V> callable) {
    if (callable == null)
        throw new NullPointerException();
    this.callable = callable;
    this.state = NEW;       // ensure visibility of callable
}

2. 执行一个任务要从它的execute方法开始

execute方法如下，它调用了executeOnExecutor方法，可以看到默认使用了sDefaultExecutor，即SerialExecutor

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

executeOnExecutor方法,此方法首先检查运行状态并赋以新状态，之后回调onPreExecute方法，并给mWorker赋以参数，最后让Executor执行任务，并返回AsyncTask对象。

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); // 传参FutureTask对象

    return this;
}

exec即Executor对象，默认使用SerialExecutor（串行线程池），用于调度任务排队顺序执行。通过exec.execute(mFuture)开启任务调度，当有任务执行时，其他任务等待。mTasks即ArrayDeque，它是一个双端队列。第一次添加任务时，mTasks.offer将新任务添加到任务队列尾部，此时mActive这个Runnable为空，所以会直接走判断是否为空中的scheduleNext方法，并在此方法中通过THREAD_POOL_EXECUTOR.execute(mActive)开启执行任务。后续任务会走finally中的scheduleNext，此时mActive不为空。当执行r.run()方法，即调用了FutureTask对象的run方法

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

FutureTask对象的run方法如下，callable对象即是在构造FutureTask对象时传入的mWorker，c.call()即在run方法中调用了mWorker的call方法，并将结果保存在result,call方法运行于子线程

public void run() {
    if (state != NEW ||
        !UNSAFE.compareAndSwapObject(this, runnerOffset,
                                     null, Thread.currentThread()))
        return;
    try {
        Callable<V> c = callable;  // callable对象即是在构造FutureTask对象时传入的mWorker
        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);
    }
}

WorkerRunnable对象的call方法如下，它调用了doInBackground方法并将其返回值作为参数传给postResult方法。到此调用了doInBackground方法，它运行在线程池中

public Result call() throws Exception {
        mTaskInvoked.set(true);

        Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
        //noinspection unchecked
        return postResult(doInBackground(mParams));
    }

postResult方法,它会给AsyncTask内部的InternalHandler发送任务完成信息

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

3. InternalHandler消息处理

InternalHandler如下，当消息类型为MESSAGE_POST_RESULT，通过finish方法完成执行结果的提交。当消息类型为MESSAGE_POST_PROGRESS时，回调更新进度onProgressUpdate方法。通过内部handler切换到主线程

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

finish方法如下，当任务没有取消时，调用onPostExecute，否则调用onCancelled。都运行在主线程

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

4. 进度更新

publishProgress,在doInBackground方法中调用，用以更新进度。此方法会向InternalHandler发送MESSAGE_POST_PROGRESS消息，以在UI线程更新进度

/**
 * This method can be invoked from {@link #doInBackground} to
 * publish updates on the UI thread while the background computation is
 * still running. Each call to this method will trigger the execution of
 * {@link #onProgressUpdate} on the UI thread.
 *
 * {@link #onProgressUpdate} will note be called if the task has been
 * canceled.
 *
 * @param values The progress values to update the UI with.
 *
 * @see #onProgressUpdate
 * @see #doInBackground
 */
protected final void publishProgress(Progress... values) {
    if (!isCancelled()) {
        sHandler.obtainMessage(MESSAGE_POST_PROGRESS,
                new AsyncTaskResult<Progress>(this, values)).sendToTarget();
    }
}

简单案例

案例简单模拟求和运算，并查看各个方法运行的线程
在MainActivity中自定义异步任务类继承AsyncTask

class BackTask extends AsyncTask<Integer, Integer, Integer> {

        @Override
        protected void onPreExecute() {
            Log.e("TAG", "onPreExecute-任务执行之前,当前线程:"+Thread.currentThread().getName());
            super.onPreExecute();
        }

        @Override
        protected Integer doInBackground(Integer... params) {
            Log.e("TAG", "doInBackground-任务执行中... ,当前线程:"+Thread.currentThread().getName());
            int N = params[0];
            int count = 0;
            int total = 0; // 计算总和
            Integer progress = 0; // 进度
            while (count < N) {
                ++count;
                total += count;
                progress = count * 100 / N;
                publishProgress(progress);

            }
            return total;
        }

        @Override
        protected void onPostExecute(Integer result) {
            super.onPostExecute(result);

            Log.e("TAG", "onPostExecute-执行结果，运算总和为" + result+" ,当前线程: "+Thread.currentThread().getName());
        }

        @Override
        protected void onProgressUpdate(Integer... values) {
            super.onProgressUpdate(values);
            Log.e("TAG", "onProgressUpdate-当前进度:" + values[0] + "%"+",当前线程:"+Thread.currentThread().getName());
        }
    }

在onCreate方法中开启任务

new BackTask().execute(100);

运行结果如下

09-07 08:33:53.508: E/TAG(2710): onPreExecute-任务执行之前,当前线程:main
09-07 08:33:53.508: E/TAG(2710): doInBackground-任务执行中... ,当前线程:AsyncTask #2
09-07 08:33:53.578: E/TAG(2710): onProgressUpdate-当前进度:1%,当前线程:main
09-07 08:33:53.578: E/TAG(2710): onProgressUpdate-当前进度:2%,当前线程:main
09-07 08:33:53.578: E/TAG(2710): onProgressUpdate-当前进度:3%,当前线程:main
09-07 08:33:53.578: E/TAG(2710): onProgressUpdate-当前进度:4%,当前线程:main
09-07 08:33:53.578: E/TAG(2710): onProgressUpdate-当前进度:5%,当前线程:main
09-07 08:33:53.578: E/TAG(2710): onProgressUpdate-当前进度:6%,当前线程:main
09-07 08:33:53.578: E/TAG(2710): onProgressUpdate-当前进度:7%,当前线程:main
09-07 08:33:53.578: E/TAG(2710): onProgressUpdate-当前进度:8%,当前线程:main
09-07 08:33:53.578: E/TAG(2710): onProgressUpdate-当前进度:9%,当前线程:main
09-07 08:33:53.578: E/TAG(2710): onProgressUpdate-当前进度:10%,当前线程:main
            ... ... ... ... (省略部分输出)
09-07 08:33:53.608: E/TAG(2710): onProgressUpdate-当前进度:90%,当前线程:main
09-07 08:33:53.608: E/TAG(2710): onProgressUpdate-当前进度:91%,当前线程:main
09-07 08:33:53.608: E/TAG(2710): onProgressUpdate-当前进度:92%,当前线程:main
09-07 08:33:53.608: E/TAG(2710): onProgressUpdate-当前进度:93%,当前线程:main
09-07 08:33:53.608: E/TAG(2710): onProgressUpdate-当前进度:94%,当前线程:main
09-07 08:33:53.608: E/TAG(2710): onProgressUpdate-当前进度:95%,当前线程:main
09-07 08:33:53.608: E/TAG(2710): onProgressUpdate-当前进度:96%,当前线程:main
09-07 08:33:53.608: E/TAG(2710): onProgressUpdate-当前进度:97%,当前线程:main
09-07 08:33:53.608: E/TAG(2710): onProgressUpdate-当前进度:98%,当前线程:main
09-07 08:33:53.608: E/TAG(2710): onProgressUpdate-当前进度:99%,当前线程:main
09-07 08:33:53.608: E/TAG(2710): onProgressUpdate-当前进度:100%,当前线程:main
09-07 08:33:53.608: E/TAG(2710): onPostExecute-执行结果，运算总和为5050 ,当前线程: main