Android 9.0 源码_机制篇 -- 全面解析 Handler 机制（原理篇）下 - 好文

MessageQueue 中有两个比较重要的方法，一个是 enqueueMessage 方法，一个是 next 方法。enqueueMessage
方法用于将一个 Messag e放入到消息队列 MessageQueue 中，next 方法是从消息队列 MessageQueue 中阻塞式地取出一个
Message。在 Android 中，消息队列负责管理着顶级程序对象（Activity、BroadcastReceiver等）以及由其创建的所有窗口。

<>#七创建MessageQueue
MessageQueue(boolean quitAllowed) { mQuitAllowed = quitAllowed; // 通过 native
方法初始化消息队列，其中 mPtr 是供 native 代码使用 mPtr = nativeInit(); }
###next()
Message next() { final long ptr = mPtr; if (ptr == 0) { // 当消息循环已经退出，则直接返回
return null; } // 循环迭代的首次为 -1 int pendingIdleHandlerCount = -1; // -1 only
during first iteration int nextPollTimeoutMillis = 0; for (;;) { if
(nextPollTimeoutMillis != 0) { Binder.flushPendingCommands(); } // 阻塞操作，当等待
nextPollTimeoutMillis 时长，或者消息队列被唤醒，都会返回 nativePollOnce(ptr,
nextPollTimeoutMillis); synchronized (this) { // Try to retrieve the next
message. Return if found. final long now = SystemClock.uptimeMillis(); Message
prevMsg = null; Message msg = mMessages; if (msg != null && msg.target == null)
{ // 当消息 Handler 为空时，查询 MessageQueue 中的下一条异步消息 msg，则退出循环 do { prevMsg = msg;
msg = msg.next; } while (msg != null && !msg.isAsynchronous()); } if (msg !=
null) { if (now < msg.when) { // 当异步消息触发时间大于当前时间，则设置下一次轮询的超时时长
nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE); }
else { // 获取一条消息，并返回 mBlocked = false; if (prevMsg != null) { prevMsg.next =
msg.next; } else { mMessages = msg.next; } msg.next = null; // 设置消息的使用状态，即
flags |= FLAG_IN_USE msg.markInUse(); // 成功地获取 MessageQueue 中的下一条即将要执行的消息
return msg; } } else { // 没有消息 nextPollTimeoutMillis = -1; } // 消息正在退出，返回null
if (mQuitting) { dispose(); return null; } // 当消息队列为空，或者是消息队列的第一个消息时 if
(pendingIdleHandlerCount < 0 && (mMessages == null || now < mMessages.when)) {
pendingIdleHandlerCount = mIdleHandlers.size(); } if (pendingIdleHandlerCount
<= 0) { // 没有 idle handlers 需要运行，则循环并等待 mBlocked = true; continue; } if
(mPendingIdleHandlers == null) { mPendingIdleHandlers = new
IdleHandler[Math.max(pendingIdleHandlerCount, 4)]; } mPendingIdleHandlers =
mIdleHandlers.toArray(mPendingIdleHandlers); } // 只有第一次循环时，会运行 idle
handlers，执行完成后，重置 pendingIdleHandlerCount 为 0 for (int i = 0; i <
pendingIdleHandlerCount; i++) { final IdleHandler idler =
mPendingIdleHandlers[i]; mPendingIdleHandlers[i] = null; // 去掉 handler 的引用
boolean keep = false; try { keep = idler.queueIdle(); // idle 时执行的方法 } catch
(Throwable t) { Log.wtf(TAG, "IdleHandler threw exception", t); } if (!keep) {
synchronized (this) { mIdleHandlers.remove(idler); } } } // 重置 idle handler 个数为
0，以保证不会再次重复运行 pendingIdleHandlerCount = 0; // 当调用一个空闲 handler 时，一个新 message
能够被分发，因此无需等待可以直接查询 pending message nextPollTimeoutMillis = 0; } }
nativePollOnce 是阻塞操作，其中 nextPollTimeoutMillis 代表下一个消息到来前，还需要等待的时长；当
nextPollTimeoutMillis = -1 时，表示消息队列中无消息，会一直等待下去。

