handler發送消息之後做了什麼事情。

首先來看handler發消息的幾個方式：
Handler提供了好幾個發送消息的方式。
post系列和sendMessage系列都是差不多的最終都會調用sendMessageAtTime（）函數：這裏用post系列舉例
handler.post(Runnable r) 入參是一個Runnable。
看看裏面做了什麼。
public final boolean post(Runnable r)
{
return sendMessageDelayed(getPostMessage®, 0);
}
裏面有一個getPostMessage®;裏面做的事情就是拿到一個message。我們來看看裏面的實現：它裏面通過Message.obtain()（這個方法使用了享元模式這裏不細講）方法拿到一個message對象。然後把我們傳進來的Runnable添加到message中。
private static Message getPostMessage(Runnable r) {
Message m = Message.obtain();
m.callback = r;
return m;
}
再看 sendMessageDelayed();裏面最終調用的是sendMessageAtTime（）方法
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);
}

這個方法有一個msg.target= this。這裏要注意一下。這個target是message裏面的一個屬性，是一個Handler。之後處理消息的可以表示是哪個handler發出來的消息。
    private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
    msg.target = this;
    if (mAsynchronous) {
        msg.setAsynchronous(true);
    }
    return queue.enqueueMessage(msg, uptimeMillis);
}
這個是我們發出的message真正入隊的方法。隊列是一個Message的鏈表結構的。根據時間排序來插入消息的。
boolean enqueueMessage(Message msg, long when) {

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