面试官：“看你简历上写熟悉 Handler 机制，那聊聊 IdleHandler 吧？”

时间  2020-02-22
标签 面试 简历 熟悉 handler 机制 聊聊 idlehandler 栏目 快乐工作 繁體版
原文   原文链接

一. 序

Handler 机制算是 Android 基本功，面试常客。但如今面试，多数已经不会直接让你讲讲 Handler 的机制，Looper 是如何循环的，MessageQueue 是如何管理 Message 等，而是基于场景去提问，看看你对 Handler 机制的掌握是否扎实。java

本文就来聊聊 Handler 中的 IdleHandler，这个咱们比较少用的功能。它能干什么？怎么使用？有什么合适的使用场景？哪些不是合适的使用场景？在 Android Framework 中有哪些地方用到了它？面试

二. IdleHandler

2.1 简单说说 Handler 机制

在说 IdleHandler 以前，先简单了解一下 Handler 机制。数组

Handler 是标准的事件驱动模型，存在一个消息队列 MessageQueue，它是一个基于消息触发时间的优先级队列，还有一个基于此消息队列的事件循环 Looper，Looper 经过循环，不断的从 MessageQueue 中取出待处理的 Message，再交由对应的事件处理器 Handler/callback 来处理。安全

其中 MessageQueue 被 Looper 管理，Looper 在构造时同步会建立 MessageQueue，并利用 ThreadLocal 这种 TLS，将其与当前线程绑定。而 App 的主线程在启动时，已经构造并准备好主线程的 Looper 对象，开发者只须要直接使用便可。oop

Handler 类中封装了大部分「Handler 机制」对外的操做接口，能够经过它的 send/post 相关的方法，向消息队列 MessageQueue 中插入一条 Message。在 Looper 循环中，又会不断的从 MessageQueue 取出下一条待处理的 Message 进行处理。post

IdleHandler 使用相关的逻辑，就在 MessageQueue 取消息的 next() 方法中。学习

2.2 IdleHandler 是什么？怎么用？

IdleHandler 说白了，就是 Handler 机制提供的一种，能够在 Looper 事件循环的过程当中，当出现空闲的时候，容许咱们执行任务的一种机制。this

IdleHandler 被定义在 MessageQueue 中，它是一个接口。spa

// MessageQueue.java
public static interface IdleHandler {
  boolean queueIdle();
}
复制代码

能够看到，定义时须要实现其 queueIdle() 方法。同时返回值为 true 表示是一个持久的 IdleHandler 会重复使用，返回 false 表示是一个一次性的 IdleHandler。线程

既然 IdleHandler 被定义在 MessageQueue 中，使用它也须要借助 MessageQueue。在 MessageQueue 中定义了对应的 add 和 remove 方法。

// MessageQueue.java
public void addIdleHandler(@NonNull IdleHandler handler) {
	// ...
  synchronized (this) {
    mIdleHandlers.add(handler);
  }
}
public void removeIdleHandler(@NonNull IdleHandler handler) {
  synchronized (this) {
    mIdleHandlers.remove(handler);
  }
}
复制代码

能够看到 add 或 remove 其实操做的都是 mIdleHandlers，它的类型是一个 ArrayList。

既然 IdleHandler 主要是在 MessageQueue 出现空闲的时候被执行，那么什么时候出现空闲？

MessageQueue 是一个基于消息触发时间的优先级队列，因此队列出现空闲存在两种场景。

  1. MessageQueue 为空，没有消息；
  2. MessageQueue 中最近须要处理的消息，是一个延迟消息（when>currentTime），须要滞后执行；

这两个场景，都会尝试执行 IdleHandler。

处理 IdleHandler 的场景，就在 Message.next() 这个获取消息队列下一个待执行消息的方法中，咱们跟一下具体的逻辑。

