注册    登录
今天看啥  ›  专栏  ›  胖宅老鼠

Android进阶知识：AsyncTask相关

胖宅老鼠  · 掘金  ·  · 2019-07-29 01:50
阅读 4

Android进阶知识：AsyncTask相关

1.前言

之前这篇Android基础知识：多线程基础总结里提到了Android中几种多线程任务使用方式，这篇就详细看一下其中AsyncTask的使用和原理。

2. 基础使用

AsyncTask从名字就可以看出看来是Android中提供的一个异步任务类，它的使用方法如下：
1.实现自定义AsyncTask，复写对应方法

class MyAsyncTask extends AsyncTask<String, Integer, String> {
        int percent = 0;

        @Override
        protected void onPreExecute() {
            //doInBackground执行之前
            Log.d(TAG, "onPreExecute：" + Thread.currentThread().getName() + " 异步任务准备开始 ");
        }

        @Override
        protected void onProgressUpdate(Integer... values) {
            //doInBackground执行中
            Log.d(TAG, "onProgressUpdate：" + Thread.currentThread().getName() + " 任务进行中：" + values[0] + "%");
        }

        @Override
        protected void onPostExecute(String result) {
            //doInBackground执行之后
            Log.d(TAG, "onPostExecute：" + Thread.currentThread().getName() + " " + result);
        }

        @Override
        protected String doInBackground(String... strings) {
            String param = strings[0];
            Log.d(TAG, "doInBackground：" + Thread.currentThread().getName() + " 异步任务执行中，获得参数：" + param);
            while (percent < 100) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                percent += 10;
                publishProgress(percent);
            }
            Log.d(TAG, "doInBackground：" + Thread.currentThread().getName() + " 异步任务完成！");
            return "任务完成啦";
        }
    }
复制代码

2.创建自定义的AsyncTask对象，调用execute方法开始任务

    MyAsyncTask myAsyncTask = new MyAsyncTask();
    myAsyncTask.execute("测试");
复制代码

运行结果：

关于实现AsyncTask它有三个泛型，分别对应开始传入的参数类型，中间进度类类型和最后任务结束返回的结果类型，实现时需要根据要求进行设置。另外还有四个主要复写的方法分别是doInBackground、onPreExecute、onProgressUpdate和onPostExecute。

  • doInBackground：看名知意，是负责执行异步任务的方法，运行在后台子线程，是必须复写的方法。
  • onPreExecute：在doInBackground方法之前被调用，可以在进行异步任务做一些准备工作，运行在主线程。
  • onPostExecute：在doInBackground方法之后被调用，获得一部人物大的返回结果，可以进行一些处理结果的操作，运行在主线程。
  • onProgressUpdate：在doInBackground方法中调用publishProgress方法后被调用，用于异步任务时更新进度，运行在主线程。

示例代码里在doInBackground方法中模拟了耗时任务并输出了日志，通过日志可以确认复写的几个方法的执行顺序并且发现onPreExecute、onProgressUpdate、onPostExecute这三个方法是运行在主线程中的，而doInBackground方法是运行在子线程中的。这也和预期的一样，所以使用时耗时任务都是写在doInBackground方法里的。另外AsyncTask可以在调用execute方法时传入所需的参数，在doInBackground方法里可以获取到这些传入参数，并且这里的传参是个可变参数对参数个数不做限制。关于AsyncTask的使用就是这些，接下来来看它的运行原理。

3.运行原理

