Handler源码解读（三）

今天重点研究下 Handler 消息延迟

Handler 的 sendMessageDelayed

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

    public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
        MessageQueue queue = mQueue;

        return enqueueMessage(queue, msg, uptimeMillis);
    }

此时的 uptimeMillis 是当前时间 + 延迟时间，必定会大于 0 的。

    private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
        msg.target = this;
        if (mAsynchronous) {
            msg.setAsynchronous(true);
        }
        return queue.enqueueMessage(msg, uptimeMillis);
    }

我们知道在 MessageQueue 中加入消息 

    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) {
                
                msg.next = p;
                mMessages = msg;
                needWake = mBlocked;
            } else {
                //
            }
            if (needWake) {
                nativeWake(mPtr);
            }
        }
        return true;
    }

如果 p == null，则证明当前消息队列没有消息。

如果 when == 0，则是调用 Handler 的 sendMessageAtFrontOfQueue 发送消息。

    public final boolean sendMessageAtFrontOfQueue(Message msg) {
        MessageQueue queue = mQueue;

        return enqueueMessage(queue, msg, 0);
    }

如果 when < p.when，则是新来的消息比第一个消息还早。

这三种情况将 mMessages 设置为新消息，新消息的下一个消息next则为原来的消息。也就是说将消息插入到队列的头节点。

    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) {
                //
            } else {

                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;
    }

如果三种情况都不符合，遍历当前消息队列，将新消息的 when 与消息队列中消息的 when 比较，新消息再插入到队列中。此时队列也就是按照 when 的队列。

此时 needWake 为 true（后续再理解 needWake ），调用 nativeWake，由前两节知道，这里在 eventfd 中写入数据了。

接下来再看下消息循环

    Message next() {
        //...
        int nextPollTimeoutMillis = 0;
        for (;;) {

            nativePollOnce(ptr, nextPollTimeoutMillis);

            synchronized (this) {
                //获取下一条消息
                final long now = SystemClock.uptimeMillis();
                Message prevMsg = null;
                Message msg = mMessages;
                if (msg != null && msg.target == null) {
                    //msg.target暂时不处理
                }
                if (msg != null) {
                    if (now < msg.when) {
                        //一下条消息还没有准备好
                        nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
                    } else {
                        
                        mBlocked = false;
                        if (prevMsg != null) {
                            prevMsg.next = msg.next;
                        } else {
                            mMessages = msg.next;
                        }
                        msg.next = null;
                        
                        msg.markInUse();
                        return msg;
                    }
                } else {
                    
                    nextPollTimeoutMillis = -1;
                }

                //IdleHandler相关
            }

            //IdleHandler相关

            nextPollTimeoutMillis = 0;
        }
    }

 这段代码，首先 nextPollTimeoutMillis 为 0 时 nativePollOnce 唤醒，或者之前发送消息使 nativePollOnce 唤醒。取出消息队列头节点的消息，这个消息的 when 自然使最小。与当前时间 now 比较。

如果比当前时间大的话，说明头节点的消息还没有触发，计算插值 nextPollTimeoutMillis。相反，则取出此次消息进行分发处理。

而计算出的 nextPollTimeoutMillis，则循环给 nativePollOnce 的参数，重新设置等待时间。

消息延迟总结

1、消息队列按照消息触发的事件进行排序。

2、设置 epoll_wait 的超时时间，使其在待定的时间唤醒。

3、消息延迟的精度不高，如果消息队列中处理消息比较耗时，会导致后面消息延迟处理。