Message next() {
	// ...
  int pendingIdleHandlerCount = -1; 
  int nextPollTimeoutMillis = 0;
  for (;;) {
    nativePollOnce(ptr, nextPollTimeoutMillis);

    synchronized (this) {
      // ...
      if (msg != null) {
        if (now < msg.when) {
          // 计算休眠的时间
          nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
        } else {
          // Other code
          // 找到消息处理后返回
          return msg;
        }
      } else {
        // 没有更多的消息
        nextPollTimeoutMillis = -1;
      }
      
      if (pendingIdleHandlerCount < 0
          && (mMessages == null || now < mMessages.when)) {
        pendingIdleHandlerCount = mIdleHandlers.size();
      }
      if (pendingIdleHandlerCount <= 0) {
        mBlocked = true;
        continue;
      }

      if (mPendingIdleHandlers == null) {
        mPendingIdleHandlers = new IdleHandler[Math.max(pendingIdleHandlerCount, 4)];
      }
      mPendingIdleHandlers = mIdleHandlers.toArray(mPendingIdleHandlers);
    }

    for (int i = 0; i < pendingIdleHandlerCount; i++) {
      final IdleHandler idler = mPendingIdleHandlers[i];
      mPendingIdleHandlers[i] = null; 

      boolean keep = false;
      try {
        keep = idler.queueIdle();
      } catch (Throwable t) {
        Log.wtf(TAG, "IdleHandler threw exception", t);
      }

      if (!keep) {
        synchronized (this) {
          mIdleHandlers.remove(idler);
        }
      }
    }

    pendingIdleHandlerCount = 0;
    nextPollTimeoutMillis = 0;
  }
}
复制代码

咱们先解释一下 next() 中关于 IdleHandler 执行的主逻辑：

  1. 准备执行 IdleHandler 时，说明当前待执行的消息为 null，或者这条消息的执行时间未到；
  2. 当 pendingIdleHandlerCount < 0 时，根据 mIdleHandlers.size() 赋值给 pendingIdleHandlerCount，它是后期循环的基础；
  3. 将 mIdleHandlers 中的 IdleHandler 拷贝到 mPendingIdleHandlers 数组中，这个数组是临时的，以后进入 for 循环；
  4. 循环中从数组中取出 IdleHandler，并调用其 queueIdle() 记录返回值存到 keep 中；
  5. 当 keep 为 false 时，从 mIdleHandler 中移除当前循环的 IdleHandler，反之则保留；

能够看到 IdleHandler 机制中，最核心的就是在 next() 中，当队列空闲的时候，循环 mIdleHandler 中记录的 IdleHandler 对象，若是其 queueIdle() 返回值为 false 时，将其从 mIdleHander 中移除。

须要注意的是，对 mIdleHandler 这个 List 的全部操做，都经过 synchronized 来保证线程安全，这一点无需担忧。

2.3 IdleHander 是如何保证不进入死循环的？

当队列空闲时，会循环执行一遍 mIdleHandlers 数组并执行 IdleHandler.queueIdle() 方法。而若是数组中有一些 IdleHander 的 queueIdle() 返回了 true，则会保留在 mIdleHanders 数组中，下次依然会再执行一遍。

注意如今代码逻辑还在 MessageQueue.next() 的循环中，在这个场景下 IdleHandler 机制是如何保证不会进入死循环的？

有些文章会说 IdleHandler 不会死循环，是由于下次循环调用了 nativePollOnce() 借助 epoll 机制进入休眠状态，下次有新消息入队的时候会从新唤醒，但这是不对的。

注意看前面 next() 中的代码，在方法的末尾会重置 pendingIdleHandlerCount 和 nextPollTimeoutMillis。

Message next() {
	// ...
  int pendingIdleHandlerCount = -1; 
  int nextPollTimeoutMillis = 0;
  for (;;) {
		nativePollOnce(ptr, nextPollTimeoutMillis);
    // ...
    // 循环执行 mIdleHandlers
    // ...
    pendingIdleHandlerCount = 0;
    nextPollTimeoutMillis = 0;
  }
}
复制代码

nextPollTimeoutMillis 决定了下次进入 nativePollOnce() 超时的时间，它传递 0 的时候等于不会进入休眠，因此说 natievPollOnce() 进入休眠因此不会死循环是不对的。

这很好理解，毕竟 IdleHandler.queueIdle() 运行在主线程，它执行的时间是不可控的，那么 MessageQueue 中的消息状况可能会变化，因此须要再处理一遍。

实际不会死循环的关键是在于 pendingIdleHandlerCount，咱们看看下面的代码。

Message next() {
	// ...
  // Step 1
  int pendingIdleHandlerCount = -1; 
  int nextPollTimeoutMillis = 0;
  for (;;) {
    nativePollOnce(ptr, nextPollTimeoutMillis);

    synchronized (this) {
      // ...
      // Step 2
      if (pendingIdleHandlerCount < 0
          && (mMessages == null || now < mMessages.when)) {
        pendingIdleHandlerCount = mIdleHandlers.size();
      }
     	// Step 3
      if (pendingIdleHandlerCount <= 0) {
        mBlocked = true;
        continue;
      }
      // ...
    }
		// Step 4
    pendingIdleHandlerCount = 0;
    nextPollTimeoutMillis = 0;
  }
}
复制代码

