消息處理機制之消息發送

我們通過handler發送消息一般會通過調用Handler類的sendMessage方法，下面就從sendMessage開始分析消息發送的過程。基本的流程如圖所示。

源碼分析 sendMessage爲例分析

frameworks/base/core/java/android/os/Handler.java

public final boolean sendMessage(Message msg)
    {
        return sendMessageDelayed(msg, 0);
    }
    
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;
        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);
    }
    
private boolean enqueueMessage(MessageQueue queue, Message msg, long         uptimeMillis) {
        msg.target = this;
        if (mAsynchronous) {
            msg.setAsynchronous(true);
        }
        return queue.enqueueMessage(msg, uptimeMillis);
    }    

成員函數sendMessage會調用到sendMessageAtTime其中參數uptimeMillis爲系統當前時間加上uptimeMillis延時時間得到的一個將來時間。sendMessageAtTime會調用
enqueueMessage方法將消息放入到MessageQueue的隊列中。MessageQueue對象的引用queue初始化是Handler構造方法中

 public Handler(Callback callback, boolean async) {
        mLooper = Looper.myLooper();
        mQueue = mLooper.mQueue;
        mCallback = callback;
        mAsynchronous = async;
    }

frameworks/base/core/java/android/os/MessageQueue.java

    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. p == null 目標消息隊列爲空隊列
2. when == 0 插入的消息處理時間等於0
3. when < p.when 插入消息的處理時間小於保存在目標消息隊列頭的時間
4. when >= p.when 插入消息的處理時間大於等於保存在目標消息隊列頭的時間

對於1、2、3這三種情況由於目標消息隊列的頭部消息發生了變化，因此我們就需要將目標線程喚醒，以便確保對保存在目標消息隊列頭部的新消息進行處理。但是如果目標線程不是處於睡眠等待狀態就不需要執行喚醒的動作。MessageQueue中的成員變量mBlocked記錄了目標線程的狀態， 如果mBlocked的值爲true就表示目標線程正在處於睡眠等待狀態，需要將它喚醒。

對於4這種情況由於目標消息隊列頭部的消息沒有發生變化，因此不需要對目標線程執行喚醒操作needWake的值爲false。

如果needWake的值爲true就會調用nativeWake方法
frameworks/base/core/jni/android_os_MessageQueue.cpp

static void android_os_MessageQueue_nativeWake(JNIEnv* env, jclass clazz, jlong ptr) {
    NativeMessageQueue* nativeMessageQueue = reinterpret_cast<NativeMessageQueue*>(ptr);
    nativeMessageQueue->wake();
}

void NativeMessageQueue::wake() {
    mLooper->wake();
}

參數ptr指向的是MessageQueue對象的成員變量mPtr,mPtr是NativeMessageQueue對象的地址，在android_os_MessageQueue_nativeWake方法中將其轉換爲了一個NativeMessageQueue對象，接着會調用wake其wake方法，接着會調用C++層Looper對象的wake方法。

void Looper::wake() {
    uint64_t inc = 1;
    ssize_t nWrite = TEMP_FAILURE_RETRY(write(mWakeEventFd.get(), &inc, sizeof(uint64_t)));
    if (nWrite != sizeof(uint64_t)) {
        if (errno != EAGAIN) {
            LOG_ALWAYS_FATAL("Could not write wake signal to fd %d (returned %zd): %s",
                             mWakeEventFd.get(), nWrite, strerror(errno));
        }
    }
}

調用write向管道中寫入&inc，這時候目標線程就會由於管道發生了IO寫操作而被喚醒。

消息的發送過程就分析完了。