前言
Handler是一個Android SDK 提供給開發者方便進行非同步訊息處理的類。
我們都知道在UI執行緒中不能進行耗時操作，例如資料讀寫、網路請求。Android 4.0開始，在主執行緒中進行網路請求甚至會丟擲Android.os.NetworkOnMainThreadException。這個時候，我們就會開始依賴Handler。我們在子執行緒進行耗時操作後，將請求結果通過Handler的sendMessge**() 方法傳送出去，在主執行緒中通過Handler的handleMessage 方法處理請求結果，進行UI的更新。
後來隨著AsyncTask、EventBus、Volley以及Retrofit 的出現，Handler的作用似乎被弱化，逐漸被大家遺忘。其實不然，AsyncTask其實是基於Handler進行了非常巧妙的封裝，Handler的使用依然是其核心。Volley同樣也是使用到了Handler。因此，我們有必要了解一下Handler的實現機制。
神奇的Handler
記得很久之前的一天，我在閱讀別人的程式碼時，看到了這樣一段：
new Handler().postDelayed(new Runnable() {
@Override
public void run() {
Toast.makeText(mContext, "I'm new Handler !", Toast.LENGTH_SHORT).show();
}
}, 1000);
複製程式碼第一印象就是，這不是在子執行緒中進行UI操作嗎？這程式碼有問題吧，於是乎立刻在自己電腦上寫了個demo試了一下，結果發現真的沒有問題。在一陣懵逼過後，我又寫出下面的程式碼，測試一下子執行緒中到底能不能進行UI操作。
new Thread(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
Toast.makeText(mContext, "I'm new Thread !", Toast.LENGTH_SHORT).show();
}
}).start();
複製程式碼結果很明顯，程式一啟動立刻就奔潰了。並丟擲異常java.lang.RuntimeException: Can't create handler inside thread that has not called Looper.prepare()。
於是乎我又在try block 之前新增了Looper.prepare()這行程式碼。再次執行程式雖然沒有奔潰，但也沒有任何反應，Toast也沒顯示。
那麼Handler到底是什麼呢？他怎麼就這麼神奇。
實現機制解析
首先，我們從整體上了解一下，在整個Handler機制中所有使用到的類，主要包括Message，MessageQueue,Looper以及Handler。
好了，為了方便後面的敘述，我們就首先了解一下這個類圖中使用到幾個類，及其關鍵方法。
Message
首先看一下Message這個類的定義（擷取部分）
public final class Message implements Parcelable {
public int what;
public int arg1;
public int arg2;
public Object obj;
/*package*/ Handler target;
/*package*/ Runnable callback;
/**
* 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();
}
/** Constructor (but the preferred way to get a Message is to call {@link #obtain() Message.obtain()}).
*/
public Message() {
}
}
複製程式碼看到這個類的前四個屬性，大家應該很熟悉，就是我們使用Handler時經常用到的那幾個屬性。用來在傳遞我們特定的資訊。其次我們還可以總結出以下資訊：
- Message 實現了Parcelable 介面，也就是說實現了序列化，這就說明Message可以在不同程式之間傳遞。
- 包含一個名為target的Handler 物件
- 包含一個名為callback的Runnable 物件
- 使用obtain 方法可以從訊息池中獲取Message的例項，也是推薦大家使用的方法，而不是直接呼叫構造方法。
MessageQueue
MessageQueue顧名思義，就是上面所說的Message所組成的queue。
首先看一下構造方法：
MessageQueue(boolean quitAllowed) {
mQuitAllowed = quitAllowed;
mPtr = nativeInit();
}
複製程式碼接收一個引數，決定當前佇列是否允許被終止。同時呼叫 一個native方法，初始化了一個long型別的變數mPtr。
同時，在這個類當中，還定義了一個next 方法，用於返回一個Message 。
Message next() {
// Return here if the message loop has already quit and been disposed.
// This can happen if the application tries to restart a looper after quit
// which is not supported.
final long ptr = mPtr;
if (ptr == 0) {
return null;
}
……
}
複製程式碼由於這個方法中有一些native呼叫，未能完全理解，只知道會返回一個Message物件。
這個next方法相當於是佇列出棧，有出棧必然有進棧，enqueueMessage 方法就是完成這個操作；這個我們後面再說。
Looper
上面說到了MessageQueue，那麼這個Queue又是由誰建立的呢？其實就是Looper。關於Looper有兩個關鍵方法：
prepare() 和 loop()
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));
}
複製程式碼可以看到，對於每一個執行緒只能有一個Looper。也就是說執行prepare方法時，必然執行最後一行程式碼 sThreadLocal.set(new Looper(quitAllowed));
我們再看Looper(quitAllowed)方法：
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
複製程式碼這樣，MessageQueue 就被建立了。這裡也可以看到，預設情況下，一個MessageQueue的quiteAllow=true。
這裡使用到的sThreadLocal 是一個ThreadLocal物件。簡單來說，使用它可以用來解決多執行緒程式的併發問題。使用set方法，將此執行緒區域性變數的當前執行緒副本中的值設定為指定值；使用get方法，返回此執行緒區域性變數的當前執行緒副本中的值。
Looper-loop()
再看一下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;
}
msg.target.dispatchMessage(msg);
msg.recycleUnchecked();
}
}
複製程式碼首先看第一句程式碼執行的方法：
/**
* Return the Looper object associated with the current thread. Returns
* null if the calling thread is not associated with a Looper.
*/
public static @Nullable Looper myLooper() {
return sThreadLocal.get();
}
複製程式碼很明顯，這樣返回的Looper就是剛才prepare時set進去的那個，因為都是在同一執行緒。再明確一下，一個執行緒對應一個Looper。
這樣就確保我們可以在不同的執行緒中建立各自的Handler，進行各自的通訊而不會互相干擾
回到程式碼，後面邏輯就很簡單了，在一個死迴圈中，通過佇列出棧的形式，不斷從MessageQueue 中取出新的Message，然後執行msg.target.dispatchMessage(msg) 方法，還記的前面Message類的定義嗎，這個target屬性其實就是一個Handler 物件，因此在這裡就會不斷去執行Handler 的dispatchMessage 方法。如果取出的Message物件為null，就會跳出死迴圈，一次Handler的工作整個就結束了。
Handler
上面說了這麼多終於輪到Handler，那麼就看看在Handler中到底發生了什麼。回到我們一開始的程式碼。
new Handler().postDelayed(new Runnable() {
@Override
public void run() {
String currentName=Thread.currentThread().getName();
Toast.makeText(mContext, "I'm new Thread "+currentName, Toast.LENGTH_SHORT).show();
}
}, 4000);
複製程式碼這裡我們用Toast彈出了當前執行緒的name，結果發現這個執行緒的名字居然是main，這也是必然結果
讓我們一步一步看看，神奇的Handler到底是怎樣工作的。就從這個程式碼開始解讀。首先看一下Handler的構造方法。
public Handler() {
this(null, false);
}
---------------
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;
}
複製程式碼這裡做的事情很簡單，就是完成了一些初始化的工作，呼叫Looper.myLooper()賦值給當前mLooper，關聯MessageQueue；這裡由於程式碼中呼叫的是不帶任何引數的建構函式，因此會建立一個mCallback=null且非非同步執行的Handler 。
接下看postDelayed 方法。
public final boolean postDelayed(Runnable r, long delayMillis)
{
return sendMessageDelayed(getPostMessage(r), delayMillis);
}
private static Message getPostMessage(Runnable r) {
Message m = Message.obtain();
m.callback = r;
return m;
}
複製程式碼這裡通過getPostMessage(Runnable r) 方法，把我們在Activity裡寫的Runnable 這個執行緒賦給了Message 的callback這個屬性。
平時大家使用Handler也發現了，他為我們提供了很多方法
因此，上面的postDelayed經過了各種輾轉反側，最終來到了這裡：
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);
}
複製程式碼經過之前的構造方法，mQueue顯然不為null，繼續往下看
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
}
複製程式碼注意，注意，注意 這裡進行了一次賦值：
msg.target = this;
複製程式碼前面提到，這個target就是一個Handler物件，因此這裡Message就和當前Handler關聯起來了。enqueueMessage，哈哈，這就是我們之前在MessageQueue中提到的進棧操作的方法，我們看一下：
boolean enqueueMessage(Message msg, long when) {
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) {
IllegalStateException e = new IllegalStateException(
msg.target + " sending message to a Handler on a dead thread");
Log.w(TAG, e.getMessage(), e);
msg.recycle();
return false;
}
msg.markInUse();
msg.when = when;
Message p = mMessages;
boolean needWake;
if (p == null || when == 0 || when < p.when) {
// New head, wake up the event queue if blocked.
msg.next = p;
mMessages = msg;
needWake = mBlocked;
} else {
// Inserted within the middle of the queue. Usually we don't have to wake
// up the event queue unless there is a barrier at the head of the queue
// and the message is the earliest asynchronous message in the queue.
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; // invariant: p == prev.next
prev.next = msg;
}
// We can assume mPtr != 0 because mQuitting is false.
if (needWake) {
nativeWake(mPtr);
}
}
return true;
}
複製程式碼這個方法就是典型的佇列入隊操作，只不過會根據Message這個物件特有的一些屬性，以及當前的狀態是否inUse，是否已經被quit等進行一些額外的判斷。
這樣，我們就完成訊息入隊的操作。還記得我們在Looper中說過，在loop方法中，會從MessageQueue中取出Message 並執行他的dispatchMessage 方法。
**dispatchMessage **
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
複製程式碼到這裡，就很明確了，在之前的postDelayed 方法中，已經通過getPostMessage，實現了 m.callback = r；這樣這裡就會執行第一個if語句：
private static void handleCallback(Message message) {
message.callback.run();
}
複製程式碼這樣，就會執行我們在Activity 的Runnable 中的run 方法了，也就是顯示Toast。
到了這裡，我們終於明白了，使用Handler 的postDelay 方法時，其Runnable中的run方法並不是在子執行緒中執行，而是把這個Runnable賦值給了一個Message物件的callback屬性，而這個Message會被傳遞到建立Handler所在的執行緒，也就是這裡的主執行緒，所以這個Toast的顯示依舊是在主執行緒中。這也和postDelay API 中所宣告的內容是一致的。
/** * Causes the Runnable r to be added to the message queue, to be run * after the specified amount of time elapses. * The runnable will be run on the thread to which this handler * is attached. */
到這裡，一開始所說的第一個程式碼塊所執行的邏輯已經理清楚了，但是還是有一點疑問，我們並沒有在Handler的構造方法中看到Looper 的prepare()方法和loop() 方法被執行，那麼他們到底是在哪裡執行的呢？這個問題我也是疑惑了很久，最終才明白是在 ActivityThread的main方法中執行。簡單來說，ActivityThread是Java層面一個Android程式真正的入口。關於ActivityThread更多的內容可以看看這篇文章。
ActivityThread-main方法（擷取主要部分）
public static void main(String[] args) {
Looper.prepareMainLooper();
ActivityThread thread = new ActivityThread();
thread.attach(false);
if (sMainThreadHandler == null) {
sMainThreadHandler = thread.getHandler();
}
if (false) {
Looper.myLooper().setMessageLogging(new
LogPrinter(Log.DEBUG, "ActivityThread"));
}
// End of event ActivityThreadMain.
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
Looper.loop();
throw new RuntimeException("Main thread loop unexpectedly exited");
}
複製程式碼這個類藏的比較深，你可以在Android-SDK\sources\android-24\android\app 這個目錄中找到。
也就是說，在一個Android 程式啟動之初，系統會幫我們為這個主執行緒建立好Looper。只不過這個方法名字比較特殊，叫做prepareMainLooper。
public static void prepareMainLooper() {
prepare(false);
synchronized (Looper.class) {
if (sMainLooper != null) {
throw new IllegalStateException("The main Looper has already been prepared.");
}
sMainLooper = myLooper();
}
}
複製程式碼注意這裡呼叫prepare時傳遞的引數值為false，和我們之前建立普通Looper時是不同的，這也 可以理解，因為這是主執行緒，怎麼可以被允許被外部程式碼終止呢。
到這裡，我們終於完整的理解了開頭我們提到的第一個程式碼塊的內容了。
至於第二種使用寫法出錯的原因也在明顯不過了，主執行緒會在程式啟動時在main方法中幫我們主動建立Looper，呼叫loop方法；而我們自己建立的執行緒就得我們主動去呼叫Looper.prepare()，這樣才能保證MessageQueue被建立，程式不會奔潰；但是我們所期望的Toast依然沒有顯示出來，這是為什麼呢？因為，我們沒有呼叫loop方法。訊息被加入佇列了，但是沒有辦法彈出。因此我們將程式碼修改如下：
new Thread(new Runnable() {
@Override
public void run() {
Looper.prepare();
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
Toast.makeText(mContext, "I'm new Thread !", Toast.LENGTH_SHORT).show();
Looper.loop();
}
}).start();
複製程式碼這樣就沒問題了，Toast就可以顯示出來了。實際上，平時寫程式碼肯定不會這麼寫，這裡只是為了說明問題。
handleMessage
回想一下，我們使用Handler最常見的場景：
handler = new MyHandler();
private class MyCallback implements Callback {
@Override
public void onFailure(Call call, IOException e) {
Message msg = new Message();
msg.what = 100;
msg.obj = e;
handler.sendMessage(msg);
}
@Override
public void onResponse(Call call, Response response) throws IOException {
Message msg = new Message();
msg.what = 200;
msg.obj = response.body().string();
handler.sendMessage(msg);
}
}
複製程式碼上面的程式碼是OKHttp的回撥方法，由於其回撥方法不處於UI 執行緒，因此需要我們通過Handler將結果傳送到主線中取執行。 那麼這又是怎樣實現的呢？
前面我們截圖說過，Handler為我們提供許多sendMessage 相關的方法，因此這裡我們在onResponse 中執行的sendMessage 經過層層傳遞，殊途同歸依然會回到MessageQueue的enqueueMessage方法，也就是說所有的sendMessageXXX方法完成的工作無非就是佇列入棧的工作，就是將包含特定資訊的Message加入到MessageQueue中。而我們也知道，通過loop方法，會從MessageQueue中取出Message，執行每一個Message 所對應Handler的dispatchMessage方法，我們再看一次這個方法：
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
複製程式碼這一次，我們建立的Message很簡單，其callback屬性必然是空的，而且在例項化Handler時，呼叫的是其無參建構函式 ，因此這個時候，就會執行最後一行程式碼handleMessage(msg) ；
/**
* Subclasses must implement this to receive messages.
*/
public void handleMessage(Message msg) {
}
複製程式碼空的 ! 沒錯，這個方法就是空的，因為這是需要我們在Handler的繼承類中自己實現的方法呀。比如下面這樣；
class MyHandler extends Handler {
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
loading.setVisibility(View.GONE);
switch (msg.what) {
case 100:
Object e = msg.obj;
Toast.makeText(mContext, e.toString(), Toast.LENGTH_SHORT).show();
break;
case 200:
String response = (String) msg.obj;
tv.setText(response);
break;
default:
break;
}
}
}
複製程式碼我們在handleMessage方法中，實現了自己的處理邏輯。
總結
好了，這就是Handler的實現機制，這裡再做一次總結稱述。
- 通過Looper的prepare方法建立MessageQueue
- 通過loop方法找到和當前執行緒匹配的Looper物件me
- 從me中取出訊息佇列物件mQueue
- 在一個死迴圈中，從mQueue中取出Message物件
- 呼叫每個Message物件的msg.target.dispatchMesssge方法
- 也就是Handler的dispatchMessage 方法
- 在dispatchMessage 根據Message物件的特點執行特定的方法。
至此，終於弄明白了Handler的執行機制。