了解运行原理就要查看他的源码，AsyncTask源码不多，一共不到800行就实现了需要的功能。我们按照AsyncTask的使用步骤来看它的源码流程。在实现自己定义的AsyncTask后，第一个步骤就是创建自定义的AsyncTask对象，所以就从构造函数开始看起。

    public AsyncTask() {
        this((Looper) null);
    }
    public AsyncTask(@Nullable Handler handler) {
        this(handler != null ? handler.getLooper() : null);
    }
  
    public AsyncTask(@Nullable Looper callbackLooper) {
        // 给mHandler初始化赋值
        mHandler = callbackLooper == null || callbackLooper == Looper.getMainLooper()
            ? getMainHandler()
            : new Handler(callbackLooper);
        // 创建WorkerRunnable
        mWorker = new WorkerRunnable<Params, Result>() {
            public Result call() throws Exception {
                mTaskInvoked.set(true);
                Result result = null;
                try {
                    // 设置线程优先级 Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
                    //调用doInBackground方法并获得返回结果
                    result = doInBackground(mParams);
                    Binder.flushPendingCommands();
                } catch (Throwable tr) {
                    mCancelled.set(true);
                    throw tr;
                } finally {
                    // 将返回结果post传递
                    postResult(result);
                }
                return result;
            }
        };
        // 创建FutureTask传入WorkerRunnable
        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);
                }
            }
        };
    }
复制代码

AsyncTask有三个构造函数，最常使用的是无参的构造函数，当然也可以调用有参的传入一个Handler或者Looper，不管调用那个最终都会走到参数是Looper的这个构造中来，这个构造函数中首先对成员变量中的mHandler进行赋值，赋值先判断了传入的Looper是否为空，如果为空或者传入的Looper是主线程的Looper就调用getMainHandler直接将主线程的Handler赋值给mHandler,否则就用传入的Looper创建一个Handler给成员变量赋值。

接着程创建了一个WorkerRunnable,看名字就知道应该是个工作线程，看到它复写了call方法再结合下面又把这个WorkerRunnable传入了一个FutureTask可以猜测，它是由一个Callable实现的，点击跟踪找一下这个类，他是一个内部类。

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

可以看到就是一个实现了Callable接口的抽象类，其中封装了我们的传入参数。回到构造函数中WorkerRunnable的call方法中显示设置了当前线程的优先级为后台进程，接着执行了doInBackground方法获得异步任务的返回结果,最后在finally代码块中调用postResult方法将结果传递。

构造函数中的最后一步是创建了一个异步任务对象FutureTask将WorkRunnable传入，在异步任务完成时会调用done方法，复写的done方法中同样先通过get方法获得异步任务结果，再通过postResultIfNotInvoked方法将结果传递。关于Callable和FutureTask不清楚的可以去看前一篇多线程基础中有简单的介绍。

在进行下一步调用execute方法之前，先看一下AsyncTask类还有一个静态代码块，我们知道静态代码块会随类的加载而加载，所以先来看下这个静态代码块。

    // CPU核心数
    private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
    //线程池核心线程数
    private static final int CORE_POOL_SIZE = Math.max(2, Math.min(CPU_COUNT - 1, 4));
    // 线程池最大线程数
    private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;
    // 线程池中线程空闲存活实现
    private static final int KEEP_ALIVE_SECONDS = 30;
    // 线程工厂
    private static final ThreadFactory sThreadFactory = new ThreadFactory() {
        // 原子型指令Integer类型
        private final AtomicInteger mCount = new AtomicInteger(1);
        // 返回一个名为AsyncTask #加上编号的线程
        public Thread newThread(Runnable r) {
            return new Thread(r, "AsyncTask #" + mCount.getAndIncrement());
        }
    };
    // 线程池的阻塞队列长度128
    private static final BlockingQueue<Runnable> sPoolWorkQueue =
            new LinkedBlockingQueue<Runnable>(128);
    /**
     * An {@link Executor} that can be used to execute tasks in parallel.
     */
    public static final Executor THREAD_POOL_EXECUTOR;

    static {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE_SECONDS, TimeUnit.SECONDS,
                sPoolWorkQueue, sThreadFactory);
        threadPoolExecutor.allowCoreThreadTimeOut(true);
        THREAD_POOL_EXECUTOR = threadPoolExecutor;
    }
复制代码

静态代码块中初始化了一个线程池，并将其赋值给成员变量中的THREAD_POOL_EXECUTOR，从注释看是一个用于执行并行任务的线程池。下面就进入execute方法来看看AsyncTask到底是怎么运行的。

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

