前言

最近闲的时间比较多，浏览一些公众号和一些IT网站，突然看到一个问题：

Handler中loop方法为什么不会导致线程卡死？

我先浏览了一下源码，以下为截取部分片段：

/**Looper*/
public static void loop() {...for (;;) {Message msg = queue.next(); // might blockif (msg == null) {// No message indicates that the message queue is quitting.return;}...msg.recycleUnchecked();}}/**MessageQuene*/
Message next() {...int pendingIdleHandlerCount = -1; // -1 only during first iterationint nextPollTimeoutMillis = 0;for (;;) {if (nextPollTimeoutMillis != 0) {Binder.flushPendingCommands();}nativePollOnce(ptr, nextPollTimeoutMillis);synchronized (this) {...}// Reset the idle handler count to 0 so we do not run them again.pendingIdleHandlerCount = 0;// While calling an idle handler, a new message could have been delivered// so go back and look again for a pending message without waiting.nextPollTimeoutMillis = 0;}}

仔细一看，这确实是两个死循环，难道死循环不会阻塞了吗，科技都这么进步了吗？，果断尝试：

/**Activity*/
runOnUiThread {while (true) {Log.d("lzp", "while")}
}

还是卡死了，页面一篇惨白，那为啥Handler中的loop不会卡死线程？

正文

为了解决这个问题，我开始在网上搜索相关的资料，但是都不能完全解决我的疑问，果然解决问题还得靠自己。

创建一台模拟器，选定Android系统版本，打上断点，问题就明朗了。

小建议：如果想要看源码，建议使用模拟器，这样断点能对得上源码，国产真机不推荐，具体原因大家都懂。

问题一：Handler中的loop真的是死循环吗？

了解过源码的朋友都知道，Handler与Looper、Messagequene的关系，这里就简要说一下：

Handler：消息处理器；
Looper：消息管理器；
MessageQuene：消息队列；

我们要理解的是Looper中的looper方法，仔细分析looper源码，其实它只完成几步工作：

public static void loop() {// 从队列去除消息final MessageQueue queue = me.mQueue;// for死循环for (;;) {Message msg = queue.next(); // might blockif (msg == null) {// No message indicates that the message queue is quitting.return;}// 消息分发  msg.target.dispatchMessage(msg);        // 消息回收msg.recycleUnchecked();}
}

很尴尬，从上面的代码，我们得出的结论只有loop方法确实是个死循环。但是我们也找到了非常有价值的线索：

// 请注意注释：可能会锁住
Message msg = queue.next(); // might block

赶紧去看一眼MessageQuene.next方法：

 Message next() {int pendingIdleHandlerCount = -1; // -1 only during first iteration// 下一次循环的时间int nextPollTimeoutMillis = 0;for (;;) {if (nextPollTimeoutMillis != 0) {Binder.flushPendingCommands();}// 此native方法很可疑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) {do {prevMsg = msg;msg = msg.next;} while (msg != null && !msg.isAsynchronous());}// 消息不为空，直接返回msgif (msg != null) {if (now < msg.when) {// Next message is not ready.  Set a timeout to wake up when it is ready.nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);} else {// Got a message.// 不要锁住mBlocked = false;if (prevMsg != null) {prevMsg.next = msg.next;} else {mMessages = msg.next;}msg.next = null;if (DEBUG) Log.v(TAG, "Returning message: " + msg);msg.markInUse();return msg;}} else {// No more messages. 消息为空nextPollTimeoutMillis = -1;}// 判断是否有空闲时执行的任务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);}// 开始执行Hanlder空闲时的任务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);}}}// Reset the idle handler count to 0 so we do not run them again.pendingIdleHandlerCount = 0;// While calling an idle handler, a new message could have been delivered// so go back and look again for a pending message without waiting.nextPollTimeoutMillis = 0;}}

上面的代码有点长，但是每一句都有很重要的意义，这里直接总结一下我的发现：

• 每次遍历Msg，都会计算下一次的遍历时间，而这个时间作为参数传给了nativePollOnce；
• nativePollOnce会计算下一次的唤醒时间，如果是-1，表示锁住，等待唤醒；
• IdleHandler，表示空闲时执行的任务，即需要锁住线程的时候；

我还从没使用过IdleHandler，所以就尝试了一下：

// 版本判断
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {handler.looper.queue.addIdleHandler {Log.d("lzp", "Handler in Idle")// 返回true，表示该任务每次空闲时都会执行// 返回false，表示该任务只会执行一次true}
}

经过测试，IdleHandler并不可靠，下面举例：

创建线程，每50毫秒向Handler插入一条Msg，10秒后结束，我希望IdleHandler执行；

很遗憾，上面的需求并不会得到满足，因为程序的执行是非常快的，我们刚处理完第一条Msg，第二条还没有进来，这个时候就已经进入到空闲状态，同理接下来每一条Msg都有可能执行IdleHandler。

问题二：MessageQuene的同步锁何时唤醒

我们已经了解了Handler的轮询处理虽然的确是死循环，但是内部有同步锁的机制，所以并不会锁死线程，但是MessageQuene的同步锁又是什么时候被唤醒的呢？

仔细思考，我们可以猜测：应该是在新消息插入的时候，唤醒了同步锁。我们跟踪一下Handler.post：

// 最后会跟踪到MessageQuene.enqueueMessageboolean enqueueMessage(Message msg, long when) {...synchronized (this) {...msg.markInUse();msg.when = when;Message p = mMessages;// 是否需要唤醒同步锁boolean needWake;if (p == null || when == 0 || when < p.when) {// New head, wake up the event queue if blocked.msg.next = p;mMessages = msg;// 立刻唤醒同步锁needWake = mBlocked;} else {// Inserted within the middle of the queue.  Usually we don't have to wake// up the event queue unless there is a barrier at the head of the queue// and the message is the earliest asynchronous message in the queue.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.nextprev.next = msg;}// 唤醒同步锁if (needWake) {nativeWake(mPtr);}}return true;}

Handler.postXXX方法最终都会执行到MessageQuene.enqueueMessage。

总结

最后做一个总结：

• Handler中的Looper和MessageQuene虽然是双死循环，但是MessageQuene中的死循环中使用了同步锁机制，避免资源的占用，所以并不会锁住线程；
• 当有新消息进入队列时，会唤醒同步锁；

以上内容仅供学习参考，如有错误欢迎指正。