Android-Handler消息機制實現原理

一、消息機制流程簡介

在應用啟動的時候，會執行程序的入口函數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();

1. 首先Looper.prepare()創建Looper並初始化Looper持有的消息隊列MessageQueue，創建好后將Looper保存到ThreadLocal中方便Handler直接獲取。
2. 然后Looper.loop()開啟循環，從MessageQueue里面取消息並調用handler的 dispatchMessage(msg) 方法處理消息。如果MessageQueue里沒有消息，循環就會阻塞進入休眠狀態，等有消息的時候被喚醒處理消息。
3. 再然后我們new Handler()的時候，Handler構造方法中獲取Looper並且拿到Looper的MessageQueue對象。然后Handler內部就可以直接往MessageQueue里面插入消息了，插入消息即發送消息，這時候有消息了就會喚醒Looper循環去處理消息。處理消息就是調用dispatchMessage(msg) 方法，最終調用到我們重寫的Handler的handleMessage()方法。

 

三、通過一些問題的研究加強對消息機制的理解

源碼分析完了，下面看一下文章開頭的兩個問題：

• Looper中是如何能調用到Handler的方法的？
• Handler是如何能往MessageQueue中插入消息的？

這兩個問題源碼分析中已經給出答案，這里做一下總結，首先搞清楚以下對象在消息機制中的關系：

Looper，MessageQueue，Message，ThreadLocal，Handler

1. Looper對象有一個成員MessageQueue，MessageQueue是一個消息隊列，用來存儲消息Message
2. Message消息中帶有一個handler對象，所以Looper取出消息后，可以很方便的調用到Handler的方法（問題1解決）
3. Message是如何帶有handler對象的？是handler在發送消息的時候把自己封裝到消息里的。
4. Handler是如何發送消息的？是通過獲取Looper對象從而取得Looper里面的MessageQueue，然后Handler就可以直接往MessageQueue里面插入消息了。（問題2解決）
5. Handler是如何獲取Looper對象的？Looper在創建的時候同時把自己保存到ThreadLocal中，並提供一個public的靜態方法可以從ThreadLocal中取出Looper，所以Handler的構造方法里可以直接調用靜態方法取得Looper對象。

帶着上面的一系列問題看源碼就很清晰了，下面是知乎上的一個問答：

Android中為什么主線程不會因為Looper.loop()里的死循環卡死？

原因很簡單，循環里有阻塞，所以死循環並不會一直執行，相反的，大部分時間是沒有消息的，所以主線程大多數時候都是處於休眠狀態，也就不會消耗太多的CPU資源導致卡死。

1. 阻塞的原理是使用Linux的管道機制實現的
2. 主線程沒有消息處理時阻塞在管道的讀端
3. 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到底是什么