提起Android消息機制，想必都不陌生。其中包含三個部分：Handler，MessageQueue以及Looper，三者共同協作，完成消息機制的運行。本篇文章將由淺入深解析Android消息機制的運行原理，先介紹三者之間的協作框架，然后從源碼的角度來分析具體的運行機制。
一、消息機制概述
1.消息機制的簡介
在Android中使用消息機制，我們首先想到的就是Handler。沒錯，Handler是Android消息機制的上層接口。Handler的使用過程很簡單，通過它可以輕松地將一個任務切換到Handler所在的線程中去執行。通常情況下，Handler的使用場景就是更新UI。
如下就是使用消息機制的一個簡單實例：
public class Activity extends android.app.Activity {
private Handler mHandler = new Handler(){
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
System.out.println(msg.what);
}
};
@Override
public void onCreate(Bundle savedInstanceState, PersistableBundle persistentState) {
super.onCreate(savedInstanceState, persistentState);
setContentView(R.layout.activity_main);
new Thread(new Runnable() {
@Override
public void run() {
...............耗時操作
Message message = Message.obtain();
message.what = 1;
mHandler.sendMessage(message);
}
}).start();
}
}
在子線程中，進行耗時操作，執行完操作后，發送消息，通知主線程更新UI。這便是消息機制的典型應用場景。我們通常只會接觸到Handler和Message來完成消息機制，其實內部還有兩大助手來共同完成消息傳遞。
2.消息機制的模型
消息機制主要包含：MessageQueue，Handler和Looper這三大部分，以及Message，下面我們一一介紹。
Message：需要傳遞的消息，可以傳遞數據；
MessageQueue：消息隊列，但是它的內部實現并不是用的隊列，實際上是通過一個單鏈表的數據結構來維護消息列表，因為單鏈表在插入和刪除上比較有優勢。主要功能向消息池投遞消息(MessageQueue.enqueueMessage)和取走消息池的消息(MessageQueue.next)；
Handler：消息輔助類，主要功能向消息池發送各種消息事件(Handler.sendMessage)和處理相應消息事件(Handler.handleMessage)；
Looper：不斷循環執行(Looper.loop)，從MessageQueue中讀取消息，按分發機制將消息分發給目標處理者。
3.消息機制的架構
消息機制的運行流程：在子線程執行完耗時操作，當Handler發送消息時，將會調用MessageQueue.enqueueMessage，向消息隊列中添加消息。當通過Looper.loop開啟循環后，會不斷地從線程池中讀取消息，即調用MessageQueue.next，然后調用目標Handler（即發送該消息的Handler）的dispatchMessage方法傳遞消息，然后返回到Handler所在線程，目標Handler收到消息，調用handleMessage方法，接收消息，處理消息。
MessageQueue，Handler和Looper三者之間的關系：每個線程中只能存在一個Looper，Looper是保存在ThreadLocal中的。主線程（UI線程）已經創建了一個Looper，所以在主線程中不需要再創建Looper，但是在其他線程中需要創建Looper。每個線程中可以有多個Handler，即一個Looper可以處理來自多個Handler的消息。 Looper中維護一個MessageQueue，來維護消息隊列，消息隊列中的Message可以來自不同的Handler。
下面是消息機制的整體架構圖，接下來我們將慢慢解剖整個架構。
從中我們可以看出：
Looper有一個MessageQueue消息隊列；
MessageQueue有一組待處理的Message；
Message中記錄發送和處理消息的Handler；
Handler中有Looper和MessageQueue。
二、消息機制的源碼解析
1.Looper
要想使用消息機制，首先要創建一個Looper。
初始化Looper
無參情況下，默認調用prepare(true);表示的是這個Looper可以退出，而對于false的情況則表示當前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));
}
這里看出，不能重復創建Looper，只能創建一個。創建Looper,并保存在ThreadLocal。其中ThreadLocal是線程本地存儲區（Thread Local Storage，簡稱為TLS），每個線程都有自己的私有的本地存儲區域，不同線程之間彼此不能訪問對方的TLS區域。
開啟Looper
public static void loop() {
final Looper me = myLooper(); //獲取TLS存儲的Looper對象
if (me == null) {
throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
}
final MessageQueue queue = me.mQueue; //獲取Looper對象中的消息隊列
Binder.clearCallingIdentity();
final long ident = Binder.clearCallingIdentity();
for (;;) { //進入loop的主循環方法
Message msg = queue.next(); //可能會阻塞,因為next()方法可能會無限循環
if (msg == null) { //消息為空，則退出循環
return;
}
Printer logging = me.mLogging; //默認為null，可通過setMessageLogging()方法來指定輸出，用于debug功能
if (logging != null) {
logging.println(">>>>> Dispatching to " + msg.target + " " +
msg.callback + ": " + msg.what);
}
msg.target.dispatchMessage(msg); //獲取msg的目標Handler，然后用于分發Message
if (logging != null) {
logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
}
final long newIdent = Binder.clearCallingIdentity();
if (ident != newIdent) {
}
msg.recycleUnchecked();
}
}
loop()進入循環模式，不斷重復下面的操作，直到消息為空時退出循環:
讀取MessageQueue的下一條Message（關于next()，后面詳細介紹）；
把Message分發給相應的target。
當next()取出下一條消息時，隊列中已經沒有消息時，next()會無限循環，產生阻塞。等待MessageQueue中加入消息，然后重新喚醒。
主線程中不需要自己創建Looper，這是由于在程序啟動的時候，系統已經幫我們自動調用了Looper.prepare()方法。查看ActivityThread中的main()方法，代碼如下所示：
public static void main(String[] args) {
..........................
Looper.prepareMainLooper();
..........................
Looper.loop();
..........................
}
其中``prepareMainLooper()方法會調用prepare(false)`方法。
2.Handler
創建Handler
public Handler() {
this(null, false);
}
public Handler(Callback callback, boolean async) {
.................................
//必須先執行Looper.prepare()，才能獲取Looper對象，否則為null.
mLooper = Looper.myLooper(); //從當前線程的TLS中獲取Looper對象
if (mLooper == null) {
throw new RuntimeException("");
}
mQueue = mLooper.mQueue; //消息隊列，來自Looper對象
mCallback = callback; //回調方法
mAsynchronous = async; //設置消息是否為異步處理方式
}
對于Handler的無參構造方法，默認采用當前線程TLS中的Looper對象，并且callback回調方法為null，且消息為同步處理方式。只要執行的Looper.prepare()方法，那么便可以獲取有效的Looper對象。
3.發送消息
發送消息有幾種方式，但是歸根結底都是調用了sendMessageAtTime()方法。
在子線程中通過Handler的post()方式或send()方式發送消息，最終都是調用了sendMessageAtTime()方法。
post方法
public final boolean post(Runnable r)
{
return sendMessageDelayed(getPostMessage(r), 0);
}
public final boolean postAtTime(Runnable r, long uptimeMillis)
{
return sendMessageAtTime(getPostMessage(r), uptimeMillis);
}
public final boolean postAtTime(Runnable r, Object token, long uptimeMillis)
{
return sendMessageAtTime(getPostMessage(r, token), uptimeMillis);
}
public final boolean postDelayed(Runnable r, long delayMillis)
{
return sendMessageDelayed(getPostMessage(r), delayMillis);
}
send方法
public final boolean sendMessage(Message msg)
{
return sendMessageDelayed(msg, 0);
}
public final boolean sendEmptyMessage(int what)
{
return sendEmptyMessageDelayed(what, 0);
}
public final boolean sendEmptyMessageDelayed(int what, long delayMillis) {
Message msg = Message.obtain();
msg.what = what;
return sendMessageDelayed(msg, delayMillis);
}
public final boolean sendEmptyMessageAtTime(int what, long uptimeMillis) {
Message msg = Message.obtain();
msg.what = what;
return sendMessageAtTime(msg, uptimeMillis);
}
public final boolean sendMessageDelayed(Message msg, long delayMillis)
{
if (delayMillis < 0) {
delayMillis = 0;
}
return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
}
就連子線程中調用Activity中的runOnUiThread()中更新UI，其實也是發送消息通知主線程更新UI，最終也會調用sendMessageAtTime()方法。
public final void runOnUiThread(Runnable action) {
if (Thread.currentThread() != mUiThread) {
mHandler.post(action);
} else {
action.run();
}
}
如果當前的線程不等于UI線程(主線程)，就去調用Handler的post()方法，最終會調用sendMessageAtTime()方法。否則就直接調用Runnable對象的run()方法。
下面我們就來一探究竟，到底sendMessageAtTime()方法有什么作用？
sendMessageAtTime()
public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
//其中mQueue是消息隊列，從Looper中獲取的
MessageQueue queue = mQueue;
if (queue == null) {
RuntimeException e = new RuntimeException(
this + " sendMessageAtTime() called with no mQueue");
Log.w("Looper", e.getMessage(), e);
return false;
}
//調用enqueueMessage方法
return enqueueMessage(queue, msg, uptimeMillis);
}
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
//調用MessageQueue的enqueueMessage方法
return queue.enqueueMessage(msg, uptimeMillis);
}
可以看到sendMessageAtTime()`方法的作用很簡單，就是調用MessageQueue的enqueueMessage()方法，往消息隊列中添加一個消息。
下面來看enqueueMessage()方法的具體執行邏輯。
enqueueMessage()
boolean enqueueMessage(Message msg, long when) {
// 每一個Message必須有一個target
if (msg.target == null) {
throw new IllegalArgumentException("Message must have a target.");
}
if (msg.isInUse()) {
throw new IllegalStateException(msg + " This message is already in use.");
}
synchronized (this) {
if (mQuitting) { //正在退出時，回收msg，加入到消息池
msg.recycle();
return false;
}
msg.markInUse();
msg.when = when;
Message p = mMessages;
boolean needWake;
if (p == null || when == 0 || when < p.when) {
//p為null(代表MessageQueue沒有消息） 或者msg的觸發時間是隊列中最早的， 則進入該該分支
msg.next = p;
mMessages = msg;
needWake = mBlocked;
} else {
//將消息按時間順序插入到MessageQueue。一般地，不需要喚醒事件隊列，除非
//消息隊頭存在barrier，并且同時Message是隊列中最早的異步消息。
needWake = mBlocked && p.target == null && msg.isAsynchronous();
Message prev;
for (;;) {
prev = p;
p = p.next;
if (p == null || when < p.when) {
break;
}
if (needWake && p.isAsynchronous()) {
needWake = false;
}
}
msg.next = p;
prev.next = msg;
}
if (needWake) {
nativeWake(mPtr);
}
}
return true;
}
MessageQueue是按照Message觸發時間的先后順序排列的，隊頭的消息是將要最早觸發的消息。當有消息需要加入消息隊列時，會從隊列頭開始遍歷，直到找到消息應該插入的合適位置，以保證所有消息的時間順序。
4.獲取消息
當發送了消息后，在MessageQueue維護了消息隊列，然后在Looper中通過loop()方法，不斷地獲取消息。上面對loop()方法進行了介紹，其中最重要的是調用了queue.next()方法,通過該方法來提取下一條信息。下面我們來看一下next()方法的具體流程。
next()
Message next() {
final long ptr = mPtr;
if (ptr == 0) { //當消息循環已經退出，則直接返回
return null;
}
int pendingIdleHandlerCount = -1; // 循環迭代的首次為-1
int nextPollTimeoutMillis = 0;
for (;;) {
if (nextPollTimeoutMillis != 0) {
Binder.flushPendingCommands();
}
//阻塞操作，當等待nextPollTimeoutMillis時長，或者消息隊列被喚醒，都會返回
nativePollOnce(ptr, nextPollTimeoutMillis);
synchronized (this) {
final long now = SystemClock.uptimeMillis();
Message prevMsg = null;
Message msg = mMessages;
if (msg != null && msg.target == null) {
//當消息Handler為空時，查詢MessageQueue中的下一條異步消息msg，為空則退出循環。
do {
prevMsg = msg;
msg = msg.next;
} while (msg != null && !msg.isAsynchronous());
}
if (msg != null) {
if (now < msg.when) {
//當異步消息觸發時間大于當前時間，則設置下一次輪詢的超時時長
nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
} else {
// 獲取一條消息，并返回
mBlocked = false;
if (prevMsg != null) {
prevMsg.next = msg.next;
} else {
mMessages = msg.next;
}
msg.next = null;
//設置消息的使用狀態，即flags |= FLAG_IN_USE
msg.markInUse();
return msg; //成功地獲取MessageQueue中的下一條即將要執行的消息
}
} else {
//沒有消息
nextPollTimeoutMillis = -1;
}
//消息正在退出，返回null
if (mQuitting) {
dispose();
return null;
}
...............................
}
}
nativePollOnce是阻塞操作，其中nextPollTimeoutMillis代表下一個消息到來前，還需要等待的時長；當nextPollTimeoutMillis = -1時，表示消息隊列中無消息，會一直等待下去。
可以看出next()方法根據消息的觸發時間，獲取下一條需要執行的消息,隊列中消息為空時，則會進行阻塞操作。
5.分發消息
在loop()方法中，獲取到下一條消息后，執行msg.target.dispatchMessage(msg)，來分發消息到目標Handler對象。
下面就來具體看下dispatchMessage(msg)方法的執行流程。
dispatchMessage()
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
//當Message存在回調方法，回調msg.callback.run()方法；
handleCallback(msg);
} else {
if (mCallback != null) {
//當Handler存在Callback成員變量時，回調方法handleMessage()；
if (mCallback.handleMessage(msg)) {
return;
}
}
//Handler自身的回調方法handleMessage()
handleMessage(msg);
}
}
private static void handleCallback(Message message) {
message.callback.run();
}
分發消息流程：
當Message的msg.callback不為空時，則回調方法msg.callback.run();
當Handler的mCallback不為空時，則回調方法mCallback.handleMessage(msg)；
最后調用Handler自身的回調方法handleMessage()，該方法默認為空，Handler子類通過覆寫該方法來完成具體的邏輯。
消息分發的優先級：
Message的回調方法：message.callback.run()，優先級最高；
Handler中Callback的回調方法：Handler.mCallback.handleMessage(msg)，優先級僅次于1；
Handler的默認方法：Handler.handleMessage(msg)，優先級最低。
對于很多情況下，消息分發后的處理方法是第3種情況，即Handler.handleMessage()，一般地往往通過覆寫該方法從而實現自己的業務邏輯。
三、總結
以上便是消息機制的原理，以及從源碼角度來解析消息機制的運行過程。可以簡單地用下圖來理解。
