AsyncTask异步任务类

时间  2019-11-19
标签 asynctask 异步 任务 繁體版
原文   原文链接

目录介绍

  • 01.先看下AsyncTask用法
  • 02.AsyncTask源码深刻分析
    • 2.1 构造方法源码分析
    • 2.2 看execute(Params... params)方法
    • 2.3 mWorker和mFuture的建立过程
  • 03.异步机制的实现
  • 04.不一样的SDK版本区别
  • 05.AsyncTask的缺陷和问题
    • 5.1 AsyncTask对应线程池
    • 5.2 AsyncTask生命周期问题
    • 5.3 AsyncTask内存泄漏问题
    • 5.4 AsyncTask结果丢失问题
    • 5.5 AsyncTask并行仍是串行问题

好消息

  • 博客笔记大汇总【16年3月到至今】，包括Java基础及深刻知识点，Android技术博客，Python学习笔记等等，还包括平时开发中遇到的bug汇总，固然也在工做之余收集了大量的面试题，长期更新维护而且修正，持续完善……开源的文件是markdown格式的！同时也开源了生活博客，从12年起，积累共计47篇[近20万字]，转载请注明出处，谢谢！
  • 连接地址：https://github.com/yangchong211/YCBlogs
  • 若是以为好，能够star一下，谢谢！固然也欢迎提出建议，万事起于忽微，量变引发质变！

问题答疑

  • AsyncTask是如何实现异步机制的，底层原理是什么？
  • AsyncTask调用execute方法时，若是不是运行在主线程中会出现什么状况，如何解决？
  • 为何异步任务对象不能执行屡次，即不能建立一个对象执行屡次execute方法？
  • doInBackground这个方法能够作什么操做？它是在主线程中仍是工做线程中？为何？
  • AsyncTask任务是否能够被中途取消？为何？
  • AsyncTask对应线程池是如何操做的？它有什么弊端，为何如今几乎不多用呢？
  • AsyncTask的执行策略是并行仍是串行的？
  • 带着问题去看这篇文章，相信看完以后你对异常AsyncTask有了初步理解……

01.先看下AsyncTask用法

  • 来看一下AsyncTask的基本使用，代码以下所示
    • 定义了本身的MyAsyncTask并继承自AsyncTask；并重写了其中的是哪一个回调方法：onPreExecute()，onPostExecute（），doInBackground();
    class MyAsyncTask extends AsyncTask<Integer, Integer, Integer> { @Override protected void onPreExecute() { super.onPreExecute(); Log.i(TAG, "onPreExecute...(开始执行后台任务以前)"); } @Override protected void onPostExecute(Integer i) { super.onPostExecute(i); Log.i("TAG", "onPostExecute...(开始执行后台任务以后)"); } @Override protected Integer doInBackground(Integer... params) { Log.i(TAG, "doInBackground...(开始执行后台任务)"); return 0; } }
  • 开始调用异步任务 
    new MyAsyncTask().execute();

02.AsyncTask源码深刻分析

2.1 构造方法源码分析

  • 源代码以下所示，主要是看AsyncTask(@Nullable Looper callbackLooper)中的代码
    • 这里面只是初始化了两个成员变量：mWorker和mFuture他们分别是：WorkerRunnable和FutureTask，对于熟悉java的逗比应该知道这两个类实际上是java里面线程池先关的概念。
    • 异步任务的构造方法主要用于初始化线程池先关的成员变量
    //建立一个新的异步任务。必须在UI线程上调用此构造函数 public AsyncTask() { this((Looper) null); } //建立一个新的异步任务。必须在UI线程上调用此构造函数 public AsyncTask(@Nullable Handler handler) { this(handler != null ? handler.getLooper() : null); } public AsyncTask(@Nullable Looper callbackLooper) { mHandler = callbackLooper == null || callbackLooper == Looper.getMainLooper() ? getMainHandler() : new Handler(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); Binder.flushPendingCommands(); } catch (Throwable tr) { mCancelled.set(true); throw tr; } finally { postResult(result); } return result; } }; 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); } } }; }

