new Handler().obtainMessage().sendToTarget()过程分析

new Handler().obtainMessage().sendToTarget()这句话用着真爽，一行代码就能搞定异步消息了！所以在代码中使用的算是非常频繁的了，那这又是一个什么样的过程呢？ 这个过程中又有什么玄机呢？ 这篇文章，我们来一步步的分析一下这三句话。

1、new Handler()的分析

new Handler()会辗转来到public Handler(Callback callback, boolean async)这个构造方法。在这个构造方法中会获取当前Looper：

mLooper = Looper.myLooper();

而此时的Looper是默认的那个Looper，即在ActivityThread的main方法中prepare的Looper

在ActivityThread.main中：

Looper.prepareMainLooper();
...
Looper.loop();

此时Handler和Looper有了关联。

2、obtainMessage()的分析

在Handler.obtainMessage()中会调用Message.obtain(this)。
Message.obtain()的源码：

public static Message obtain(Handler h) {
        Message m = obtain();
        m.target = h;
        return m;
  }

obtain从消息池中构造一个message，并将message的target置为传进来的handler。

此时handler和message有了关联。

3、sendToTarget()的分析

public void sendToTarget() {
        target.sendMessage(this);
}

直接调用target.sendMessage，而target正是当前的Handler。
继续跟踪target.sendMessage(this) target中发送消息会辗转来到private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis)
在这个方法中有去调用queue.enqueueMessage.

继续跟踪queue.enqueueMessage,这个方法有点长，主要是将当前Message压入消息队列中：

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

这里面的MessageQueue就是在Handler保存的那个MessageQueue，也就是说此时，这个Message已经保存到Handler中的那个消息队列中了。而，我们Handler中的MessageQueue哪来的呢？ 来看看这行代码：

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

Handler中的MessageQueue正式从Looper中获取的，这个Looper当然就是在ActivityThread中prepare的那个。


顺一下此时的关系：Handler中保存了ActivityThread中的Looper，并从该Looper中获取了MessageQueue；调用obtainMessage，实质上是创建了一个Message对象，并将Message对象的target设置为现在的Handler；调用Message.sendToTarget()实际是调用了Message.target.sendMessage()，即Handler.sendMessage，而Handler.sendMessage会来到enqueueMessage方法，在这个方法中调用MessageQueue.enqueueMessage将消息压缩刚开始我们获取的那个MessageQueue。

此时，再来看看Looper.loop()是怎么将消息回调到handleMessage中的：

for (;;) {
        Message msg = queue.next(); // might block
        ...
        msg.target.dispatchMessage(msg);
        ...
        msg.recycle();
 }

继续看看Handler.dispatchMessage():

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

转来转去，终于把Message回调到了handleMessage！！！
从源码中，我们也能看出， sendToTarget()方法并不是真正的将Message发送出去，而是将Message压入了MessageQueue中，真正去回调handleMessage还是在Looper.loop()中完成的。