咱们梳理一下：

  • Step 1，循环开始前，pendingIdleHandlerCount 的初始值为 -1；
  • Step 2，在 pendingIdleHandlerCount<0 时，才会经过 mIdleHandlers.size() 赋值。也就是说只有第一次循环才会改变 pendingIdleHandlerCount 的值；
  • Step 3，若是 pendingIdleHandlerCount<=0 时，则循环 continus；
  • Step 4，重置 pendingIdleHandlerCount 为 0；

在第二次循环时，pendingIdleHandlerCount 等于 0，在 Step 2 不会改变它的值，那么在 Step 3 中会直接 continus 继续下一次循环，此时没有机会修改 nextPollTimeoutMillis。

那么 nextPollTimeoutMillis 有两种可能：-1 或者下次唤醒的等待间隔时间，在执行到 nativePollOnce() 时就会进入休眠，等待再次被唤醒。

下次唤醒时，mMessage 必然会有一个待执行的 Message，则 MessageQueue.next() 返回到 Looper.loop() 的循环中，分发处理这个 Message，以后又是一轮新的 next() 中去循环。

2.4 framework 中如何使用 IdleHander？

到这里基本上就讲清楚 IdleHandler 如何使用以及一些细节，接下来咱们来看看，在系统中，有哪些地方会用到 IdleHandler 机制。

在 AS 中搜索一下 IdleHandler。

简单解释一下：

  1. ActivityThread.Idler 在 ActivityThread.handleResumeActivity() 中调用。
  2. ActivityThread.GcIdler 是在内存不足时，强行 GC；
  3. Instrumentation.ActivityGoing 在 Activity onCreate() 执行前添加；
  4. Instrumentation.Idler 调用的时机就比较多了，是键盘相关的调用；
  5. TextToSpeechService.SynthThread 是在 TTS 合成完成以后发送广播；

有兴趣能够本身追一下源码，这些都是使用的场景，具体用 IdleHander 干什么，仍是要看业务。

三.一些面试问题

到这里咱们就讲清楚 IdleHandler 干什么？怎么用？有什么问题？以及使用中一些原理的讲解。

下面准备一些基本的问题，供你们理解。

Q：IdleHandler 有什么用？

  1. IdleHandler 是 Handler 提供的一种在消息队列空闲时，执行任务的时机；
  2. 当 MessageQueue 当前没有当即须要处理的消息时，会执行 IdleHandler；

Q：MessageQueue 提供了 add/remove IdleHandler 的方法，是否须要成对使用？

  1. 不是必须；
  2. IdleHandler.queueIdle() 的返回值，能够移除加入 MessageQueue 的 IdleHandler；

Q：当 mIdleHanders 一直不为空时，为何不会进入死循环？

  1. 只有在 pendingIdleHandlerCount 为 -1 时，才会尝试执行 mIdleHander；
  2. pendingIdlehanderCount 在 next() 中初始时为 -1，执行一遍后被置为 0，因此不会重复执行；

Q：是否能够将一些不重要的启动服务，搬移到 IdleHandler 中去处理？

  1. 不建议；
  2. IdleHandler 的处理时机不可控，若是 MessageQueue 一直有待处理的消息，那么 IdleHander 的执行时机会很靠后；

Q：IdleHandler 的 queueIdle() 运行在那个线程？

  1. 陷进问题，queueIdle() 运行的线程，只和当前 MessageQueue 的 Looper 所在的线程有关；
  2. 子线程同样能够构造 Looper，并添加 IdleHandler；

三. 小结时刻

到这里就把 IdleHandler 的使用和原理说清除了。

IdleHandler 是 Handler 提供的一种在消息队列空闲时，执行任务的时机。但它执行的时机依赖消息队列的状况，那么若是 MessageQueue 一直有待执行的消息时，IdleHandler 就一直得不到执行，也就是它的执行时机是不可控的，不适合执行一些对时机要求比较高的任务。

本文就到这里，对你有帮助吗？有任何问题欢迎留言。以为有帮助别忘了转发、点好看，谢谢！

推荐阅读：

公众号后台回复成长『成长』，将会获得我准备的学习资料。

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