一、消息機制流程簡介
在應用啟動的時候，會執行程序的入口函數main()，main()里面會創建一個Looper對象，然后通過這個Looper對象開啟一個死循環，這個循環的工作是，不斷的從消息隊列MessageQueue里面取出消息即Message對象，并處理。然后看下面兩個問題：
循環拿到一個消息之后，如何處理？
是通過在Looper的循環里調用Handler的dispatchMessage()方法去處理的，而dispatchMessage()方法里面會調用handleMessage()方法，handleMessage()就是平時使用Handler時重寫的方法，所以最終如何處理消息由使用Handler的開發者決定。
MessageQueue里的消息從哪來？
使用Handler的開發者通過調用sendMessage()方法將消息加入到MessageQueue里面。
上面就是Android中消息機制的一個整體流程，也是 “Android中Handler，Looper，MessageQueue，Message有什么關系？” 的答案。通過上面的流程可以發現Handler在消息機制中的地位，是作為輔助類或者工具類存在的，用來供開發者使用。
對于這個流程有兩個疑問：
- Looper中是如何能調用到Handler的方法的？
- Handler是如何能往MessageQueue中插入消息的？
這兩個問題會在后面給出答案，下面先來通過源碼，分析一下這個過程的具體細節：
二、消息機制的源碼分析
首先main()方法位于ActivityThread.java類里面，這是一個隱藏類，源碼位置：frameworks/base/core/java/android/app/ActivityThread.java
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");
}
Looper的創建可以通過Looper.prepare()來完成，上面的代碼中prepareMainLooper()是給主線程創建Looper使用的，本質也是調用的prepare()方法。創建Looper以后就可以調用Looper.loop()開啟循環了。main方法很簡單，不多說了，下面看看Looper被創建的時候做了什么，下面是Looper的prepare()方法和變量sThreadLocal：
static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
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));
}
很簡單，new了一個Looper，并把new出來的Looper保存到ThreadLocal里面。ThreadLocal是什么？它是一個用來存儲數據的類，類似HashMap、ArrayList等集合類。它的特點是可以在指定的線程中存儲數據，然后取數據只能取到當前線程的數據，比如下面的代碼：
ThreadLocal<Integer> mThreadLocal = new ThreadLocal<>();
private void testMethod() {
mThreadLocal.set(0);
Log.d(TAG, "main mThreadLocal=" + mThreadLocal.get());
new Thread("Thread1") {
@Override
public void run() {
mThreadLocal.set(1);
Log.d(TAG, "Thread1 mThreadLocal=" + mThreadLocal.get());
}
}.start();
new Thread("Thread2") {
@Override
public void run() {
mThreadLocal.set(2);
Log.d(TAG, "Thread1 mThreadLocal=" + mThreadLocal.get());
}
}.start();
Log.d(TAG, "main mThreadLocal=" + mThreadLocal.get());
}
輸出的log是
main mThreadLocal=0
Thread1 mThreadLocal=1
Thread2 mThreadLocal=2
main mThreadLocal=0
通過上面的例子可以清晰的看到ThreadLocal存取數據的特點，只能取到當前所在線程存的數據，如果所在線程沒存數據，取出來的就是null。其實這個效果可以通過HashMap<Thread, Object>來實現，考慮線程安全的話使用ConcurrentMap<Thread, Object>，不過使用Map會有一些麻煩的事要處理，比如當一個線程結束的時候我們如何刪除這個線程的對象副本呢？如果使用ThreadLocal就不用有這個擔心了，ThreadLocal保證每個線程都保持對其線程局部變量副本的隱式引用，只要線程是活動的并且 ThreadLocal 實例是可訪問的；在線程消失之后，其線程局部實例的所有副本都會被垃圾回收（除非存在對這些副本的其他引用）。更多ThreadLocal的講解參考：Android線程管理之ThreadLocal理解及應用場景
好了回到正題，prepare()創建Looper的時候同時把創建的Looper存儲到了ThreadLocal中，通過對ThreadLocal的介紹，獲取Looper對象就很簡單了，sThreadLocal.get()即可，源碼提供了一個public的靜態方法可以在主線程的任何地方獲取這個主線程的Looper（注意一下方法名myLooper()，多個地方會用到）：
public static @Nullable Looper myLooper() {
return sThreadLocal.get();
}
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;
for (;;) {
Message msg = queue.next(); // might block
if (msg == null) {
// No message indicates that the message queue is quitting.
return;
}
try {
msg.target.dispatchMessage(msg);
} finally {
if (traceTag != 0) {
Trace.traceEnd(traceTag);
}
}
msg.recycleUnchecked();
}
}
上面的代碼，首先獲取主線程的Looper對象，然后取得Looper中的消息隊列final MessageQueue queue = me.mQueue;，然后下面是一個死循環，不斷的從消息隊列里取消息Message msg = queue.next();，可以看到取出的消息是一個Message對象，如果消息隊列里沒有消息，就會阻塞在這行代碼，等到有消息來的時候會被喚醒。取到消息以后，通過msg.target.dispatchMessage(msg);來處理消息，msg.target 是一個Handler對象，所以這個時候就調用到我們重寫的Hander的handleMessage()方法了。
msg.target 是在什么時候被賦值的呢？要找到這個答案很容易，msg.target是被封裝在消息里面的，肯定要從發送消息那里開始找，看看Message是如何封裝的。那么就從Handler的sendMessage(msg)方法開始，過程如下：
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);
}
可以看到最后的enqueueMessage()方法中msg.target = this;，這里就把發送消息的handler封裝到了消息中。同時可以看到，發送消息其實就是往MessageQueue里面插入了一條消息，然后Looper里面的循環就可以處理消息了。Handler里面的消息隊列是怎么來的呢？從上面的代碼可以看到enqueueMessage()里面的queue是從sendMessageAtTime傳來的，也就是mQueue。然后看mQueue是在哪初始化的，看Handler的構造方法如下：
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;
}
mQueue的初始化很簡單，首先取得Handler所在線程的Looper，然后取出Looper中的mQueue。這也是Handler為什么必須在有Looper的線程中才能使用的原因，拿到mQueue就可以很容易的往Looper的消息隊列里插入消息了（配合Looper的循環+阻塞就實現了發送接收消息的效果）。
以上就是主線程中消息機制的原理。
那么，在任何線程下使用handler的如下做法的原因、原理、內部流程等就非常清晰了：
new Thread() {
@Override
public void run() {
Looper.prepare();
Handler handler = new Handler();
Looper.loop();
}
}.start();
- 首先Looper.prepare()創建Looper并初始化Looper持有的消息隊列MessageQueue，創建好后將Looper保存到ThreadLocal中方便Handler直接獲取。
- 然后Looper.loop()開啟循環，從MessageQueue里面取消息并調用handler的 dispatchMessage(msg) 方法處理消息。如果MessageQueue里沒有消息，循環就會阻塞進入休眠狀態，等有消息的時候被喚醒處理消息。
- 再然后我們new Handler()的時候，Handler構造方法中獲取Looper并且拿到Looper的MessageQueue對象。然后Handler內部就可以直接往MessageQueue里面插入消息了，插入消息即發送消息，這時候有消息了就會喚醒Looper循環去處理消息。處理消息就是調用dispatchMessage(msg) 方法，最終調用到我們重寫的Handler的handleMessage()方法。
三、通過一些問題的研究加強對消息機制的理解
源碼分析完了，下面看一下文章開頭的兩個問題：
- Looper中是如何能調用到Handler的方法的？
- Handler是如何能往MessageQueue中插入消息的？
這兩個問題源碼分析中已經給出答案，這里做一下總結，首先搞清楚以下對象在消息機制中的關系：
Looper，MessageQueue，Message，ThreadLocal，Handler
- Looper對象有一個成員MessageQueue，MessageQueue是一個消息隊列，用來存儲消息Message
- Message消息中帶有一個handler對象，所以Looper取出消息后，可以很方便的調用到Handler的方法（問題1解決）
- Message是如何帶有handler對象的？是handler在發送消息的時候把自己封裝到消息里的。
- Handler是如何發送消息的？是通過獲取Looper對象從而取得Looper里面的MessageQueue，然后Handler就可以直接往MessageQueue里面插入消息了。（問題2解決）
- Handler是如何獲取Looper對象的？Looper在創建的時候同時把自己保存到ThreadLocal中，并提供一個public的靜態方法可以從ThreadLocal中取出Looper，所以Handler的構造方法里可以直接調用靜態方法取得Looper對象。
帶著上面的一系列問題看源碼就很清晰了，下面是知乎上的一個問答：
Android中為什么主線程不會因為Looper.loop()里的死循環卡死？
原因很簡單，循環里有阻塞，所以死循環并不會一直執行，相反的，大部分時間是沒有消息的，所以主線程大多數時候都是處于休眠狀態，也就不會消耗太多的CPU資源導致卡死。
- 阻塞的原理是使用Linux的管道機制實現的
- 主線程沒有消息處理時阻塞在管道的讀端
- binder線程會往主線程消息隊列里添加消息，然后往管道寫端寫一個字節，這樣就能喚醒主線程從管道讀端返回，也就是說looper循環里queue.next()會調用返回...
這里說到binder線程，具體的實現細節不必深究，考慮下面的問題：
主線程的死循環如何處理其它事務？
首先需要看懂這個問題，主線程進入Looper死循環后，如何處理其他事務，比如activity的各個生命周期的回調函數是如何被執行到的（注意這里是在同一個線程下，代碼是按順序執行的，如果在死循環這阻塞了，那么進入死循環后循環以外的代碼是如何執行的）。
首先再看main函數的源碼
Looper.prepareMainLooper();
ActivityThread thread = new ActivityThread();
thread.attach(false);
if (sMainThreadHandler == null) {
sMainThreadHandler = thread.getHandler();
}
Looper.loop();
在Looper.prepare和Looper.loop之間new了一個ActivityThread并調用了它的attach方法，這個方法就是開啟binder線程的，另外new ActivityThread()的時候同時會初始化它的一個H類型的成員，H是一個繼承了Handler的類。此時的結果就是：在主線程開啟loop死循環之前，已經啟動binder線程，并且準備好了一個名為H的Handler，那么接下來在主線程死循環之外做一些事務處理就很簡單了，只需要通過binder線程向H發送消息即可，比如發送 H.LAUNCH_ACTIVITY 消息就是通知主線程調用Activity.onCreate() ，當然不是直接調用，H收到消息后會進行一系列復雜的函數調用最終調用到Activity.onCreate()。
至于誰來控制binder線程來向H發消息就不深入研究了，下面是《Android開發藝術探索》里面的一段話：
ActivityThread 通過 ApplicationThread 和 AMS 進行進程間通訊，AMS 以進程間通信的方式完成 ActivityThread 的請求后會回調 ApplicationThread 中的 Binder 方法，然后 ApplicationThread 會向 H 發送消息，H 收到消息后會將 ApplicationThread 中的邏輯切換到 ActivityThread 中去執行，即切換到主線程中去執行，這個過程就是主線程的消息循環模型。
這個問題就到這里，更多內容看知乎原文
最后
和其他系統相同，Android應用程序也是依靠消息驅動來工作的。網上的這句話還是很有道理的。
文章參考：
《Android開發藝術探索》
Android中為什么主線程不會因為Looper.loop()里的死循環卡死？
Android線程管理之ThreadLocal理解及應用場景
Android 消息機制——你真的了解Handler
Android Handler到底是什么