execute方法中进而调用了executeOnExecutor方法，除了传入了params还传入了一个executeOnExecutor，先来看看executeOnExecutor是什么？

    private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
    /**
     * An {@link Executor} that executes tasks one at a time in serial
     * order.  This serialization is global to a particular process.
     */
    public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
复制代码

它引用了成员变量中的SERIAL_EXECUTOR，而SERIAL_EXECUTOR又是一个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 {
                        // 调用传入的Runnable的run方法
                        r.run();
                    } finally {
                        scheduleNext();
                    }
                }
            });
            // 第一次进入或对列为空mActive为空直接调用scheduleNext
            if (mActive == null) {
                scheduleNext();
            }
        }
        // 从队列中取出任务交给THREAD_POOL_EXECUTOR线程池处理
        protected synchronized void scheduleNext() {
            if ((mActive = mTasks.poll()) != null) {
                THREAD_POOL_EXECUTOR.execute(mActive);
            }
        }
    }
复制代码

SerialExecutor中有一个任务队列mTasks,它的execute方法中将传入的Runnable重新封装入一个新的Runnable,在新的Runnable的run方法中调用原来Runnable的run方法，并且在finally代码块中调用了scheduleNext方法，最终将这个新的Runnable任务加入mTasks任务队列。之后判断了mActive是否为空，为空的话也调用scheduleNext方法。这个mActive看到是在scheduleNext方法中从任务队列中取出的Runnable对象，scheduleNext方法中取出任务后不为空将这个任务交给THREAD_POOL_EXECUTOR这个线程池去处理，THREAD_POOL_EXECUTOR就是静态代码块中初始化的线程池，也是最终处理异步任务的线程池。

接着再回到executeOnExecutor方法中，AsyncTask的execute方法中调用的executeOnExecutor方法。

 @MainThread
    public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,
            Params... params) {
            // 判断AsyncTask的状态不为PENDING抛出对应异常
        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)");
            }
        }
        // 状态为PENDING就将状态修改为RUNNING
        mStatus = Status.RUNNING;
        // 调用onPr方法eExecute
        onPreExecute();
        // 将execute方法中传入的参数传递到构造函数中创建的WorkerRunnable中
        mWorker.mParams = params;
        // 将构造函数中创建的FutureTask交给exec线程池即sDefaultExecutor线程池处理
        exec.execute(mFuture);
        return this;
    }
复制代码

方法中先判断AsyncTask的状态,AsyncTask的状态有以下几种。

  public enum Status {
        /**
         * 表示任务尚未执行
         */
        PENDING,
        /**
         * 表示任务正在执行
         */
        RUNNING,
        /**
         * 表示任务已经完成
         */
        FINISHED,
    }
复制代码

AsyncTask的不是尚未执行状态就抛出对应的异常，否则就调用onPreExecute这个异步任务执行前的方法，然后将接收到的参数传入构造函数中创WorkerRunnable中,最后调用exec.execute方法将异步任务交给exec线程池即sDefaultExecutor线程池处理。接着就会按照之前看过的一样，异步任务会先进入SerialExecutor线程池，在SerialExecutor中放入取出串行任务队列，最终交给THREAD_POOL_EXECUTOR线程池执行任务。

之前看过WorkRunnable任务执行完成后会调用postResult或postResultIfNotInvoked方法。

    private void postResultIfNotInvoked(Result result) {
        final boolean wasTaskInvoked = mTaskInvoked.get();
        if (!wasTaskInvoked) {
            postResult(result);
        }
    }
复制代码

postResultIfNotInvoked方法中还是调用了postResult方法，所以进入这个postResult方法跟踪查看。

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

postResult方法中调用了getHandler方法获得成员变量中的mHandler发送了个消息，消息中将异步任务的返回结果封装成了一个AsyncTaskResult对象放入消息的obj发送。AsyncTaskResult对象将是将当前的AsyncTask和异步任务结果做了个封装。

 private static class AsyncTaskResult<Data> {
        final AsyncTask mTask;
        final Data[] mData;

        AsyncTaskResult(AsyncTask task, Data... data) {
            mTask = task;
            mData = data;
        }
    }
复制代码

