深入理解Message, MessageQueue, Handler和Looper
做過Android的都知道Message, MessageQueue, Handler和Looper，但知道不代表你理解它們。有時覺得用得很順手，但Android怎麼實現又說不上來，總覺得似懂非懂。不把它們攻破實在渾身不舒服。
先讓我們一句話總結，再開始分析。
Looper不斷獲取MessageQueue中的一個Message，然後交給Hanlder處理。
其實Message和Runnable可以一併壓入MessageQueue中，形成一個集合，後面將有所體現。
本文所涉及的程式碼檔案以及路徑：
frameworks/base/core/java/android/os/Hanlder.java
frameworks/base/core/java/android/os/Message.java
frameworks/base/core/java/android/os/MessageQueue.java
frameworks/base/core/java/android/os/Looper.java
frameworks/base/core/java/android/app/ActivityThread.java
frameworks/base/core/jni/android_os_MessageQueue.cpp
1、Message
android.os.Message定義了訊息必要的描述和屬性資料。
public final class Message implements Parcelable {
public int what;
public int arg1;
public int arg2;
public Object obj;
public Messenger replyTo;
Bundle data;
Handler target;
Runnable callback;
......
}
請注意裡面的target和callback，後面將對此進行關聯。其中arg1和arg2是用來存放整型資料的，what用來儲存訊息標識，obj是Object型別的任意物件，replyTo是訊息管理器，會關聯到一個handler。通常Message物件不是直接new出來，只要呼叫handler中的obtainMessage方法來直接獲得Message物件。這也是Android推薦的做法。
/**
* Return a new Message instance from the global pool. Allows us to
* avoid allocating new objects in many cases.
*/
public static Message obtain() {
synchronized (sPoolSync) {
if (sPool != null) {
Message m = sPool;
sPool = m.next;
m.next = null;
m.flags = 0; // clear in-use flag
sPoolSize--;
return m;
}
}
return new Message();
}
你看，如果池中沒有才會new一個Message。
2、MessageQueue
MessageQueue是一個final class，用來存放訊息的訊息佇列，它具有佇列的常規操作，包括：
- 新建佇列
-
MessageQueue(boolean quitAllowed) { mQuitAllowed = quitAllowed; mPtr = nativeInit(); } -
private native static long nativeInit();
由程式碼可以看出，由建構函式和本地方法nativeInit()組成。其中，nativeInit()會在本地建立一個NativeMessageQueue物件，然後賦給MessageQueue中的成員變數，這一系列通過記憶體指標進行。
-
static jlong android_os_MessageQueue_nativeInit(JNIEnv* env, jclass clazz) { NativeMessageQueue* nativeMessageQueue = new NativeMessageQueue(); if (!nativeMessageQueue) { jniThrowRuntimeException(env, "Unable to allocate native queue"); return 0; } nativeMessageQueue->incStrong(env); return reinterpret_cast<jlong>(nativeMessageQueue); } - 元素入隊
-
boolean enqueueMessage(Message msg, long when)
- 元素出隊
-
Message next()
- 元素刪除
-
void removeMessages(Handler h, Runnable r, Object object)
void removeMessages(Handler h, int what, Object object)
- 銷燬佇列
-
// Disposes of the underlying message queue. // Must only be called on the looper thread or the finalizer. private void dispose() { if (mPtr != 0) { nativeDestroy(mPtr); mPtr = 0; } }銷燬佇列也需要用到本地方法，此處就不展開了。
3、Handler
Handler作為訊息處理者，一是處理Message，二是將某個Message壓入MessageQueue中。Handler類中持有MessageQueue和Looper成員變數（後面再體現它們的作用）：
public class Handler {
final MessageQueue mQueue;
final Looper mLooper;
final Callback mCallback;
final boolean mAsynchronous;
IMessenger mMessenger;
......
}
先讓我們focus Handler如何處理Message
public void dispatchMessage(Message msg)
public void handleMessage(Message msg)
一個對Message進行分發，一個對Message進行處理。
還記得開始的一句話總結麼？Looper從MessageQueue中取出一個Message後，首先會呼叫Handler.dispatchMessage進行訊息分發。這裡雖然還沒涉及Looper的討論，但可以先給出訊息分發的程式碼，具體在Looper類的loop方法中
public static void loop() {
......
for (;;) {
......
msg.target.dispatchMessage(msg);
......
}
}
好，回到Handler的dispatchMessage方法
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
通過程式碼得知，預設情況下Handler的派發流程是：
- 如果Message中的callback不為空，通過callback來處理（開頭我們提到Message中有一個callback）
- 如果Handler的mCallback不為空，通過mCallback來處理
- 如果上面兩個都為空，才呼叫handleMessage來處理
其中mCallback為
public interface Callback {
public boolean handleMessage(Message msg);
}
而一般情況下，我們就是通過直接new Handler的方式重寫handleMessage來處理Message，這個Handler就是訊息處理責任人。
/**
* Subclasses must implement this to receive messages.
*/
public void handleMessage(Message msg) {
}
接著，Handler第二個作用是將某個Message壓入MessageQueue中。大家注意沒有，Message是Handler處理，而Message也是Handler壓入到MessageQueue中，既然這樣，為什麼不直接執行？其實這樣是體現程式設計的有序性，如果事件優先順序較小，就需要排隊，否則馬上處理。
將Message壓入到MessageQueue中，能呼叫的主要的方法有：
public final boolean post(Runnable r)
public final boolean postDelayed(Runnable r, long delayMillis)
public final boolean sendMessage(Message msg)
public final boolean sendEmptyMessage(int what)
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);
}
post系列的方法會呼叫相應的sendEmptyMessage、sendEmptyMessageDelayed等方法，最終進入sendMessageAtTime中，然後呼叫enqueueMessage，把Message壓入佇列中。
由於post方法的引數是Runnable物件，所以Hander內部提供了getPostMessage方法把Runnable物件轉化為Message
private static Message getPostMessage(Runnable r) {
Message m = Message.obtain();
m.callback = r;
return m;
}
最終，Handler形成了一個迴圈：Handler->MessageQueue->Message->Handler
4、Looper
Looper也是一個final class，並且持有一個MessageQueue，MessageQueue作為執行緒的訊息儲存倉庫，配合Handler, Looper一起完成一系列操作。值得注意的是，還有一個final Thread和一個final ThreadLocal<Looper>的成員變數，其中ThreadLocal負責建立一個只針對當前執行緒的Looper及其它相關資料物件，其它執行緒無法訪問。
Looper類中的註釋還給了一個使用Looper的普通執行緒範例：
/*class LooperThread extends Thread {
* public Handler mHandler;
*
* public void run() {
* Looper.prepare();
*
* mHandler = new Handler() {
* public void handleMessage(Message msg) {
* // process incoming messages here
* }
* };
*
* Looper.loop();
* }
* }
*/
其實就是三個步驟：
- Looper.prepare()準備工作
- 建立訊息處理的handler
- 呼叫Looper.loop()進入訊息迴圈
看起來簡單吧？可是你能看出mHandler是怎樣把訊息投遞到Looper所管理的MessageQueue中的麼？Looper在什麼時候建立呢？
先看一下Looper.prepare()到底做了什麼事情
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();
}
首先通過sThreadLocal.get()判斷保證一個Thread只能有一個Looper例項，最後new Looper完成Looper的例項化。同時MessageQueue就在Looper的建構函式中創建出來。
再來看handler的建立。還記得前面提到的Handler類中的成員變數麼？Handler中就持有一個Looper，這樣一來，Handler就和Looper關聯起來了。Handler一共有7個建構函式，看其中一個：
public Handler(Callback callback, boolean async) {
......
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;
}
Looper中的myLooper()
public static @Nullable Looper myLooper() {
return sThreadLocal.get();
}
這樣一來，Handler中的建構函式通過Looper.myLooper()獲取當前執行緒中的Looper例項，實際上就是Looper中的sThreadLocal.get()呼叫；然後把mLooper.mQueue賦給Handler的mQueue，最終Handler, Looper和MessageQueue就聯絡起來了。後續Handler執行post/send系列的方法時，會將訊息投遞給mQueue，也就是mLooper.mQueue中。一旦Looper處理到訊息，它又從中呼叫Handler來進行處理。
最後看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;
// 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();
}
}
由前面得知，myLooper()就是呼叫sThreadLocal.get()來獲取與之匹配的Looper例項。me.mQueue驗證了每一個Looper中都自帶了一個MessageQueue。進入for迴圈後，開始從MessageQueue中取出一個訊息（可能會阻塞），如果當前訊息佇列中沒有Message，執行緒退出；否則分發訊息。msg.target.dispatchMessage(msg)中的target就是一個Handler。最後訊息處理完畢，進行回收。
平時我們在Activity中使用Handler處理Message時，為什麼看不到Looper呢？這隻能說Android偷偷為我們做了一些背後的工作。好了，UI執行緒要上場了。
5、ActivityThread
沒錯，ActivityThread就是我們熟悉的UI執行緒，它在應用程式啟動的時候由系統創建出來。先來看一下這個UI執行緒的main函式
public static void main(String[] args) {
......
Looper.prepareMainLooper();
ActivityThread thread = new ActivityThread();
thread.attach(false);
if (sMainThreadHandler == null) {
sMainThreadHandler = thread.getHandler();
}
......
Looper.loop();
throw new RuntimeException("Main thread loop unexpectedly exited");
}
有兩點與普通執行緒不一樣的地方。
普通執行緒只要prepare就可以了，而主執行緒使用的是prepareMainLooper；普通執行緒生成一個與Looper繫結的Handler物件就行，而主執行緒是從當前執行緒中獲取Handler（thread.getHandler()）。
public static void prepareMainLooper() {
prepare(false);
synchronized (Looper.class) {
if (sMainLooper != null) {
throw new IllegalStateException("The main Looper has already been prepared.");
}
sMainLooper = myLooper();
}
}
其實prepareMainLooper也是呼叫prepare，只是不讓該執行緒退出。經過prepare後，myLooper()就得到一個本地執行緒<ThreadLocal>的Looper物件，然後賦給sMainLooper，也就是UI執行緒的Looper。如果其它執行緒想獲得主執行緒的Looper，只需呼叫getMainLooper()。
public static Looper getMainLooper() {
synchronized (Looper.class) {
return sMainLooper;
}
}
再來看thread.getHandler()。
其實ActivityThead內部有一個繼承Handler的H類
private class H extends Handler {
......
public void handleMessage(Message msg) {
......
}
......
}
final H mH = new H();
所以thread.getHandler()返回的就是mH，這樣ActivityThread也有一個Handler處理各種訊息了。
總結一下。
- 每個Thread只對應一個Looper
- 每個Looper只對應一個MessageQueue
- 每個MessageQueue有N個Message
- 每個Message最多指定一個Handler來處理
而Thread和Handler是一對多的關係。
到這裡，是不是對Message, MessageQueue, Handler和Looper有了更深的認識呢？
參考：
《深入理解Android核心設計思想》 林學森 編著