本文为作者原创，转载请注明链接
Handler的运行机制是Android程序员面试中经常被问到的一个问题，因为该问题可以考察面试者对于Android源码的了解程度。本文将以源码的角度来探索Handler的机制和原理。
这张图是本人画的，下面通过绑定Looper和MessageQueue、发送消息、处理消息三个步骤来解析Handler的源码。
Looper.prepare()和Looper.loop()方法
要在某一个线程中使用Handler接受处理消息，必须在该线程中执行这两个方法。那为什么我们平时好像没有调用过着两个方法呢？那是因为Android主线程已经帮我们调用了这两个方法。例如要在子线程中使用Handler接收处理消息，就需要我们自己手动调用这两个方法了。在本文中只讨论在主线程中使用Handler接受处理消息的情况(在子线程的情况也是一样的)。
先来看看Looper.prepare()和Looper构造函数的源码：
public static void prepare() {
prepare(true);
}
private static void prepare(boolean quitAllowed) {
if (sThreadLocal.get() != null) {
throw new RuntimeException("Only one Looper may be created per thread");
}
sThreadLocal.set(new Looper(quitAllowed));
}
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
可以看到在这段源码中，new了一个Looper对象保存到了sThreadLocal中。那么ThreadLocal又是什么东西呢？ThreadLocal是一个线程内部的数据存储类，这里不展开介绍它。简单来说ThreadLocal可以根据不同的线程保存和读取不同的数据，由于Handler使用的时候就是多线程的情景，在这里使用ThreadLocal来保存主线程中的Looper对象再合适不过了。而在Looper的构造函数中，new了一个MessageQueue并赋值给成员变量mQueue，即为该Looper对象绑定了一个MessageQueue。
那么这段代码总结起来，它的目的就是在为主线程创造并绑定一个Looper对象，并为该Looper对象绑定一个MessageQueue对象。
下面再来看看Looper.loop()方法做了什么事：
public static void loop() {
final Looper me = myLooper();
if (me == null) {
throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
}
final MessageQueue queue = me.mQueue;
Binder.clearCallingIdentity();
final long ident = Binder.clearCallingIdentity();
for (;;) {
Message msg = queue.next(); // might block
if (msg == null) {
// No message indicates that the message queue is quitting.
return;
}
......
}
}
这段源码就比较长了，没关系我们只看重点。
首先通过myLooper()方法拿到looper对象，然后通过该对象拿到MessageQueue对象queue。下面使用Binder和底层通信，这里不展开。
重点在于下面的无限for循环。for (;;)非常简单粗暴，调用了MessageQueue的next()方法。后面的注释提示了这个方法可能会阻塞。如果返回的消息为null，代表MessageQueue已退出，return退出loop()方法。如果MessageQueue中没有消息对象，next()方法会阻塞，直到再有消息传进来。
Handle发送消息方法
Handle的sendMessage方法最终调用的是sendMessageAtTime方法，来看看这个方法干了什么：
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);
}
很简单，先判断有没有绑定的MessageQueue对象，如果没有就要抛异常。有的话执行enqueueMessage方法。
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
}
msg.target这个成员变量就是Hanlder类，赋值为this代表，把消息发给调用这个方法的Handler。然后执行queue.enqueueMessage方法。这个方法将消息加进MessageQueue中，如果原来的MessageQueue中没有消息，会唤醒它执行next()方法取消息。具体的源码涉及native层的操作，在这里就不展开讨论了，有兴趣的朋友可以研究下。
如果是用post(Runnable r)方法发消息呢？
public final boolean postAtTime(Runnable r, long uptimeMillis) {
return sendMessageAtTime(getPostMessage(r), uptimeMillis);
}
private static Message getPostMessage(Runnable r) {
Message m = Message.obtain();
m.callback = r;
return m;
}
可以看到最终调用的还是sendMessageAtTime方法，只是通过getPostMessage方法把runnable对象放进一个消息对象传出去。
Handler处理消息
通过上面的流程，消息发出来了，进入MessageQueue中，我们在主线程又通过Looper.loop()方法把消息取出来了，那下面怎么处理消息呢？继续来看Looper.loop()方法，取出消息后有这么一段代码：
try {
msg.target.dispatchMessage(msg);
} finally {
if (traceTag != 0) {
Trace.traceEnd(traceTag);
}
}
msg.target是什么？不就是上面enqueueMessage方法中，我们传人的handle对象嘛。也就是说这里调用了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);
}
}
private static void handleCallback(Message message) {
message.callback.run();
}
首先判断消息中的callback是否为空，如果post(Runnable r)发来的消息，这里的callback就是传来的runnable对象了，调用handleCallback(msg)处理。这个方法就简单了，直接运行该runnable即可。
callback对象为空，会判断mCallback是否为空。这里的mCallback对象是Handler构造函数中传进来的，是Hanlder中的内部接口。如果有就回调接口实现的handleMessage(msg)方法。没有的话，调用handleMessage(msg)方法。该方法默认什么都不做，一般是我们自己重写该方法处理消息。
总结
至此，Handler发送消息，取消息，处理消息的流程我们已经从源码的角度剖析完成了。下次面试再被问到就可以游刃有余地回答了。MessageQueue中的next()和enqueueMessage方法涉及到很多native方法，在本文中没有展开研究，有兴趣的朋友可以把这部分也搞明白了，对Handler机制会有一个更深的理解。
