Handler訊息機制包含：Handler、Message、MessageQueue、Looper；
Handler
Handler顧名思義也就是處理者的意思，它主要用於傳送和處理訊息的。傳送訊息一般會使用Handler的sendMessage()方法，而發出的訊息經過一些列地輾轉處理後，最終會傳遞到Handler的handleMessage()方法中。
Message
Message是線上程之間傳遞的訊息，它可以在內部攜帶少量的資訊，用於在不同執行緒之間交換資料。
MessageQueue
MessageQueue是訊息佇列的意思，它主要用於存放所有通過Handler傳送的訊息。這部分訊息會一直存在於訊息佇列中，等待被處理。每個執行緒中只會有一個MessageQueue物件。（MessageQueue是在Looper的建構函式中建立的，因此一個MessageQueue對應一個Looper）。
Looper
Looper是每個執行緒中MessageQueue的管家，呼叫Looper的loop()方法後，就會進入到一個無限迴圈當中，然後每當發現MessageQueue中存在一條訊息，就會將它取出，並傳遞到Handler的handleMessage()方法中。每個執行緒中也會只有一個Looper物件。
使用Handler所需要注意的事項：在子執行緒中直接呼叫new Handler()的時候，會導致程式崩潰，需要先呼叫Looper.prepare()；why? 看程式碼：
public Handler() {
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());
}
}
// 在此獲取一個Looper物件，如果為空就會丟擲異常
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 = null;
public static final Looper myLooper() {
return (Looper)sThreadLocal.get();
}
public static final void prepare() {
if (sThreadLocal.get() != null) {
throw new RuntimeException("Only one Looper may be created per thread");
}
sThreadLocal.set(new Looper());
} 複製程式碼可以看到，首先判斷sThreadLocal中是否已經存在Looper了，如果還沒有則建立一個新的Looper設定進去。這樣也就完全解釋了為什麼我們要先呼叫Looper.prepare()方法，才能建立Handler物件。同時也可以看出每個執行緒中最多隻會有一個Looper物件。在主執行緒中，系統自動幫我們呼叫了Looper.prepare()方法。
深入解析Handler機制
我們對非同步訊息處理的整個流程梳理一遍：
首先需要在主執行緒當中建立一個Handler物件，並重寫handleMessage()方法。然後當子執行緒中需要進行UI操作時，就建立一個Message物件，並通過Handler將這條訊息傳送出去。之後這條訊息會被新增到MessageQueue的佇列中等待被處理，而Looper則會一直嘗試從MessageQueue中取出待處理訊息，最後分發回Handler的handleMessage()方法中
Message message = new Message();
message.arg1 = 1;
Bundle bundle = new Bundle();
bundle.putString("data", "data");
message.setData(bundle);
handler.sendMessage(message);複製程式碼以上程式碼相信都很熟悉，就是傳送Message的程式碼，可是這裡Handler到底是把Message傳送到哪裡去了呢？為什麼之後又可以在Handler的handleMessage()方法中重新得到這條Message呢？看來又需要通過閱讀原始碼才能解除我們心中的疑惑了，Handler中提供了很多個傳送訊息的方法，其中除了sendMessageAtFrontOfQueue()方法之外，其它的傳送訊息方法最終都會輾轉呼叫到sendMessageAtTime()方法中，這個方法的原始碼如下所示：
public boolean sendMessageAtTime(Message msg, long uptimeMillis)
{
boolean sent = false;
MessageQueue queue = mQueue;
if (queue != null) {
msg.target = this;
sent = queue.enqueueMessage(msg, uptimeMillis);
}
else {
RuntimeException e = new RuntimeException(
this + " sendMessageAtTime() called with no mQueue");
Log.w("Looper", e.getMessage(), e);
}
return sent;
}複製程式碼sendMessageAtTime()方法接收兩個引數，其中msg引數就是我們傳送的Message物件，而uptimeMillis引數則表示傳送訊息的時間，它的值等於自系統開機到當前時間的毫秒數再加上延遲時間，如果你呼叫的不是sendMessageDelayed()方法，延遲時間就為0，然後將這兩個引數都傳遞到MessageQueue的enqueueMessage()方法中。
這個MessageQueue又是什麼東西呢？其實從名字上就可以看出了，它是一個訊息佇列，用於將所有收到的訊息以佇列的形式進行排列，並提供入隊和出隊的方法。這個類是在Looper的建構函式中建立的，因此一個Looper也就對應了一個MessageQueue。 那麼enqueueMessage()方法毫無疑問就是入隊的方法了，我們來看下這個方法的原始碼：
final boolean enqueueMessage(Message msg, long when) {
if (msg.when != 0) {
throw new AndroidRuntimeException(msg + " This message is already in use.");
}
if (msg.target == null && !mQuitAllowed) {
throw new RuntimeException("Main thread not allowed to quit");
}
synchronized (this) {
if (mQuiting) {
RuntimeException e = new RuntimeException(msg.target + " sending message to a Handler on a dead thread");
Log.w("MessageQueue", e.getMessage(), e);
return false;
} else if (msg.target == null) {
mQuiting = true;
}
msg.when = when;
Message p = mMessages;
if (p == null || when == 0 || when < p.when) {
msg.next = p;
mMessages = msg;
this.notify();
} else {
Message prev = null;
while (p != null && p.when <= when) {
prev = p;
p = p.next;
}
msg.next = prev.next;
prev.next = msg;
this.notify();
}
}
return true;
} 複製程式碼首先你要知道，MessageQueue並沒有使用一個集合把所有的訊息都儲存起來，它只使用了一個mMessages物件表示當前待處理的訊息。所謂的入隊其實就是將所有的訊息按時間來進行排序，這個時間當然就是我們剛才介紹的uptimeMillis引數。具體的操作方法就根據時間的順序呼叫msg.next，從而為每一個訊息指定它的下一個訊息是什麼。當然如果你是通過sendMessageAtFrontOfQueue()方法來傳送訊息的，它也會呼叫enqueueMessage()來讓訊息入隊，只不過時間為0，這時會把mMessages賦值為新入隊的這條訊息，然後將這條訊息的next指定為剛才的mMessages，這樣也就完成了新增訊息到佇列頭部的操作。 現在入隊操作我們就已經看明白了，那出隊操作是在哪裡進行的呢?這個就需要看一看Looper.loop()方法的原始碼了，如下所示：
public static final void loop() {
Looper me = myLooper();
MessageQueue queue = me.mQueue;
while (true) {
Message msg = queue.next(); // might block 訊息佇列的出隊方法
if (msg != null) {
if (msg.target == null) {
return;
}
if (me.mLogging!= null) me.mLogging.println(
">>>>> Dispatching to " + msg.target + " "
+ msg.callback + ": " + msg.what
);
msg.target.dispatchMessage(msg);
if (me.mLogging!= null) me.mLogging.println(
"<<<<< Finished to " + msg.target + " "
+ msg.callback);
msg.recycle();
}
}
} 複製程式碼這個方法從第4行開始，進入了一個死迴圈，然後不斷地呼叫的MessageQueue的next()方法，我想你已經猜到了，這個next()方法就是訊息佇列的出隊方法。不過由於這個方法的程式碼稍微有點長，我就不貼出來了，它的簡單邏輯就是如果當前MessageQueue中存在mMessages(即待處理訊息)，就將這個訊息出隊，然後讓下一條訊息成為mMessages，否則就進入一個阻塞狀態，一直等到有新的訊息入隊。繼續看loop()方法的第14行，每當有一個訊息出隊，就將它傳遞到msg.target的dispatchMessage()方法中，那這裡msg.target又是什麼呢？其實就是Handler啦，你觀察一下上面sendMessageAtTime()方法的第6行就可以看出來了。接下來當然就要看一看Handler中dispatchMessage()方法的原始碼了，如下所示：
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
} 複製程式碼如果mCallback不為空，則呼叫mCallback的handleMessage()方法，否則直接呼叫Handler的handleMessage()方法，並將訊息物件作為引數傳遞過去。這樣我相信大家就都明白了為什麼handleMessage()方法中可以獲取到之前傳送的訊息了吧！
其他在子執行緒中進行UI操作的方法
Handler的post()方法
View的post()方法
Activity的runOnUiThread()方法
侵刪·原文連結