还记得mHandler是在哪儿创建的吗？是在AsyncTask的构造函数中通过getMainHandler方法创建的。

private static Handler getMainHandler() {
        synchronized (AsyncTask.class) {
            if (sHandler == null) {
                sHandler = new InternalHandler(Looper.getMainLooper());
            }
            return sHandler;
        }
    }
复制代码

getMainHandler方法中用主线程Looper创建一个InternalHandler。刚才的postResult方法中发送的消息，就交给的是这个Handler处理。

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;
            }
        }
    }
复制代码

InternalHandler中的handleMessage方法中处理了两种消息，一种是异步任务完成结果的消息，另一种是更新进度的消息。还是先来看任务结果的消息，其对应MESSAGE_POST_RESULT。调用result.mTask.finish方法，即AsyncTask的finish方法。

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

finish方法中先判断了此时任务有没有被取消,取消了就会走onCancelled方法，没取消就会调用onPostExecute这个异步任务完成后的方法，然后将AsyncTask的状态修改为已完成。至此AsyncTask的一次执行流程结束。

最后来看看异步任务更新进度的方法。要进行进度更新需要我们在doInBackground方法中调用publishProgress(percent)方法将进度传入。于是来看这个publishProgress(percent)方法。

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

方法中先判断任务没被取消就获取Handler发送更新进度消息，进度数据同样封装到AsyncTaskResult类型里。然后再看怎么处理消息。

 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;
            }
        }
复制代码

处理消息很简单就是调用了AsyncTask的onProgressUpdate方法将进度数据传入即可。至此AsyncTask的运行原理就全部讲完了，最后通过两张图梳理下整个过程。

方法流程

4.AsyncTask的问题

4.1 AsyncTask必须在主线程创建调用

AsyncTask一定要在主线程创建调用吗？实践是检验真理的唯一标准。

new Thread(new Runnable() {
    @Override
    public void run() {
        MyAsyncTask myAsyncTask = new MyAsyncTask();
        myAsyncTask.execute("测试");
    }
}).start();
复制代码

运行结果日志：

根据运行结果日志观察，发现子线程中创建和运行AsyncTask并没有发生错误，只是onPreExecute方法调用的线程变了，变成创建的子线程了，这也很好理解，根据之前看过的源码可以知道onPreExecute方法是在executeOnExecutor方法中直接调用的，所以就是运行在AsyncTask创建线程里。而其他方法要么是通过线程池中线程调用，要么是通过InternalHandler到主线程中调用，所以运行线程与之前无异。

那么子线程中创建使用AsyncTask单单只是onPreExecute方法运行线程不同吗？为什么会有必须在主线程创建调用这种说法呢？

其实这种说法是建立在老版本的AsyncTask上的，在上面的运行原理中所有的源码相关都是截取的API28版本的AsyncTask的源码。其中Handler是获得的主线程的Looper创建的。

    sHandler = new InternalHandler(Looper.getMainLooper());
复制代码

而在早期版本中，这里看API10版本的AsyncTask中的代码。

    private static final InternalHandler sHandler = new InternalHandler();
复制代码

早期版本中创建Handler时没有使用主线程的Looper所以创建AsyncTask的线程就是Handler所在线程，这样会导致onPostExecute和onProgressUpdate方法都会运行在这个线程，如果创建AsyncTask不在主线程就会导致onPostExecute和onProgressUpdate方法也不运行在主线程，进而在这两个方法中无法直接对UI进行更新。

4.2 Android3.0之前AsyncTask是并行执行任务，3.0之后为串行执行。

关于这点同样还是源码版本差异，新版本源码从之前的运行原理描述中可以看到AsyncTask在调用execute方法开启任务后，是先将任务放入一个SerialExecutor线程池，其中维护了一个队列，每次都是从这个队列中一个个取任务再交给真正处理任务的线程池。而在早期版本中是没有这个SerialExecutor这个线程池的，任务都是直接放入任务线程池执行的。

    public final AsyncTask<Params, Progress, Result> execute(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;
        sExecutor.execute(mFuture);
        return this;
    }

    private static final ThreadPoolExecutor sExecutor = new ThreadPoolExecutor(CORE_POOL_SIZE,
            MAXIMUM_POOL_SIZE, KEEP_ALIVE, TimeUnit.SECONDS, sWorkQueue, sThreadFactory);