当处于空闲时，往往会执行 IdleHandler 中的方法。当 nativePollOnce() 返回后，next() 从 mMessages
中提取一个消息。

#八 enqueueMessage()
boolean enqueueMessage(Message msg, long when) { // 每一个普通 Message 必须有一个
target if (msg.target == null) { throw new IllegalArgumentException("Message
must have a target."); } if (msg.isInUse()) { throw new
IllegalStateException(msg + " This message is already in use."); } synchronized
(this) { // 正在退出时，回收 msg，加入到消息池 if (mQuitting) { IllegalStateException e = new
IllegalStateException( msg.target + " sending message to a Handler on a dead
thread"); Log.w(TAG, e.getMessage(), e); msg.recycle(); return false; }
msg.markInUse(); msg.when = when; Message p = mMessages; boolean needWake; if
(p == null || when == 0 || when < p.when) { // p 为 null (代表MessageQueue没有消息）或者
msg 的触发时间是队列中最早的，则进入该该分支 msg.next = p; mMessages = msg; needWake = mBlocked; //
当阻塞时需要唤醒 } else { // 将消息按时间顺序插入到 MessageQueue。一般地，不需要唤醒事件队列，除非 // 消息队头存在
barrier，并且同时 Message 是队列中最早的异步消息 needWake = mBlocked && p.target == null &&
msg.isAsynchronous(); Message prev; for (;;) { prev = p; p = p.next; if (p ==
null || when < p.when) { break; } if (needWake && p.isAsynchronous()) {
needWake = false; } } msg.next = p; // invariant: p == prev.next prev.next =
msg; } // 消息没有退出，我们认为此时 mPtr != 0 if (needWake) { nativeWake(mPtr); } } return
true; }
MessageQueue 是按照 Message
触发时间的先后顺序排列的，队头的消息是将要最早触发的消息。当有消息需要加入消息队列时，会从队列头开始遍历，直到找到消息应该插入的合适位置，以保证所有消息的时间顺序。

<>#九 removeMessages()
void removeMessages(Handler h, int what, Object object) { if (h == null) {
return; } synchronized (this) { Message p = mMessages; //
从消息队列的头部开始，移除所有符合条件的消息 while (p != null && p.target == h && p.what == what &&
(object == null || p.obj == object)) { Message n = p.next; mMessages = n;
p.recycleUnchecked(); p = n; } // 移除剩余的符合要求的消息 while (p != null) { Message n =
p.next; if (n != null) { if (n.target == h && n.what == what && (object == null
|| n.obj == object)) { Message nn = n.next; n.recycleUnchecked(); p.next = nn;
continue; } } p = n; } } }
这个移除消息的方法，采用了两个 while
循环，第一个循环是从队头开始，移除符合条件的消息，第二个循环是从头部移除完连续的满足条件的消息之后，再从队列后面继续查询是否有满足条件的消息需要被移除。

<>#总结

最后用一张图，来表示整个消息机制：

图解：

✨ Handler通过sendMessage()发送Message到MessageQueue队列；
        ✨ Looper通过loop()，不断提取出达到触发条件的Message，并将Message交给target来处理；
        ✨ 经过dispatchMessage()后，交回给Handler的handleMessage()来进行相应地处理。

        ✨ 将Message加入MessageQueue时，处往管道写入字符，可以会唤醒loop线程；如果MessageQueue中没有Message，并处于Idle状态，则会执行IdelHandler接口中的方法，往往用于做一些清理性地工作。

####想学习更多Android知识，或者获取相关资料请加入Android技术开发交流2群：935654177。本群可免费获取Gradle，RxJava，小程序，Hybrid，移动架构，NDK，React
Native，性能优化等技术教程！

热门工具换一换