Handler延时处理消息的流程

前言

昨天碰到一个关于handler的问题，当我使用sendEmptyMessageDelayed这个方法，在手机熄屏的情况下并没有按时发送消息，而且中间的时间还不固定，有时候短，有时候长，但是在亮屏和充电情况下，没有该问题。
难道handler的延时本身就不准？带着疑问我看了下handler的运行机制，找到了答案！

next()和enqueueMessage()

本篇文章默认为你已经知道handler的使用发法，所以我不会对handler的基础只是做介绍了。

当我使用sendEmptyMessageDelayed的时候，源码依次的调用顺序是；
sendEmptyMessageDelayed(int what, long delayMillis) —>
sendMessageDelayed(Message msg, long delayMillis) —>
sendMessageAtTime(Message msg, long uptimeMillis) —>
enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis)

其中enqueueMessage调用的MessageQueue的boolean enqueueMessage(Message msg, long when)，接下来我们来看看该函数。

文件：MessageQueue.java

boolean enqueueMessage(Message msg, long when) {        if (msg.target == null) {            throw new IllegalArgumentException("Message must have a target.");        }        if (msg.isInUse()) {            throw new IllegalStateException(msg + " This message is already in use.");        }        synchronized (this) {            //退出时，回收msg，放到消息池            if (mQuitting) {                IllegalStateException e = new IllegalStateException(                        msg.target + " sending message to a Handler on a dead thread");                Log.w(TAG, e.getMessage(), e);                msg.recycle();                return false;            }            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; //这时为true            } else {                // 插入到队列中间，经常我们不需要唤醒事件队列，除非队列的                // 头部有一个障碍或者消息是该队列最早的异步消息                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;    }

从代码可以看出该类的作用是把消息按时间顺序排序，并且控制线程的唤醒，但是我们对mBlocked和handler是怎么记时，还是不清楚，接来我们来看看Loop是怎么取消息的

我们看Loop.loop()就可以知道，取消息是这行代码：

Message msg = queue.next(); // might block

所以我们再看看next()

文件：MessageQueue.java

Message next() {        // Return here if the message loop has already quit and been disposed.        // This can happen if the application tries to restart a looper after quit        // which is not supported.        final long ptr = mPtr;        if (ptr == 0) {            return null;        }        int pendingIdleHandlerCount = -1; // 第一个迭代时为 -1        int nextPollTimeoutMillis = 0; // 阻塞的时间        for (;;) {            if (nextPollTimeoutMillis != 0) {                Binder.flushPendingCommands();            }            // 阻塞操作            nativePollOnce(ptr, nextPollTimeoutMillis);            synchronized (this) {                // 获取系统启动后，到现在的时间                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());                }                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;                        if (DEBUG) Log.v(TAG, "Returning message: " + msg);                        msg.markInUse();                        return msg;                    }                } else {                    // 没有消息                    nextPollTimeoutMillis = -1;                }                // Process the quit message now that all pending messages have been handled.                if (mQuitting) {                    dispose();                    return null;                }                // 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.                if (pendingIdleHandlerCount < 0                        && (mMessages == null || now < mMessages.when)) {                    pendingIdleHandlerCount = mIdleHandlers.size();                }                if (pendingIdleHandlerCount <= 0) {                    // 没有idle handlers 在运行，loop需要等待                    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(TAG, "IdleHandler threw exception", t);                }                if (!keep) {                    synchronized (this) {                        mIdleHandlers.remove(idler);                    }                }            }            // 重置idle handler 的数量为0，这样我们就不会再次运行            pendingIdleHandlerCount = 0;            // 当调用一个空闲的handler时, 一个新的消息可以被分发            // 因此可以不需要等待，直接查询pending message            nextPollTimeoutMillis = 0;        }    }

从这个方法中可以看出，handler获取时间的方式是调用SystemClock.uptimeMillis()，并用它和消息的里包含的时间进行对比。
同时next()方法内部如果有阻塞，会把mBlocked设置true，在下一个Message进队列时会判断这个message的位置，如果在队首就会调用nativeWake()方法唤醒线程。

综上所述：
1. 如果我sendEmptyMessageDelayed发送了消息A，延时为500ms，这时消息进入队列，触发了nativePollOnce，Looper阻塞，等待下一个消息，或者是Delayed时间结束，自动唤醒；
2. 在1的前提下，紧接着又sendEmptyMessage了消息B，消息进入队列，但这时A的阻塞时间还没有到，于是把B插入到A的前面，然后调用nativeWake()方法唤醒线程
3. 唤醒之后，会重新都取队列，这是B在A前面，有不需要等待，于是直接返回给Looper
4. Looper处理完该消息后，会再次调用next()方法，如果发现now大于msg.when则返回A消息，否则计算下一次该等待的时间

看到这里你可能想说，这和我的问题没什么关系啊，别急，答案就在SystemClock.uptimeMillis()，handler是通过它来获取时间的，但uptimeMillis()是不包括休眠的时间的，所以手机如果在休眠状态下（android 7.0在灭屏情况下很容易进入休眠），那时间就一直不变，至于中途又发送消息了，那是因为手机被唤醒了（android7.0会定时唤醒手机，接收消息），这时执行完delay操作，就可以发送消息了。