第一次在掘金上發表文章，生怕說錯了什麼誤人子弟，更不敢標題黨。
如果文章有誤，歡迎您直接在評論指出。
一. What、Handler 是什麼
Handler 與 Message、MessageQueue、Looper 一起構成了 Android 的訊息機制，Android 系統通過大量的訊息來與使用者進行互動，View 的繪製、點選事件、Activity 的生命週期回撥等都作為訊息由主執行緒的 Handler 來處理。
Handler 在訊息機制中的作用是：傳送和處理訊息。
Handler 還有另一個重要的作用，跨執行緒通訊。最常見的就是子執行緒請求網路，然後使用 Handler 將請求到的資料 post 到主執行緒重新整理 UI，大名鼎鼎的 Retrofit 也是這麼做的。
二. How、如何使用 Handler
建立 Handler
private Handler handler = new Handler() { // 重寫 handleMessage 來根據不同 what 來處理 Message // 這個方法在 Handler 建立的執行緒執行 @Override public void handleMessage(Message msg) { super.handleMessage(msg); switch (msg.what) { case 0: MLog.i(msg.obj); break; case 1: break; default: } } };複製程式碼建立併傳送 Message
// 獲取一個 Message Message message = Message.obtain(); message.what = 0; message.obj = new Object(); // 使用 Handler 傳送 Message // 訊息傳送完成後 Handler 的 handleMessage(Message msg) 會處理訊息 handler.sendMessage(message); // 延遲 1s 傳送 Message handler.sendMessageDelayed(message, 1000); // 傳送一個空的 Message handler.sendEmptyMessage(msg.what); // 延遲傳送一個空的 Message handler.sendEmptyMessageDelayed(0, 1000); // 還可以這樣 // 建立 Message 並繫結 Handler Message message = handler.obtainMessage(); message.what = 0; message.obj = new Object(); // 傳送 Message message.sendToTarget();複製程式碼使用 Handler 子執行緒請求資料，主執行緒重新整理 UI
// 1. 在主執行緒建立 Handler（略） // 2. 子執行緒請求資料，主執行緒重新整理 UI new Thread(new Runnable() { @Override public void run() { // 獲取網路資料 final List<Object> datas = getNetData(); // 方法一：將資料作為 Message 的 obj 傳送出去，在 handleMessage 中重新整理 UI Message msg = Message.obtain(); msg.what = 1; msg.obj = data; handler.sendMessage(msg); // 方法二：直接在 post 中重新整理 UI handler.post(new Runnable() { @Override public void run() { // 使用 datas 重新整理 UI // 這個方法也會在 Handler 建立的執行緒執行 } }); } }).start();複製程式碼
三. Handler 的記憶體洩漏
不得不說，上面使用 Handler 的方法會有記憶體洩漏的風險
Handler 記憶體洩漏的兩個原因
Java 中非靜態內部類和匿名內部類會持有外部類的引用
// 這是一個外部類 Handler 不會持有外部類引用 // 顯然 handleMessage 沒地方寫了 Handler handler = new Handler(); // 重寫 handleMessage 後將得到一個內部類 Handler，以內 handleMessage 是在外部類中實現的 // 它持有外部類引用，可能會引起記憶體洩漏 Handler handler = new Handler() { @Override public void handleMessage(Message msg) { super.handleMessage(msg); switch (msg.what) { case 0: MLog.i(msg.obj); break; case 1: break; default: } } }; // 這裡 Handler 是一個匿名類，但不是內部類 // Runnable 是一個匿名內部類，持有外部類引用，可能會引起記憶體洩漏 new Handler().post(new Runnable() { @Override public void run() { // ... } });複製程式碼
Handler 的生命週期比外部類長。
分析
- 非靜態的內部 Handler 子類、匿名 Handler 子類會持有外部類的引用(Activity)，而 Handler 可能會因為要等待處理耗時操作導致存活時間超過 Activity，或者訊息佇列中存在未被 Looper 處理的 Message ，而 Message 會持有 Handler 的引用。於是，在 Activity 退出時，其引用還是被 Handler 持有，導致 Activity 無法被及時回收，造成記憶體洩露。
- 非靜態的內部 Runnable 子類、匿名 Runnable 子類 post 到任意 Handler 上時，Runnable 其實是 Massage中的 Callback，持有 Message 引用，如果這個 Massage 在訊息佇列還沒有被處理，那麼就會造成 Runnable 一直持有外部類的引用而造成記憶體洩露。
解決方案：
- 通過靜態內部類或者外部類來宣告 Handler 和 Runnable。
- 通過弱引用來拿到外部類的變數。
- 在 Activity/Fragment 銷燬的時候請空 MessageQueue 中的訊息。
程式碼
// Handler 弱引用封裝 public class SafetyHandler<T> extends Handler { /** * 外部引用, 例如 Activity, Fragment, Dialog, View 等 */ private WeakReference<T> mTargetRef; public SafetyHandler() { } public SafetyHandler(T target) { this.mTargetRef = new WeakReference<>(target); } public T getTarget() { if (isTargetAlive()) { return mTargetRef.get(); } else { removeCallbacksAndMessages(null); return null; } } public void setTarget(T target) { this.mTargetRef = new WeakReference<>(target); } private boolean isTargetAlive() { return mTargetRef != null && mTargetRef.get() != null; } } // 在 Fragment 中使用方法 // 想重寫 handleMessage 的話，要建立靜態內部類或者外部類，否則有記憶體洩漏風險 private static class MyHandler extends SafetyHandler<MyFragment> { MyHandler(MyFragment fragment) { super(fragment); } @Override public void handleMessage(Message msg) { super.handleMessage(msg); if(getTarget() != null) { MyFragment fragment = getTarget(); switch (msg.what) { // 操作 fragment } } } } // 宣告 Handler MyHandler handler = new MyHandler(this); // 使用 Handler handler.sendMessage() ... // onDestroy @Override public void onDestroy() { super.onDestroy(); handler.removeCallbacksAndMessages(null); }複製程式碼
四. Why、Handler 訊息機制的原理
這部分從 ActivityThread 的 main 方法出發，打通整個訊息機制的流程，結合原始碼體驗效果更佳。
概述
介紹訊息機制的原理前，我們先來看一下 Handler 與 Message、MessageQueue、Looper 這個四個類的作用
- Handler：前面已經說過，Handler 負責傳送和處理 Message。
- Message：訊息，負責傳遞標示(what) 和資料(obj) ；每個 Message 都會通過 target 這個成員變數來繫結一個 Handler，由這個 Handler 來傳送和處理 Message。
- MessageQueue：訊息佇列，負責存放有 Handler 傳送過來的訊息；每個 Handler 中都有一個 final MessageQueue mQueue，Handler 傳送訊息就是把訊息加入這個 MessageQueue 。
- Looper：負責不斷的從 MessageQueue 中取出訊息然後交給 Handler（Message#target ） 處理；每個 Looper 中都有一個唯一的訊息佇列（final MessageQueue mQueue），每個 Handler 中都有一個 final Looper mLooper，Handler 中的 MessageQueue 就是來自 Looper。
注意：每個執行緒只能有一個 Looper 和 一個 MessageQueue，可以有多個 Handler，每個 Handler 可以傳送和處理多個 Message。
另外，提到訊息機制就不得不說一下 Android 中的主執行緒（UI 執行緒）
Android 中的主執行緒通過 Looper.loop() 進入一個無線迴圈中，不斷的從一個 MessageQueue 取出訊息，處理訊息，我們每觸發一個事件，就會向這個 MessageQueue 中新增一個訊息，Looper 取出這個訊息，Handler 處理這個訊息，正是 Looper.loop() 在驅動著 Android 應用執行下去 ，這也是為什麼 Looper.loop 為什麼不會阻塞住主執行緒的原因（當然前提是在 ActivityThread 的 main 函式 中呼叫）。
正式進入原始碼分析
本原始碼分析基於 API 25，以下原始碼中刪除了一些無關的程式碼
1、在主執行緒的入口，ActivityThread 的 main 方法
public static void main(String[] args) {
// 準備主執行緒的 Looer
Looper.prepareMainLooper();
// 建立 ActivityThread
ActivityThread thread = new ActivityThread();
thread.attach(false);
// 獲取主執行緒的 Handler
if (sMainThreadHandler == null) {
sMainThreadHandler = thread.getHandler();
}
// 對訊息佇列進行無線輪詢，處理訊息
Looper.loop();
// 一旦跳出迴圈，丟擲異常（Android 不允許跳出主執行緒的 Looper.loop()）
throw new RuntimeException("Main thread loop unexpectedly exited");
}複製程式碼-> Looper.prepareMainLooper()
public static void prepareMainLooper() {
// 準備一個 Looper
prepare(false);
synchronized (Looper.class) {
// main Looper 只能初始化一次，再次初始化會丟擲異常
if (sMainLooper != null) {
throw new IllegalStateException("The main Looper has already been prepared.");
}
// 獲取 main Looper
sMainLooper = myLooper();
}
}複製程式碼-> prepare(false)
// 準備一個 Looper，quitAllowed 是否允許 Looper 中的 MessageQueue 退出
// 預設 prepare() 允許退出，主執行緒這裡不允許退出
private static void prepare(boolean quitAllowed) {
// 先看下 sThreadLocal 是什麼
// static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
// ThreadLocal:執行緒本地儲存區，每個執行緒都有本地儲存區域，這個區域是每個執行緒私有的，不同的執行緒不能之間不能彼此訪問
// 如果 sThreadLocal 中有資料，丟擲異常，換句話說 prepare() 這個函式每個執行緒只能執行一次
if (sThreadLocal.get() != null) {
throw new RuntimeException("Only one Looper may be created per thread");
}
// 建立 Looper 儲存到該執行緒的 ThreadLocal 中
sThreadLocal.set(new Looper(quitAllowed));
}複製程式碼-> new Looper(quitAllowed)
private Looper(boolean quitAllowed) {
// 在 Looper 建立的時候建立一個訊息佇列
// quitAllowed:訊息佇列是否可以退出，主線的訊息佇列肯定不允許退出，所以上面是 prepare(false)
// quitAllowed 為 false 執行 MessageQueue#quit 退出訊息佇列時會出現異常
mQueue = new MessageQueue(quitAllowed);
// 獲取 Looper 存在於哪個執行緒
mThread = Thread.currentThread();
}複製程式碼-> sMainLooper = myLooper()
public static @Nullable Looper myLooper() {
// 從 sThreadLocal 中獲取當前執行緒的 Looper
// 如果當前執行緒沒有掉用 Looper.prepare 返回 null
return sThreadLocal.get();
}複製程式碼-> sMainThreadHandler = thread.getHandler();
final Handler getHandler() {
// 返回 mH
return mH;
}
// mH 在成員變數的位置 new H()
final H mH = new H();
// H 繼承了 Handler 封裝了一系列關於 Acitivty、Service 以及其他 Android 相關的操作
private class H extends Handler複製程式碼總結：在主執行緒的 main 方法中，會建立主執行緒的 Looper、MessageQueue，然後進入 Looper.loop() 迴圈中，不斷的取出訊息，處理訊息，以此來驅動 Android 應用的執行。
2、Handler 的建立，Handler 的所有構造方法都會跳轉到下面兩個之一
public Handler(Callback callback, boolean async) {
// Hanlder 是匿名類、內部類、本地類時，如果沒有宣告為 static 則會出現記憶體洩漏的警告
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()");
}
// 訊息佇列，從 Looper 中獲取
mQueue = mLooper.mQueue;
// 處理訊息的回撥介面
mCallback = callback;
// 處理訊息的方式是否為非同步，預設同步
mAsynchronous = async;
}
public Handler(Looper looper, Callback callback, boolean async) {
mLooper = looper;
mQueue = looper.mQueue;
mCallback = callback;
mAsynchronous = async;
}複製程式碼總結：在 Handler 的構造方法中，Handler 和 Looper、MessageQueue 繫結起來，如果當前執行緒沒有 Looper 丟擲異常（這也是為什麼直接在子執行緒建立 Handler 會出現異常）。
3、使用 Handler 傳送訊息
-> sendMessageAtTime(Message msg, long uptimeMillis)
// 除了 sendMessageAtFrontOfQueue，Handler 所有的 post、sendMessage 都會跳到這個方法
// Message msg: 要傳送的訊息
// long uptimeMillis: 傳送訊息的絕對時間，通過 SystemClock.uptimeMillis() 加上我們自己的延遲時間 delayMillis 計算而來
public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
MessageQueue queue = mQueue;
// 訊息佇列為空（可能已經退出）返回 false 入隊失敗
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);
}複製程式碼-> sendMessageAtFrontOfQueue(Message msg)
// 傳送訊息到 MessageQueeu 的隊頭
public final boolean sendMessageAtFrontOfQueue(Message msg) {
MessageQueue queue = mQueue;
if (queue == null) {
RuntimeException e = new RuntimeException(
this + " sendMessageAtTime() called with no mQueue");
Log.w("Looper", e.getMessage(), e);
return false;
}
// 通過設定 uptimeMillis 為 0，是訊息加入到 MessageQueue 的隊頭
return enqueueMessage(queue, msg, 0);
}複製程式碼-> enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis)
// 所有 Handler 的 post 、sendMessage 系列方法和 runOnUiThread 最終都會呼叫這個方法
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
// msg.target 是一個 Handler，將 Message 和 Handler 繫結
// 也就是用哪個 Handler 傳送訊息，這個 Message 就和哪個 Handler 繫結
msg.target = this;
// 如果設定了訊息處理方式為非同步處理
if (mAsynchronous) {
msg.setAsynchronous(true);
}
// MessageQueue 的方法，將訊息入隊
return queue.enqueueMessage(msg, uptimeMillis);
}複製程式碼-> MessageQueue#enqueueMessage(Message msg, long when)
boolean enqueueMessage(Message msg, long when) {
// Messgae 沒有繫結 Handler 丟擲異常
if (msg.target == null) {
throw new IllegalArgumentException("Message must have a target.");
}
// Messgae 正在使用 丟擲異常
if (msg.isInUse()) {
throw new IllegalStateException(msg + " This message is already in use.");
}
synchronized (this) {
// 訊息佇列正在退出，回收 Message
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(); // 呼叫 Message#recycleUnchecked()
return false;
}
msg.markInUse(); // 標記 Message 正在使用
msg.when = when; // 設定 Message 的觸發時間
// mMessages 記錄著 MessageQueue 的隊頭的訊息
Message p = mMessages;
boolean needWake;
// MessageQueue 沒有訊息、Message 觸發時間為 0、Messgae 觸發時間比隊頭 Message 早
// 總之這個 Message 在 MessageQueue 中需要最先被分發
if (p == null || when == 0 || when < p.when) {
// New head, wake up the event queue if blocked.
msg.next = p; // 將以前的隊頭 Message 連結在這個 Message 後面
mMessages = msg; // 將這個 Message 賦值給 mMessages
needWake = mBlocked; // 佇列是否阻塞
} else {
// 標記佇列是否阻塞
needWake = mBlocked && p.target == null && msg.isAsynchronous();
Message prev;
// 按照時間順序將 Message 插入訊息佇列
for (;;) {
prev = p; // prev 記錄隊頭
p = p.next; // p 記錄隊頭的後一個
// 隊頭後面沒有訊息或者其觸發事件比要插入的 Message 晚，跳出迴圈
if (p == null || when < p.when) {
break;
}
if (needWake && p.isAsynchronous()) {
needWake = false;
}
}
// 將 Message 插入佇列
msg.next = p;
prev.next = msg;
}
// We can assume mPtr != 0 because mQuitting is false.
if (needWake) {
nativeWake(mPtr);
}
}
return true;
}複製程式碼總結：到現在為止，我們的 Handler 已經將 Message 傳送到了 MessageQueue，Message 靜靜的等待被處理。
4、Looper.loop() 還記得這個方法在 ActivityThread 的 main 呼叫了嗎？正是它在不斷處理 MessageQueue 裡面的訊息。
public static void loop() {
// 獲取 Looper.Looper.prepare 準備好的 Looper
final Looper me = myLooper();
if (me == null) {
throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
}
// 獲取 Looper 中的訊息佇列
final MessageQueue queue = me.mQueue;
// 進入無線迴圈
for (;;) {
// 取出下一條訊息
Message msg = queue.next();
// 沒有訊息，退出 loop
// 其實上面 queue.next() 也是一個無限迴圈，獲取到訊息就返回，沒有訊息就一直迴圈
if (msg == null) {
return;
}
try {
// msg.target 實際上就是一個 Handler
// 獲取到了訊息，使用繫結的 Handler#dispatchMessage 分發訊息
msg.target.dispatchMessage(msg);
} finally {
}
// 釋放訊息，把 Message 的各個變數清空然後放進訊息池中
msg.recycleUnchecked();
}
}複製程式碼5、Handler#dispatchMessage(msg) 訊息是如何處理的
public void dispatchMessage(Message msg) {
// 1
if (msg.callback != null) {
handleCallback(msg);
} else {
// 2
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
// 3. 看到這個方法沒有！就是我們建立 Handler 時重寫的 handleMessage
// OK 整個流程打通！
handleMessage(msg);
}
}複製程式碼總結：流程雖然通了，但是處理 Message 的方法貌似有三種(我標記了序號)，而且我們的 handleMessage 的優先順序最低，其他方法會在什麼情況下執行呢？ 直接說結論了，呼叫 Handler 的 post 系列方法會走序號1的處理，建立 Handler 傳入 Callback 會走序號2 的處理。
Handler 機制總結：想使用 Handler 必須要有 Looper，建立 Looper 的時候會建立 MessageQueue，在 Handler 的構造的時候會繫結這個 Looper 和 MessageQueue，Handler 將 Message 傳送到 MessageQueue 中，Looper.loop() 會不斷的從 MessageQueue 取出訊息再交給這個 Handler 處理。
五. HandlerThread 的使用及原始碼解讀
在子執行緒中能直接建立 Handler 嗎？
new Thread(new Runnable() { @Override public void run() { new Handler().post(new Runnable() { @Override public void run() { MLog.i("Handler in " + Thread.currentThread().getName()); } }); } }).start();複製程式碼答案前面提到了是不能，執行上面的程式碼會出現 java.lang.RuntimeException: Can't create handler inside thread that has not called Looper.prepare() 這個異常，異常提示我們，不能再沒有呼叫 Looper.prepare() 的執行緒中建立 Handler。
簡單修改下程式碼就可以了，給執行緒準備好 Looper
new Thread(new Runnable() { @Override public void run() { // 準備一個 Looper，Looper 建立時對應的 MessageQueue 也會被建立 Looper.prepare(); // 建立 Handler 並 post 一個 Message 到 MessageQueue new Handler().post(new Runnable() { @Override public void run() { MLog.i("Handler in " + Thread.currentThread().getName()); } }); // Looper 開始不斷的從 MessageQueue 取出訊息並再次交給 Handler 執行 // 此時 Lopper 進入到一個無限迴圈中，後面的程式碼都不會被執行 Looper.loop(); } }).start();複製程式碼
- 上面的操作 Android 都幫我們封裝好了，正是 HandlerThread 這個類。
HandlerThread 的簡單使用
// 1. 建立 HandlerThread
handlerThread = new HandlerThread("myHandlerThread") {
// onLooperPrepared 這個方法子執行緒執行，由執行緒的 run 方法呼叫，可以在裡面直接建立 Handler
@Override protected void onLooperPrepared() {
super.onLooperPrepared();
new Handler().post(new Runnable() {
@Override public void run() {
// 注意：Handler 在子執行緒建立，這個方法也會執行在子執行緒，不可以更新 UI
MLog.i("Handler in " + Thread.currentThread().getName());
}
});
}
};
// 2. 準備 HandlerThread 的 Looper 並呼叫 onLooperPrepared
handlerThread.start();
// 3. 退出
@Override public void onDestroy() {
super.onDestroy();
handlerThread.quit();
}
// 也可以這樣用
// 1. 建立 HandlerThread 並準備 Looper
handlerThread = new HandlerThread("myHandlerThread");
handlerThread.start();
// 2. 建立 Handler 並繫結 handlerThread 的 Looper
new Handler(handlerThread.getLooper()).post(new Runnable() {
@Override public void run() {
// 注意：Handler 繫結了子執行緒的 Looper，這個方法也會執行在子執行緒，不可以更新 UI
MLog.i("Handler in " + Thread.currentThread().getName());
}
});
// 3. 退出
@Override public void onDestroy() {
super.onDestroy();
handlerThread.quit();
}複製程式碼HandlerThread 原始碼解讀
HandlerThread 繼承了 Thread，本質是一個擁有 Looper 的執行緒，因此在 HandlerThread 我們可以直接使用 Handler。
構造方法
public HandlerThread(String name) { super(name); mPriority = Process.THREAD_PRIORITY_DEFAULT; } // 傳入執行緒的名稱和優先順序 // 注意 priority 的值必須來自 android.os.Process 不能來自 java.lang.Thread public HandlerThread(String name, int priority) { super(name); mPriority = priority; }複製程式碼run 方法：建立子執行緒的 Looper
@Override public void run() { mTid = Process.myTid(); // 準備一個 Looper Looper.prepare(); synchronized (this) { // 獲取 Looper mLooper = Looper.myLooper(); // Looper 獲取成功後，喚醒 getLooper 的 wait notifyAll(); } Process.setThreadPriority(mPriority); // Looper 準備好的回撥，在這個方法裡可以使用 Handler 了 onLooperPrepared(); // Looper 開始迴圈取訊息 Looper.loop(); mTid = -1; }複製程式碼getLooper 方法：獲取子執行緒的 Looper
public Looper getLooper() { // 執行緒沒有開始或者死亡，返回 null if (!isAlive()) { return null; } // If the thread has been started, wait until the looper has been created. // Looper 的建立時在子執行緒完成的，而 getLooper 可能會在主執行緒呼叫 // 當 Looper 沒有建立完成時，使用 wait 阻塞等待 // 上面在 Looper 建立好後會 notifyAll 來喚醒 wait synchronized(this) { while (isAlive() && mLooper == null) { try { wait(); } catch (InterruptedException e) { } } } return mLooper; }複製程式碼quit 和 quitSafely ：結束 Looper 的執行
// quit quit() -> looper.quit() -> mQueue.quit(false); // quitSafely quitSafely() -> looper.quitSafely() -> mQueue.quit(true); // 這兩個方法最終都會呼叫到 MessageQueue 的 void quit(boolean safe) 方法 // 前者會直接移除 MessageQueue 中的所有訊息，然後終止 MessageQueue // 後者會將 MessageQueue 中已有訊息處理完成後（不再接收新訊息）終止 MessageQueue複製程式碼六.參考文章
- Android API 25 原始碼
- Android訊息機制1-Handler(Java層)