复制代码

上面这段是API10对应Android2.3.7版本中AsyncTask的execute方法，可以看到任务是直接加入到sExecutor这个任务线程池中的。

4.3 AsyncTask内存泄漏

在使用AsyncTask若为非静态内部类，在Activity销毁时，AsyncTask中的耗时任务还没有完成，这时AsyncTask会还持有Activity的引用，造成其无法被会正常回收，造成内存泄漏。

解决方法也很简单只要使用静态类static加上弱引用WeakReference就可以了。另外从源码中看出AsyncTask有提供一个cancel方法，那么在Activity的destory方法里调用这个方法取消任务可不可以解决内存泄漏呢？答案是不可以的，具体还是看源码。

    private final AtomicBoolean mCancelled = new AtomicBoolean();

    public final boolean cancel(boolean mayInterruptIfRunning) {
        mCancelled.set(true);
        return mFuture.cancel(mayInterruptIfRunning);
    }
复制代码

看到AsyncTask的cancel方法只是将mCancelled这个状态修改为true,另外调用了mFuture.cancel方法。

 public boolean cancel(boolean mayInterruptIfRunning) {
        if (!(state == NEW &&
              U.compareAndSwapInt(this, STATE, NEW,
                  mayInterruptIfRunning ? INTERRUPTING : CANCELLED)))
            return false;
        try {    // in case call to interrupt throws exception
            if (mayInterruptIfRunning) {
                try {
                    Thread t = runner;
                    if (t != null)
                        t.interrupt();
                } finally { // final state
                    U.putOrderedInt(this, STATE, INTERRUPTED);
                }
            }
        } finally {
            finishCompletion();
        }
        return true;
    }
复制代码

在mFuture.cancel方法中最终还是调用了线程的t.interrupt方法，而Thread的interrupt方法是不会立即中断线程的，它同样是仅仅修改了一个中断线程的标志状态，需要自己在代码中判断处理或者等该线程进入阻塞才会抛出一个InterruptedException异常退出线程。所以AsyncTask的cancel方法是不能阻止内存泄漏的。

5.总结

关于AsyncTask的内容就是以上这些了，AsyncTask作为官方提供的一种处理异步任务的封装类，其实也并没有那么好用，稍不注意就会发生各种问题，不过作为了解，理解它的运行原理还是很有必要的。




原文地址：访问原文地址
快照地址： 访问文章快照
推荐文章
BNU统计  ·  统观节气|立夏·万物始茂 忽而今夏
4 天前
天津科技大学  ·  【牢记嘱托 见行见效】《中美人才培养计划》主题研讨会在天津科技大学举行
4 天前
天津科技大学  ·  @全体Tusters，争做文明有礼天津人！
4 天前
兰州大学萃英在线  ·  五四青年节这天，她登上了《人民日报》
5 天前
武汉大学  ·  今天，武大学生发出6封信
4 天前
新智元  ·  时隔两年，千亿芯片巨头再换帅！高永岗辞任董事长，58岁老将刘训峰接棒
9 月前
挤钻科学  ·  崔卫平：邪恶体制下的个人选择
2 年前
北京市电子科技情报研究所  ·  苏州市人民政府与华为签署全面战略合作协议
3 年前
陶城报  ·  福建陶瓷“龙头企业”有哪些？建华、铭盛、协进等上榜
3 年前
好地讯  ·  教师节土拍点评：限价部分失效，刚需受宠，中价分化，这三个现象背后有什么力量在起作用？
4 年前
关于   移动版   ·   Py中国   ·   RSS之家   ·   codingpro   ·   Code   ·   link之家   ·   卧龙AI搜索   ·   藏经阁   ·   小百科
今天看啥 - 微信公众号rss订阅, 微信rss, 稳定的RSS源
© 2024 ~ 沪ICP备11025650号