概述
在Android的UI開發(fā)中哄辣，我們經(jīng)常會使用Handler來控制主UI程序的界面變化请梢，以及線程間進行通信赠尾。在面試中經(jīng)常會問到相關(guān)的問題，它們到底是如何工作的呢毅弧？讓我們來一探究竟气嫁。
Handler通信機制的角色
Message：消息內(nèi)容，可以比喻成貨品
MessageQueue：消息隊列够坐，可以比喻成貨品倉庫
Looper：消息分發(fā)者寸宵，可以比喻成貨品管理人
Handler：消息消費者，可以比喻成接收貨品的人
源碼分析
首先要理解的概念是元咙，一個線程對應(yīng)一個唯一的Looper和MessagQueue邓馒，可以有多個Handler。
現(xiàn)在來分析它們是如何工作的：
1. Looper
整個消息機制要使用前發(fā)須執(zhí)行Looper的prepare()和loop()兩個函數(shù)蛾坯，Activity中我們可以直接使用Handler是因為系統(tǒng)已經(jīng)幫我們執(zhí)行了光酣，但在線程中需要我們手動執(zhí)行這兩個函數(shù)。下面我們來看看這兩個函數(shù)的具體內(nèi)容：
private static void prepare(boolean quitAllowed) {
// sThreadLocal指向的是調(diào)用Looper的線程脉课，這里進行了一個判斷救军，如果通過get()方法獲取到的Looper對象不對空，則報錯倘零，即一個線程只能對應(yīng)一個Looper
if (sThreadLocal.get() != null) {
throw new RuntimeException("Only one Looper may be created per thread");
}
// 這里是new一個Looper set到sThreadLoca里唱遭，進行了一個線程和Looper的綁定
sThreadLocal.set(new Looper(quitAllowed));
}
由以上代碼可以看出，其實prepare()是一個創(chuàng)建Looper呈驶，進行線程和Looper綁定的過程拷泽，只能執(zhí)行一次，不能重復(fù)創(chuàng)建綁定袖瞻。
再來看看loop()函數(shù)
public static void loop() {
// myLooper()是從sThreadLocal里獲取剛才在prepare()里綁定的Looper對象
final Looper me = myLooper();
if (me == null) {
throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
}
// 從Looper中獲取消息隊列司致，每一個Looper對應(yīng)一個MessagQueue對象
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();
// 這里通過一個循環(huán)不斷去取MessagQueue里的消息進行處理
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
final Printer logging = me.mLogging;
if (logging != null) {
logging.println(">>>>> Dispatching to " + msg.target + " " +
msg.callback + ": " + msg.what);
}
final long traceTag = me.mTraceTag;
if (traceTag != 0) {
Trace.traceBegin(traceTag, msg.target.getTraceName(msg));
}
// 獲取到消息后調(diào)用消息里target對象進行分發(fā)message，這個target對象就是Handler聋迎，是在handler發(fā)消息時進行了設(shè)置脂矫，把handler放到message里的target中，后面會在代碼中提到霉晕。
try {
msg.target.dispatchMessage(msg);
} finally {
if (traceTag != 0) {
Trace.traceEnd(traceTag);
}
}
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);
}
// 這里對message對象進行回收庭再，因為message是使用了享元模式，避免生成過多的Message對象牺堰，所以這里進行回收放到對象池里重復(fù)利用拄轻。
msg.recycleUnchecked();
}
}
2. Handler
handler相信大家都有用過，直接看看構(gòu)造函數(shù)
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());
}
}
// handler把當前線程綁定的looper對象賦值給mLooper了伟葫，所以默認是在當前線程進行消息分發(fā)處理的
// 當然Looper里有一個getMainLooper()方法恨搓，可以獲取到Application的Looper對象，即UI線程的Looper對象扒俯。
mLooper = Looper.myLooper();
// 這里進行了為空的判斷奶卓，說明創(chuàng)建Handler使用時必須先創(chuàng)建Looper一疯，調(diào)用prepare()函數(shù)
// 所以我們在線程中要使用Handler通信時，要先調(diào)用Looper.prepare()才能創(chuàng)建Handler夺姑。創(chuàng)建完Handler再調(diào)用Looper.loop()進行消息分發(fā)處理墩邀。
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;
}
再來看一個指定Looper的構(gòu)造函數(shù)，上面的構(gòu)造函數(shù)是用當前線程綁定的Looper進行消息分發(fā)的盏浙，這個構(gòu)造函數(shù)可以指定Looper
public Handler(Looper looper, Callback callback, boolean async) {
mLooper = looper;
mQueue = looper.mQueue;
mCallback = callback;
mAsynchronous = async;
}
現(xiàn)在來看下發(fā)消息的處理眉睹，所有的發(fā)消息函數(shù)都會調(diào)用下面sendMessageAtTime函數(shù)，這里會調(diào)用的enqueueMessage函數(shù)中废膘，對
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) {
// 剛才說的target就是在這里賦值的竹海，把當有Handler對象放到target里，那Looper中就是調(diào)用msg.target.dispatchMessage(msg)時行分發(fā)的丐黄。
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
}
Looper中調(diào)用msg.target.dispatchMessage(msg)時行分發(fā)斋配，我們來看下dispatchMessage函數(shù)的源碼。
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
函數(shù)中就調(diào)用了handleMessage方法灌闺，就是我們創(chuàng)建Handler時傳入的消息處理回調(diào)艰争。
總結(jié)
最后再簡單說一下整個流程：
- 創(chuàng)建Looper，建立線程和Looper桂对、MessageQueue的一一對應(yīng)關(guān)系
- handler調(diào)用sendMessage(msg)實際是把msg加入到消息隊列中
- Looper一直在不斷在循環(huán)取消息甩卓，有消息就調(diào)用消息的msg.target.dispatchMessage()方法，而dispatchMessage方法就會觸發(fā)handler里的handleMessage回調(diào)蕉斜，以此完成消息的傳遞逾柿。
