Handler发送消息后消息队列的处理

在Android中使用Handler不仅可以直接post发送消息，还可以通过postDelayed设定延迟时间，来延迟执行消息任务。那么这后面的机制是如何处理的呢？

首先查看Handler的源码，会发现post和postDelayed内部均调用的同一方法sendMessageDelayed：

public final boolean post(Runnable r)
{
   return  sendMessageDelayed(getPostMessage(r), 0);
}

public final boolean postDelayed(Runnable r, long delayMillis)
{
    return sendMessageDelayed(getPostMessage(r), delayMillis);
}

在这里的不同是当调用post时，延迟时间传入的是0。

下一步，sendMessageDelayed中：

public final boolean sendMessageDelayed(Message msg, long delayMillis)
{
    if (delayMillis < 0) {
        delayMillis = 0;
    }
    return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
}

将小于0的异常延迟时间置为0，接下来将延迟时间与SystemClock.uptimeMillis()相加，最终调用sendMessageAtTime。
这一步的时间转换，将延迟时间这个相对值，转化为了系统启动后的一个绝对值时间，之后framework中的处理均是在绝对值上进行比较。

再继续追踪源码，handler最终会调用MessageQueue中的方法，将消息添加到队列中：

private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
    msg.target = this;
    if (mAsynchronous) {
        msg.setAsynchronous(true);
    }
    return queue.enqueueMessage(msg, uptimeMillis);  // 添加到消息队列
}

进一步分析MessageQueue中的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;
        }

        // We can assume mPtr != 0 because mQuitting is false.
        if (needWake) {
            nativeWake(mPtr);
        }
    }
    return true;
}

1.在消息对象msg中包含一个when变量，保存的就是该消息应执行的时间（刚才转化后的绝对值时间）。
2.mMessages是MessageQueue类中的一个全局变量，指向的是消息队列中的头节点。因此我们看到判断逻辑前，先将mMessages引用赋值给了变量p。
3.接下来，若消息队列中没有任何消息（p=null），或绝对时间为0，亦或这条消息执行时间在当前队列第一条消息之前，那么将这条消息添加到队列开始的位置；
不满足这些条件时，用一个很典型的链表插入算法，将消息按时间顺序添加到列表中。