2.2 看execute(Params... params)方法

  • 看一下execute方法php

    • 发现该方法中添加一个@MainThread的注解，经过该注解，能够知道咱们在执行AsyncTask的execute方法时，只能在主线程中执行
    @MainThread
public final AsyncTask<Params, Progress, Result> execute(Params... params) { return executeOnExecutor(sDefaultExecutor, params); }

  • 若是execute方法不是运行在主线程中会出现什么状况呢？java

    • 执行，可是并无什么区别，程序仍是能够正常执行。可是onPreExecute方法是与开始执行的execute方法是在同一个线程中的，因此若是在子线程中执行execute方法，必定要确保onPreExecute方法不执行刷新UI的方法，不然将会抛出异常。
    new Thread(new Runnable() { @Override public void run() { Log.i("tag", Thread.currentThread().getId() + ""); new MAsyncTask().execute(); } }).start(); Log.i("tag", "mainThread:" + Thread.currentThread().getId() + ""); @Override protected void onPreExecute() { super.onPreExecute(); //更新UI title.setText("潇湘剑雨"); Log.i(TAG, "onPreExecute...(开始执行后台任务以前)"); }
    • 异常以下所示，在子线程中执行execute方法，那么这时候若是在onPreExecute方法中刷新UI，会报错，即子线程中不能更新UI。
    Process: com.example.aaron.helloworld, PID: 659 android.view.ViewRootImpl$CalledFromWrongThreadException: Only the original thread that created a view hierarchy can touch its views.

  • 接着看看executeOnExecutor这个方法源码android

    • 具体的内部实现方法里：首先判断当前异步任务的状态，其内部保存异步任务状态的成员变量mStatus的默认值为Status.PENDING,因此第一次执行的时候并不抛出这两个异常，那么何时回进入这个if判断并抛出异常呢，经过查看源代码能够知道，当咱们执行了execute方法以后，若是再次执行就会进入这里的if条件判断并抛出异常
    • 在executeOnExecutor中若没有进入异常分之，则将当前异步任务的状态更改成Running，而后回调onPreExecute()方法，这里能够查看一下onPreExecute方法实际上是一个空方法，主要就是为了用于咱们的回调实现，同时这里也说明了onPreExecute（）方法是与execute方法的执行在同一线程中。

  • 而后将execute方法的参数赋值给mWorker对象那个，最后执行exec.execute(mFuture)方法，并返回自身。git

    • image

  • 模拟测试一下抛出异常的操做github

    • 看到咱们定义了一个AsyncTask的对象，而且每次执行点击事件的回调方法都会执行execute方法，当咱们点击第一次的时候程序正常执行，可是当咱们执行第二次的时候，程序就崩溃了。
    final MyAsyncTask mAsyncTask = new MyAsyncTask(); title.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { new Thread(new Runnable() { @Override public void run() { Log.i("tag", Thread.currentThread().getId() + ""); mAsyncTask.execute(); } }).start(); Log.i("tag", "mainThread:" + Thread.currentThread().getId() + ""); } });
    • 若这时候第一次执行的异步任务还没有执行完成则会抛出异常：
    Cannot execute task:the task is already running.
    • 若第一次执行的异步任务已经执行完成，则会抛出异常：
    Cannot execute task:the task has already been executed (a task can be executed only once)

  • 而后看一下exec.execute(mFuture)的实现面试

    • 这里的exec实际上是AsyncTask定义的一个默认的Executor对象：
    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); } } }
    • 能够发现其继承Executor类其内部保存着一个Runnable列表，即任务列表，在刚刚的execute方法中执行的exec.execute(mFuture)方法就是执行的这里的execute方法。
    • 这里具体看一下execute方法的实现：
      • 1）首先调用的是mTasks的offer方法，即将异步任务保存至任务列表的队尾
      • 2）判断mActive对象是否是等于null，第一次运行是null，而后调用scheduleNext()方法
      • 3）在scheduleNext()这个方法中会从队列的头部取值，并赋值给mActive对象，而后调用THREAD_POOL_EXECUTOR去执行取出的取出的Runnable对象。
      • 4）在这以后若是再有新的任务被执行时就等待上一个任务执行完毕后才会获得执行，因此说同一时刻只会有一个线程正在执行。
      • 5）这里的THREAD_POOL_EXECUTOR实际上是一个线程池对象。

