消息队列采用排队方式对消息进行处理，即先到的消息会先得到处理，但如果消息本身指定了被处理的时刻，则必须等到该时刻才能处理该消息。消息在MessageQueue中使用Message类表示，队列中的消息以链表的结构进行保存，Message对象内部包含一个next变量，该变量指向下一个消息对象。

MessageQueue中的两个主要函数是“取出消息”和“添加消息”，分别是next()和enquenceMessage()。

next()函数

final Message next() {
        int pendingIdleHandlerCount = -1; // -1 only during first iteration
        int nextPollTimeoutMillis = 0;

        for (;;) {
            if (nextPollTimeoutMillis != 0) {
                Binder.flushPendingCommands();
            }
            nativePollOnce(mPtr, nextPollTimeoutMillis);

            synchronized (this) {
                // Try to retrieve the next message.  Return if found.
                final long now = SystemClock.uptimeMillis();
                final Message msg = mMessages;
                if (msg != null) {
                    final long when = msg.when;
                    if (now >= when) {
                        mBlocked = false;
                        mMessages = msg.next;
                        msg.next = null;
                        if (Config.LOGV) Log.v("MessageQueue", "Returning message: " + msg);
                        return msg;
                    } else {
                        nextPollTimeoutMillis = (int) Math.min(when - now, Integer.MAX_VALUE);
                    }
                } else {
                    nextPollTimeoutMillis = -1;
                }

                // If first time, then get the number of idlers to run.
                if (pendingIdleHandlerCount < 0) {
                    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);
            }

            // 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("MessageQueue", "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;
        }
    }

该函数的内部流程分三步：

1. 调用nativePollOnce(mPtr, int time)。这是一个JNI函数，作用是从消息队列中取出一个消息。MessageQueue类内部本身并没有保存消息队列，真正的消息队列数据保存在JNI中的C代码中，在C环境中创建了一个NativeMessageQueue数据对象，这就是nativePollOnce()第一个参数的意义。它是一个int型变量，在C环境中，该变量被强制转换为一个NativeMessageQueue对象。在C环境中，如果消息队列中没有消息，将导致当前线程被挂起(wait)，如果消息队列中有消息，则C代码中将把该消息赋值给Java环境中的mMessages变量。

2. 接下来的代码被包含在synchronized(this)中，this被用作取消息和写消息的锁。仅仅是判断消息所指定的执行时间是否到了。如果到了，就返回该消息，并将mMessages变量置空；如果时间还没有到，则尝试读取下一个消息。

3. 如果mMessages为空，则说明C环境中的消息队列没有可执行的消息了，因此，执行mPendingIdleHanlder列表中的“空闲回调函数”。可以向MessageQueue中注册一些“空闲回调函数”，从而当线程中没有消息可处理的时候去执行这些“空闲代码”。

enquenceMessage()函数

final boolean enqueueMessage(Message msg, long when) {
        if (msg.when != 0) {
            throw new AndroidRuntimeException(msg
                    + " This message is already in use.");
        }
        if (msg.target == null && !mQuitAllowed) {
            throw new RuntimeException("Main thread not allowed to quit");
        }
        final boolean needWake;
        synchronized (this) {
            if (mQuiting) {
                RuntimeException e = new RuntimeException(
                    msg.target + " sending message to a Handler on a dead thread");
                Log.w("MessageQueue", e.getMessage(), e);
                return false;
            } else if (msg.target == null) {
                mQuiting = true;
            }

            msg.when = when;
            //Log.d("MessageQueue", "Enqueing: " + msg);
            Message p = mMessages;
            if (p == null || when == 0 || when < p.when) {
                msg.next = p;
                mMessages = msg;
                needWake = mBlocked; // new head, might need to wake up
            } else {
                Message prev = null;
                while (p != null && p.when <= when) {
                    prev = p;
                    p = p.next;
                }
                msg.next = prev.next;
                prev.next = msg;
                needWake = false; // still waiting on head, no need to wake up
            }
        }
        if (needWake) {
            nativeWake(mPtr);
        }
        return true;
    }

1. 将参数msg赋值给mMessages。

2. 调用nativeWake(mPtr)。这是一个JNI函数，其内部会将mMessages消息添加到C环境中的消息队列中，并且如果消息线程正处于挂起(wait)状态，则唤醒该线程。

【内核研究】消息队列_MessageQueue