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

前言

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

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

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

/**Looper*/
public static void loop() {
        ...
        for (;;) {
            Message msg = queue.next(); // might block
            if (msg == null) {
                // No message indicates that the message queue is quitting.
                return;
            }
            ...
            msg.recycleUnchecked();
        }
    }

/**MessageQuene*/
Message next() {
        ...
        int pendingIdleHandlerCount = -1; // -1 only during first iteration
        int 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 block
            if (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());
                }
                // 消息不为空，直接返回msg
                if (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.enqueueMessage
 boolean 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.next
                prev.next = msg;
            }

            // 唤醒同步锁
            if (needWake) {
                nativeWake(mPtr);
            }
        }
        return true;
    }

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

总结

最后做一个总结：

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

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