2.3 构造方法中mWorker和mFuture的建立过程

  • 看一下执行过程当中mWorker的执行逻辑：
    • 能够看到在执行线程池的任务时，咱们回调了doInBackground方法，这也就是咱们重写AsyncTask时重写doInBackground方法是后台线程的缘由。
    mWorker = new WorkerRunnable<Params, Result>() { public Result call() throws Exception { mTaskInvoked.set(true); Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND); //noinspection unchecked Result result = doInBackground(mParams); Binder.flushPendingCommands(); return postResult(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); } } };
    • 这里具体看一下postResultIfNotInvoked方法：
    private void postResultIfNotInvoked(Result result) { final boolean wasTaskInvoked = mTaskInvoked.get(); if (!wasTaskInvoked) { postResult(result); } }
    • 其内部仍是调用了postResult方法：
    private Result postResult(Result result) { @SuppressWarnings("unchecked") Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT, new AsyncTaskResult<Result>(this, result)); message.sendToTarget(); return result; }
    • 这里能够看到起调用了内部的Handler对象的sendToTarget方法，发送异步消息

03.异步机制的实现

  • 看AsyncTask内部定义了一个Handler对象
    • 内部的handleMessage方法，有两个处理逻辑，分别是：更新进入条和执行完成，这里的更新进度的方法就是咱们重写AsyncTask方法时重写的更新进度的方法，这里的异步任务完成的消息会调用finish方法
    private static class InternalHandler extends Handler { public InternalHandler() { super(Looper.getMainLooper()); } @SuppressWarnings({"unchecked", "RawUseOfParameterizedType"}) @Override public void handleMessage(Message msg) { AsyncTaskResult<?> result = (AsyncTaskResult<?>) msg.obj; switch (msg.what) { case MESSAGE_POST_RESULT: result.mTask.finish(result.mData[0]); break; case MESSAGE_POST_PROGRESS: result.mTask.onProgressUpdate(result.mData); break; } } }
  • 而后看看调用finish方法作了什么
    • 首先会判断当前任务是否被取消，若被取消的话则直接执行取消的方法，不然执行onPostExecute方法，也就是咱们重写AsyncTask时须要重写的异步任务完成时回调的方法。
    private void finish(Result result) { if (isCancelled()) { onCancelled(result); } else { onPostExecute(result); } mStatus = Status.FINISHED; }
  • 既然有处理消息的，那么确定有发送消息的。
    • 能够从构造方法中看到，当经过执行doInBackground方法拿到结果后，最后在finally执行发送该消息逻辑
    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_PROGRESS这个消息发送是处理进度，须要在工做线程中
    @Override protected ReusableBitmap doInBackground(Void... params) { // enqueue the 'onDecodeBegin' signal on the main thread publishProgress(); return decode(); } @WorkerThread protected final void publishProgress(Progress... values) { if (!isCancelled()) { getHandler().obtainMessage(MESSAGE_POST_PROGRESS, new AsyncTaskResult<Progress>(this, values)).sendToTarget(); } }

04.不一样的SDK版本区别

  • 调用AsyncTask的execute方法不能当即执行程序的缘由析及改善方案经过查阅官方文档发现，AsyncTask首次引入时，异步任务是在一个独立的线程中顺序的执行，也就是说一次只执行一个任务，不能并行的执行，从1.6开始，AsyncTask引入了线程池，支持同时执行5个异步任务，也就是说时只能有5个线程运行，超过的线程只能等待，等待前的线程某个执行完了才被调度和运行。换句话说，若是个进程中的AsyncTask实例个数超过5个，那么假如前5都运行很长时间的话，那么第6个只能等待机会了。这是AsyncTask的一个限制，并且对于2.3之前的版本没法解决。若是你的应用须要大量的后台线程去执行任务，那么只能放弃使用AsyncTask，本身建立线程池来管理Thread。不得不说，虽然AsyncTask较Thread使用起来方便，可是它最多只能同时运行5个线程，这也大大局限了它的做用，你必需要当心设计你的应用，错开使用AsyncTask时间，尽力作到分时，或者保证数量不会大于5个，否就会遇到上次提到的问题。多是Google意识到了AsynTask的局限性了，从Android3.0开始对AsyncTask的API作出了一些调整：每次只启动一个线程执行一个任务，完了以后再执行第二个任务，也就是至关于只有一个后台线在执行所提交的任务。

05.AsyncTask的缺陷和问题

5.1 AsyncTask对应线程池

  • Asynctask对应的线程池ThreadPoolExecutr都是进程范围内共享的，都是static的，因此是Asynctask控制着进程范围内全部的子类实例。因为这个限制的存在，当使用默认线程池时，若是线程数超过线程池的最大容量，线程池就会爆掉(3.0后默认串行执行，不会出现个问题)。针对这种状况，能够尝试自定义线程池，配合Asynctask使用。
  • 关于默认线程池：
    • AsyncTask里面线程池是一个核心线程数为CPU + 1，最大线程数为CPU * 2 + 1，工做队列长度为128的线程池，线程等待队列的最大等待数为28，可是能够自定义线程池。线程池是由AsyncTask来处理的，线程池容许tasks并行运行，须要注意的是并发状况下数据的一致性问题，新数据可能会被老数据覆盖掉相似volatile变量。因此但愿tasks可以串行运行的话，使用SERIAL_EXECUTOR。

5.2 AsyncTask生命周期问题

  • 不少开发者会认为一个在Activity中建立的AsyncTask随着Activity的销毁而销毁。然而事实并不是如此。AsynTask会一直执行，直到doInBackground()方法执行完毕，而后，若是cancel(boolean)被调用,那么onCancelled(Result result)方法会被执行；不然，执行onPostExecuteResult result)方法。若是咱们的Activity销毁以前，没有取消AsyncTask，这有可能让咱们的应用崩溃(crash)。由于它想要处理的view已经不存在了。因此，咱们是必须确保在销毁活动以前取消任务。总之，咱们使用AsyncTask须要确保AsyncTask正确的取消。

5.3 AsyncTask内存泄漏问题

  • 若是AsyncTask被声明为Activity的非静态的内部类，那么AsyncTask会保留一个对Activity的引用。若是Activity已经被销毁，AsyncTask的后台线程还在执行，它将续在内存里保留这个引用，致使Activity没法被回收，引发内存泄漏。

5.4 AsyncTask结果丢失问题

  • 屏幕旋转或Activity在后台被系统杀掉等状况会致使Actvity的从新建立，以前运行的AsyncTask会持有一个以前Activity的引用，这个引用已经无效，这时调用onPostExecute()再去更新界面将再也不生效。

5.5 AsyncTask并行仍是串行问题

  • 在Android1.6以前的版本，AsyncTask是串行的，在1.6-2.3的版本，改为了并行的。在2.3以后的版本又作了修改，能够支持并行和串行，当想要串行执行时，直接行execute()方法，若是须要并行执行时，执行executeOnExecutor(Executor)。

关于其余内容介绍

01.关于博客汇总连接

02.关于个人博客

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程