一篇文章搞懂Handler发消息时，Handler，MessageQueue，Looper都做了些什么

先给出结论，然后再看下源码究竟是怎么做的。

• Handler发送消息
• MessageQueue入队列
• Looper取消息
• Handler分发消息

发送消息

一共七个发送消息的方法，这里我们加上编号。方便之后写他们的调用关系。

• 1.sendMessage(Message msg)
• 2.sendEmptyMessage(int what)
• 3.sendEmptyMessageDelayed(int what, long delayMillis)
• 4.sendEmptyMessageAtTime(int what, long uptimeMillis)
• 5.sendMessageDelayed(Message msg, long delayMillis)
• 6.sendMessageAtTime(Message msg, long uptimeMillis)
• 7.sendMessageAtFrontOfQueue(Message msg)
  我们看下sendMessage(Message msg)

 public final boolean sendMessage(Message msg)
    {
        return sendMessageDelayed(msg, 0);
    }

可以看到只是调用sendMessageDelayed(msg, 0)方法。再看其他方法，大多类似。他们的关系如下

• 1–>5–>6
• 2–>3–>5–>6
• 4–>6
• 6–>enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis)
• 7–>enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis)

这个有一个知识点，我们看到1,2,3,4,5最后都是调用sendMessageAtTime这个方法。那么发送延时消息是怎么计算时间的呢？举一个源码的例子

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

注意这里SystemClock.uptimeMillis() + delayMillis，其实就是系统启动未休眠时间+延迟时间。SystemClock.uptimeMillis()这个方法返回的官方注解Returns milliseconds since boot, not counting time spent in deep sleep.。个人理解手机启动后未休眠状态的时间。Android 7.0之后手机息屏太久会进入休眠。可以看到会计算出延时后的时间，然后进行入队列。那么入队列又是怎么操作的，继续看。

入队列，进入消息池

看名字就是消息入队列了。看下源码

    private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
        //Handler target是Message的成员变量
        msg.target = this;
        if (mAsynchronous) {
            //是否异步
            msg.setAsynchronous(true);
        }
        //MessageQueue执行入队列操作
        return queue.enqueueMessage(msg, uptimeMillis);
    }

接着看MessageQueue的enqueueMessage方法

    boolean enqueueMessage(Message msg, long when) {
        //handler为空抛异常
        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) {
            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;
            
            //当前队列的队头msg
            Message p = mMessages;
            boolean needWake;
            //解释下when < p.when ：这个消息触发时间比p早，所以把这个消息放在P之前，也就是队头
            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 {
                //否则也就是需要放在队列的队头msg之后
                //关于needWake回头再研究
                needWake = mBlocked && p.target == null && msg.isAsynchronous();
                Message prev;
                //遍历循环找到要插入的位置
                for (;;) {
                    将当前的P赋值给临时变量prev
                    prev = p;
                    p = p.next;//p赋值p的next
                    
                    //如果没有下一个，或者当前的触发时间早于P的触发时间，跳出循环
                    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;
    }

注释已经很清楚。可以看到入队列就是按照消息触发时间，进入队列。至此，入队列完全结束。

处理消息

正常情况下，发消息流程到此结束。但是好奇的你一定发现消息发送完成了，谁处理啊？Looper啊，Looper.loop();但是这个方法要手动调用。有经验的一定知道Activity中不需要手动调用，因为在Activity中系统已经帮我们调用了。

至于Looper.loop()方法，这里简单提一下。在入队列时，我们已经按消息触发时间排好序了，那么Looper.loop()要做的就是不断取出队列头的msg，调用Handle.dispatchMessage(msg)。

    public static void loop() {
    
        ······
        
        for (;;) {
        
        
            //拿到队头的消息
            Message msg = queue.next(); // might block
            if (msg == null) {
                // No message indicates that the message queue is quitting.
                return;
            }
            ······
            try {
                //msg.target.dispatchMessage(msg)其实就是Handler.dispatchMessage(msg);
                msg.target.dispatchMessage(msg);
                dispatchEnd = needEndTime ? SystemClock.uptimeMillis() : 0;
            } finally {
                if (traceTag != 0) {
                    Trace.traceEnd(traceTag);
                }
            }
            ······
        }
    }

细心的你一定又发现，延迟消息在队头，又不到时间怎么处理？当然有办法处理，我们看下queue.next()的源码

    Message next() {
    
        ···省略代码···
        
        int pendingIdleHandlerCount = -1; // -1 only during first iteration
        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;
                }

                ···省略代码···
        }
    }

也就是只有到了消息触发的时间调用next才会返回msg。

到这里我们还差最后一步，如何将通知到目标线程。
我们看下msg.target.dispatchMessage(msg);其实就是Handle.dispatchMessage(msg)做了哪些操作

	public void dispatchMessage(Message msg) {
        if (msg.callback != null) {
            handleCallback(msg);
        } else {
            if (mCallback != null) {
                if (mCallback.handleMessage(msg)) {
                    return;
                }
            }
            handleMessage(msg);
        }
    }

终于到了我们熟悉handleMessage(msg)了。相信到mCallback.handleMessage(msg)大家就都明白是怎么回事了。
至此全部结束。