@UnsupportedAppUsage
    Message next() {
        int pendingIdleHandlerCount = -1; // -1 only during first iteration
        int nextPollTimeoutMillis = 0;
        for (;;) {
           //进入等待消息，要被唤醒2种情况，1被其他函数wake，2等待时间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;
                //当消息的Handler为空时，则查询异步消息
                if (msg != null && msg.target == null) {
                    // Stalled by a barrier.  Find the next asynchronous message in the queue.
                     //当查询到异步消息，则立刻退出循环
                    do {
                        prevMsg = msg;
                        msg = msg.next;
                    } while (msg != null && !msg.isAsynchronous());
                }
                if (msg != null) {
               	 //检测msg时间是还没到了
                    if (now < msg.when) {
                        // Next message is not ready.  Set a timeout to wake up when it is ready.
                        //还没到msg的处理时间，那么就会与当前时间进行差值，这个差值就是等待时间nextPollTimeoutMillis
                        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
                            mMessages = msg.next;
                        }
                        msg.next = null;
                        msg.markInUse();
                        //直接return回去消息，也就是有消息都在这里return了不会执行下面业务
                        return msg;
                    }
                } else {
                //没有找到消息
                    // No more messages.
                    nextPollTimeoutMillis = -1;
                }

                // 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.
                //找了一圈发现没有要处理的消息了，那么就开始判断是否有IdleHandler的消息要处理
                //注意这里的pendingIdleHandlerCount第一次进入才是-1，后续一旦执行IdleHandler都是变成0，不会再进入
                if (pendingIdleHandlerCount < 0
                        && (mMessages == null || now < mMessages.when)) {
                    //把mIdleHandlers集合大小赋值给pendingIdleHandlerCount
                    pendingIdleHandlerCount = mIdleHandlers.size();
                }
                //如果发现没有IdleHandler，那么就返回循环进行block阻塞等待唤醒
                if (pendingIdleHandlerCount <= 0) {
                    // No idle handlers to run.  Loop and wait some more.
                    mBlocked = true;
                    continue;
                }
							//如果mPendingIdleHandlers这个数组没有初始化就进行初始化，这里最小大小为4应该是为了性能以防频繁扩容
                if (mPendingIdleHandlers == null) {
                    mPendingIdleHandlers = new IdleHandler[Math.max(pendingIdleHandlerCount, 4)];
                }
                //mIdleHandlers转成了数组mPendingIdleHandlers
                mPendingIdleHandlers = mIdleHandlers.toArray(mPendingIdleHandlers);
            }

            // Run the idle handlers.
            // We only ever reach this code block during the first iteration.
            //开始正式执行对应的IdleHandler
            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 {
                //执行IdleHandler的对应回调业务方法
                    keep = idler.queueIdle();
                } catch (Throwable t) {
                    Log.wtf(TAG, "IdleHandler threw exception", t);
                }
								//这里的keep就是queueIdle的返回值，如果返回false就会从mIdleHandlers进行移除
                if (!keep) {
                    synchronized (this) {
                        mIdleHandlers.remove(idler);
                    }
                }
            }
						//把pendingIdleHandlerCount变成0，不是-1，这样防止死循环执行IdleHandler
            // Reset the idle handler count to 0 so we do not run them again.
            pendingIdleHandlerCount = 0;
					//这里是为了让尽快遍历一下是否有消息，因为可能执行IdleHandler期间有新消息
            // 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;
        }
    }