00、前言

01、用法

第一种 post(Runnable)

mHandler.post(object :Runnable{
    override fun run() {
        // TODO  具体业务逻辑
    }
})

为了直接的理解，未通过 lambda 表达式简化写法。这里传的参数是一个 Runnable。

第二种 sendMessage(Message)

val msg = Message()
msg.what = 1
msg.obj = "Quincy"
mHandler.sendMessage(msg)

这个方法传入的参数是一个 Message 对象。

02、源码

发送消息的方式其实远远不止以上两种方法。在实际开发中，我们可以根据实际情况选择更多的方法。例如：postAtTime(),postDelayed() ,sendEmptyMessage()，sendMessageAtFrontOfQueue()等等。

但，实际上无论是哪一个方法，最后都调用 Handler 中的同一个方法 —— enqueueMessage()。

接下来，就让我们通过查看源码的方式，看看发送消息是怎么样的一个过程吧。

// Handler.java

//post 方法
public final boolean post(@NonNull Runnable r) {
   return  sendMessageDelayed(getPostMessage(r), 0);//标识 0
}

//sendMessage 方法
public final boolean sendMessage(@NonNull Message msg) {
    return sendMessageDelayed(msg, 0); //标识 1
}

在这里，我们发现这两个方法最后都调用了同一个方法 sendMessageDelayed() ，那我们接下来任务就只需要跟进这个方法就行了。

在此之前，我们先看看这两个方法源码上的区别。第二个方法就是直接将我们传进来的 Message 传到下一个方法中，而第一个方法是通过getPostMessage(r) 将我们传进来的 Runnable 包装成了一个 Message。

//Handler.java
//跟进标识 0
private static Message getPostMessage(Runnable r) {
    Message m = Message.obtain();
    m.callback = r;
    return m;
}

通过 Message.obtain() 获得一个 Message 对象。并且将我们 传进来的 Runnable 赋值给 Message 的 Callback。这里是‘考点’，后面消息分发要考。

好了，回到主线任务。继续跟进 sendMessageDelayed()吧。

//Handler.java

//跟进标识 1
public final boolean sendMessageDelayed(@NonNull Message msg, long delayMillis) {
    if (delayMillis < 0) { //传的延迟时间小于 0 的，直接改为 0，即不延迟。
        delayMillis = 0;
    }
    return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);//标识 2
}

//跟进标识 2
public boolean sendMessageAtTime(@NonNull Message msg, long uptimeMillis) {
    MessageQueue queue = mQueue;
    if (queue == null) {
        RuntimeException e = new RuntimeException(
                this + " sendMessageAtTime() called with no mQueue");
        Log.w("Looper", e.getMessage(), e);
        return false;
    }
    return enqueueMessage(queue, msg, uptimeMillis);//标识 3
}

//跟进标识 3
private boolean enqueueMessage(@NonNull MessageQueue queue, @NonNull Message msg,
        long uptimeMillis) {
    msg.target = this; //注意这里，将当前的 Handler 赋值给 Message 的 target 属性。这个在分发消息的时候，也要考。
    msg.workSourceUid = ThreadLocalWorkSource.getUid();

    if (mAsynchronous) { //暂时先不管，后面讲到同步消息和异步消息再来看。
        msg.setAsynchronous(true);
    }
    return queue.enqueueMessage(msg, uptimeMillis);//标识 4 
}

要注意的点，都标注在上面的代码中。这里罗列一下：

• 如果传入的延迟时间小于，则认为是不需要延迟，立刻执行。

• 在 enqueueMessage 方法中，会将当前的 Handler 赋值给 Message 的 target 属性。用于后续消息分发，寻找分发对象。

温馨提示：标识 4 ，不再是 Handler 的方法了。而是调用到了 MessageQueue 中的方法。

//MessageQueue.java
boolean enqueueMessage(Message msg, long when) {
    if (msg.target == null) {
        throw new IllegalArgumentException("Message must have a target.");
    }

    synchronized (this) { //为当前的 MessageQueue 消息队列加锁。因为Handler与MessageQueue 的关系，是多对一。
        if (msg.isInUse()) {
            throw new IllegalStateException(msg + " This message is already in use.");
        }

        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; //mMessage为当前消息分发到的消息位置
        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;
}

主要的分析，已经在代码当中，同样进行罗列回顾一下：

• 因为一个线程中，可以有多 Handler ，但只有一个 MessageQueue。所以为了线程安全，在占用当前 MessageQueue 的时候，需要加上同步锁。

• for ( ; ; ) 这个死循环的作用是，按消息执行时间升序排队。

03、结语

到这里我们的消息就进入到了 MessageQueue 中了。接下来就是等待被 Looper 传唤了。那我们下篇文章再见啦~