IdleHandler是什么？

看MessageQueue源码的时候发现一个IdleHandler，但它并不是Handler，直译过来的话应该叫“闲置处理器”。一般开发中不会用到，了解一下Android框架中的源码，以免以后有骚操作需要说不定会用上。

1、IdleHandler定义

IdleHandler是定义在MessageQueue类中的一个接口：

/**
     * Callback interface for discovering when a thread is going to block
     * waiting for more messages.
     */
    public static interface IdleHandler {
        /**
         * Called when the message queue has run out of messages and will now
         * wait for more.  Return true to keep your idle handler active, false
         * to have it removed.  This may be called if there are still messages
         * pending in the queue, but they are all scheduled to be dispatched
         * after the current time.
         */
        boolean queueIdle();
    }

从Android源码的注释我们可以初步看到这是一个闲置回调接口：

①当消息队列空闲阻塞等待更多消息时，回调该接口。可以在消息队列空闲时做一些操作，避开“UI主线程高峰期”。

②返回类型boolean值，为true时会保留该“闲置处理器”，下次消息队列闲置时仍然会回调（谨慎使用，控制好返回值，以免“蹩脚的程序员”无限调用）。返回false时，被调用后就会被移除。

③显然，queueIdle()方法在主线程不适宜执行耗时操作。

2、空闲

消息队列什么时候空闲呢？MessageQueue供了一个方法isIdle()判断当前消息队列是否空闲：

/**
     * Returns true if the looper has no pending messages which are due to be processed.
     *
     * <p>This method is safe to call from any thread.
     *
     * @return True if the looper is idle.
     */
    public boolean isIdle() {
        synchronized (this) {
            final long now = SystemClock.uptimeMillis();
            return mMessages == null || now < mMessages.when;
        }
    }

从代码可以看出“空闲”的含义：当前没有Message，或者有Message但是延迟消息当前无需处理(没到时候)。

3、IdleHandler相关源码

MessageQueue类中与IdleHandler相关的代码只有三处：两个相关的变量定义、添加和移除“闲置处理器”的方法以及next()方法中。

3.1、内部变量

MessageQueue中定义了两个IdleHandler相关的成员变量：一个是用来保存添加到该消息队列中的IdleHandler集合mIdleHandlers；另一个是用在next()方法中的临时中转数组mPendingIdleHandlers：之所以这样做，因为还要修改原有集合mIdleHandlers，所以干脆拷贝一份数组副本。

@UnsupportedAppUsage
    private final ArrayList<IdleHandler> mIdleHandlers = new ArrayList<IdleHandler>();
    private IdleHandler[] mPendingIdleHandlers;

3.2、添加和移除方法

添加一个IdleHandler实例到消息队列MessageQueue中。一定不能为空，否则会抛出异常。

/**
     * Add a new {@link IdleHandler} to this message queue.  This may be
     * removed automatically for you by returning false from
     * {@link IdleHandler#queueIdle IdleHandler.queueIdle()} when it is
     * invoked, or explicitly removing it with {@link #removeIdleHandler}.
     *
     * <p>This method is safe to call from any thread.
     *
     * @param handler The IdleHandler to be added.
     */
    public void addIdleHandler(@NonNull IdleHandler handler) {
        if (handler == null) {
            throw new NullPointerException("Can't add a null IdleHandler");
        }
        synchronized (this) {
            mIdleHandlers.add(handler);
        }
    }

从添加到这个消息队列的IdleHandler集合中移除指定的“闲置处理器”：

/**
     * Remove an {@link IdleHandler} from the queue that was previously added
     * with {@link #addIdleHandler}.  If the given object is not currently
     * in the idle list, nothing is done.
     *
     * <p>This method is safe to call from any thread.
     *
     * @param handler The IdleHandler to be removed.
     */
    public void removeIdleHandler(@NonNull IdleHandler handler) {
        synchronized (this) {
            mIdleHandlers.remove(handler);
        }
    }

3.3、next()代码片段

在Handler消息延迟原理一文中，我们知道Loop通过next()不断从消息队列中取出Message。next()方法中和IdleHandler相关的代码片段如下：

如果消息队列空闲，并且有需要处理的“闲置处理器”：先将mIdleHandlers转成数组存起来在mPendingIdleHandlers中

...
            // If first time idle, then get the number of idlers to run.
            // Idle handles only run if the queue is empty or if the first message
            // in the queue (possibly a barrier) is due to be handled in the future.
            if (pendingIdleHandlerCount < 0
                    && (mMessages == null || now < mMessages.when)) {
                pendingIdleHandlerCount = mIdleHandlers.size();
            }
            if (pendingIdleHandlerCount <= 0) {
                // No idle handlers to run.  Loop and wait some more.
                mBlocked = true;
                continue;
            }
            if (mPendingIdleHandlers == null) {
                mPendingIdleHandlers = new IdleHandler[Math.max(pendingIdleHandlerCount, 4)];
            }
            mPendingIdleHandlers = mIdleHandlers.toArray(mPendingIdleHandlers);
        ...

接下来就是遍历数组，执行接口方法queueIdle()：返回false就会从mIdleHandlers中移除当前执行过的IdleHandler。

...
            // Run the idle handlers.
            // We only ever reach this code block during the first iteration.
            for (int i = 0; i < pendingIdleHandlerCount; i++) {
                final IdleHandler idler = mPendingIdleHandlers[i];
                mPendingIdleHandlers[i] = null; // release the reference to the handler
                boolean keep = false;
                try {
                    keep = idler.queueIdle();
                } catch (Throwable t) {
                    Log.wtf(TAG, "IdleHandler threw exception", t);
                }
                if (!keep) {
                    synchronized (this) {
                        mIdleHandlers.remove(idler);
                    }
                }
            }
        ...

IdleHandler是什么？