Android 深入理解Handler, Looper, Message 三者之间的关系

Handler, Looper, Message三者之间的关系基本上是面试官必问问题之一，那今天让我们从源码的角度来解读一下它们之间的关系

Handler 构造

//主线程创建Handler
Handler handler = new Handler();

public Handler() {
this(null, false);
}

public Handler(Callback callback, boolean async) {
if (FIND_POTENTIAL_LEAKS) {
final Class<? extends Handler> klass = getClass();
if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&
(klass.getModifiers() & Modifier.STATIC) == 0) {
Log.w(TAG, "The following Handler class should be static or leaks might occur: " +
klass.getCanonicalName());
}
}

mLooper = Looper.myLooper();
if (mLooper == null) {
throw new RuntimeException(
"Can't create handler inside thread that has not called Looper.prepare()");
}
mQueue = mLooper.mQueue;
mCallback = callback;
mAsynchronous = async;
}

以上就是Handler的构造方法，下面我们来分析下两个重点

mLooper = Looper.myLooper();

public static @Nullable Looper myLooper() {
return sThreadLocal.get();
}

通过myLooper方法得到一个Looper，sThreadLocal存放的Looper，是主线程main方法中创建的

mQueue = mLooper.mQueue;

mQueue 为消息队列，是从Looper中获取，接下来看它发送消息的逻辑

Handler 发送消息

handler.sendMessage(new Message());

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

上面代码经过层层调用，最终把消息插入到MessageQueue 队列中（queue队列就是在构造方法中从Looper得到的 ）

//把Hander对象赋值给消息的target 的属性
msg.target = this;

从构造方法和发送消息可以得出：首先得到主线程创建的Looper对象，然后得到Looper对象中的MessageQueue，然后发送消息到MessageQueue队列当中，插入消息队列以后要如何处理呢？我们来看看Looper的一些方法

Looper prepare方法

主线程在创建的时候会调用Looper的prepare和loop方法，那prepare方法里面干了什么呢？

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

创建一个Looper对象然后存放到sThreadLocal中，而Handler对象中的Looper就是从sThreadLocal中获取的，接下来看看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;

// Make sure the identity of this thread is that of the local process,
// and keep track of what that identity token actually is.
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;
}

// This must be in a local variable, in case a UI event sets the logger
Printer logging = me.mLogging;
if (logging != null) {
logging.println(">>>>> Dispatching to " + msg.target + " " +
msg.callback + ": " + msg.what);
}

msg.target.dispatchMessage(msg);

if (logging != null) {
logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
}

// Make sure that during the course of dispatching the
// identity of the thread wasn't corrupted.
final long newIdent = Binder.clearCallingIdentity();
if (ident != newIdent) {
Log.wtf(TAG, "Thread identity changed from 0x"
+ Long.toHexString(ident) + " to 0x"
+ Long.toHexString(newIdent) + " while dispatching to "
+ msg.target.getClass().getName() + " "
+ msg.callback + " what=" + msg.what);
}

msg.recycleUnchecked();
}
}

首先得到looper里的消息队列，然后循环从消息队列里取message，最后调用message里target的dispatchMessage方法，target就是发送消息的Handler对象

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

主要看handleMessage方法这行代码，handleMessage需要我们自己去实现，下面这行代码什么时候会调用呢？

if (msg.callback != null) {
handleCallback(msg);
}

这段代码是什么意思呢？这里涉及到发送消息的另外一种方式，我们有时候为了简单会这样调用

handler.post(new Runnable() {
@Override
public void run() {

}
})

//调用的post方法
public final boolean post(Runnable r)
{
return  sendMessageDelayed(getPostMessage(r), 0);
}

private static Message getPostMessage(Runnable r) {
Message m = Message.obtain();
m.callback = r;
return m;
}

从getPostMessage方法中可以看到，首先从消息池中得到消息对象，然后把我们创建的Runnable对象赋值给消息的callback属性，我们回过头看看上面的判断代码，判断callback是否为空，不为空调用handleCallback方法

private static void handleCallback(Message message) {
message.callback.run();
}

方法里面就是回调callback的run方法，run方法就是我们自己的业务逻辑代码

总结

到此三者之间的关系已经分析完毕，主线程在创建时创建Looper对象，在Looper构造方法中创建消息队列MessageQueue，调用Looper的loop方法启动消息循环；然后Handler在创建时从sThreadLocal中取主线程Looper对象中MessageQueue，发送消息插入到消息队列，loop循环取出消息，调用Handler的handleMessage方法或callback回调方法完成消息处理，所以Handler对象必须关联一个Looper对象，在子线程中使用Handler必须要调用Looper的prepare和loop方法，因为它需要Looper的消息队列和消息循环处理，而主线程在创建时已经创建了Looper对象，并启动了Looper循环，所以在主线程中使用Handler不需要调用这2个方法。