一. 序

Handler 機制算是 Android 基本功，面試常客。但現在面試，多數已經不會直接讓你講講 Handler 的機制，Looper 是如何迴圈的，MessageQueue 是如何管理 Message 等，而是基於場景去提問，看看你對 Handler 機制的掌握是否紮實。

本文就來聊聊 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 物件，開發者只需要直接使用即可。

Handler 類中封裝了大部分「Handler 機制」對外的操作介面，可以通過它的 send/post 相關的方法，向訊息佇列 MessageQueue 中插入一條 Message。在 Looper 迴圈中，又會不斷的從 MessageQueue 取出下一條待處理的 Message 進行處理。

IdleHandler 使用相關的邏輯，就在 MessageQueue 取訊息的 next() 方法中。

2.2 IdleHandler 是什麼？怎麼用？

IdleHandler 說白了，就是 Handler 機制提供的一種，可以在 Looper 事件迴圈的過程中，當出現空閒的時候，允許我們執行任務的一種機制。

IdleHandler 被定義在 MessageQueue 中，它是一個介面。

// 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 就一直得不到執行，也就是它的執行時機是不可控的，不適合執行一些對時機要求比較高的任務。

本文就到這裡，對你有幫助嗎？有任何問題歡迎留言。覺得有幫助別忘了轉發、點好看，謝謝！

---

推薦閱讀：

• TCP 三次握手四次揮手意外情況處理
• 作為位元組跳動面試官，有些話我不得不說
• 被開發者拋棄的 Executors，錯在哪兒？

公眾號後臺回覆成長『成長』，將會得到我準備的學習資料。

相關推薦