# 1. 什么是消息機制
說到消息機制谆棱，作為一名 Android 開發(fā)者一定先想到的是 Handler。Handler 就是 Android 消息機制的上層接口逢防，我們可用通過 Handler 輕松的在不同的線程中切換任務(wù)龄广，但 Handler 的實現(xiàn)還有兩個很重要的概念 MessageQueue 和 Looper。
MessageQueue 的翻譯是消息隊列宰掉，它的內(nèi)部采用了單鏈表的結(jié)構(gòu)存儲 Handler 對象發(fā)送的消息呵哨。
Looper 的作用是不斷地查詢 MessageQueue 中是否有消息，如果 Looper 發(fā)現(xiàn) MessageQueue 中存入了新的消息轨奄，它就會去處理這條消息孟害，如果沒有新消息，Looper 就會以無限循環(huán)的方式去查詢 MessageQueue 中是否有新消息戚绕。
# 2. 為什么要有 Handler
## 2.1）官方文檔中 Handler 的主要作用
（1）安排將來某個時間點執(zhí)行的 Message 和 Runnables纹坐；
（2）在不同于當(dāng)前的線程上執(zhí)行的操作枝冀；
## 2.2）Handler 被用來做的最多的一件事就是更新主線程的 UI舞丛。
在 Android 開發(fā)中，默認(rèn)子線程是不可以更新 UI 的果漾，這一點可以從 View 的最高層級 ViewRootImpl 類中找到答案
void checkThread() {
if (mThread != Thread.currentThread()) {
throw new CalledFromWrongThreadException("Only the original thread that created a view hierarchy can touch its views.");
}
}
ViewRootImpl 類中的 checkThread 方法會在更新 UI 前被執(zhí)行球切，如果當(dāng)前線程不是主線程，就會拋出 Only the original thread that created a view hierarchy can touch its views. 的異常
## 2.3）那么 Android 為什么要設(shè)計為只能在主線程中更新 UI 呢绒障？
- Android 在子線程中更新 UI 是不安全的吨凑，如果多個子線程同時修改一個控件的數(shù)據(jù)世囊，后果是不可控的
- 如果給 UI 更新機制加鎖逃沿，會降低 UI 的訪問效率，并且可能阻塞某些線程的執(zhí)行
# 3. Handler 的用法
## 3.1）在主線程中創(chuàng)建 Handler
通常呛讲，我們在主線程中創(chuàng)建 Handler 的寫法如下：
private Handler handler = new Handler(){
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
}
};
但這樣寫庐镐，系統(tǒng)會這樣提示：
This Handler class should be static or leaks might occur (anonymous android.os.Handler)
這個Handler類應(yīng)該是靜態(tài)的恩商，否則可能會發(fā)生泄漏
出現(xiàn)這個警告但原因是，Handler 在 Activity 中作為一個匿名內(nèi)部類來定義必逆，它的內(nèi)部持有來 Activity 的實例怠堪。當(dāng) Activity 被用戶關(guān)閉時，因為 Handler 持有了 Activity 的引用名眉，就造成了 Activity 無法被回收粟矿，從而導(dǎo)致了內(nèi)存泄漏。
因此损拢，在這里推薦一種更加安全的寫法：
private static class MyHandler extends Handler{
private WeakReference<Activity> weakReference;
public MyHandler(Activity activity){
weakReference = new WeakReference<>(activity);
}
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
switch (msg.what){
case 0:
Toast.makeText(weakReference.get(),Thread.currentThread().getName(),Toast.LENGTH_SHORT).show();
break;
}
}
}
private MyHandler handler = new MyHandler(this);
通過靜態(tài)內(nèi)部類的方式實現(xiàn)一個 Handler陌粹，此時內(nèi)部類并不持有外部類對象的應(yīng)用，需要在內(nèi)部類的構(gòu)造方法內(nèi)增加一個外部類（Activity）的弱應(yīng)用福压。這樣掏秩，即使 Activity 被關(guān)閉绘证，Activity 也能順利被回收。
onCreate() 中的代碼如下：
btn_0 = findViewById(R.id.btn_0);
btn_0.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
new Thread(){
@Override
public void run() {
super.run();
Message message = Message.obtain();
message.what = 0;
handler.sendMessage(message);
}
}.start();
}
});
這時候點擊按鈕的運行效果如下：
## 3.2）在子線程中創(chuàng)建 Handler
在官方文檔中 Handler 的主要作用是在不同于當(dāng)前線程的線程中執(zhí)行操作哗讥，那么如何用 Handler 解決兩個子線程之間的通信呢嚷那？
請看代碼：
btn_1 = findViewById(R.id.btn_1);
btn_1.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
new Thread(){
@Override
public void run() {
super.run();
Looper.prepare();
handler = new MyHandler(MainActivity.this);
try {
sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
Looper.loop();
}
}.start();
new Thread(){
@Override
public void run() {
super.run();
Message message = Message.obtain();
message.what = 0;
handler.sendMessage(message);
}
}.start();
}
});
此時點擊按鈕：
可見當(dāng)前的處理線程已經(jīng)變成了子線程。
# 4. Handler 工作原理
如果細(xì)心的觀察代碼杆煞，可以看到在子線程中創(chuàng)建 Handler 的時候調(diào)用了 Looper.prepare() 和 Looper.loop() 兩個方法魏宽。這兩句代碼有什么用呢？
我們暫時可以把 Looper 理解為消息的管理者决乎，它負(fù)責(zé)從 MessageQueue 中提取出消息队询，傳遞給 Handler 進行處理，每一個 Handler 都必須要有一個 Looper构诚，在 Handler 創(chuàng)建的時候蚌斩，它會自動使用當(dāng)前線程的 Looper，而 Looper.prepare() 的作用就是為當(dāng)前線程準(zhǔn)備一個 Looper范嘱，Looper.loop() 的作用是開始查找當(dāng)前 MessageQueue 中是否有了新的消息送膳。
這就是 Handler 工作的第一步 ：
## 4.1）采用當(dāng)前線程的 Looper 創(chuàng)建 Handler
因為這里主要講 Handler 的工作流程，創(chuàng)建 Looper 的具體過程放到文章的下面講解丑蛤。我們只要知道
Looper.prepare() 為當(dāng)前的線程創(chuàng)建了一個 Looper 對象即可叠聋。
但是，在主線程中創(chuàng)建 Handler 的時候受裹，我們并沒有看到 Looper.prepare() 的執(zhí)行碌补，這是因為在 UI 線程，即 ActivityThread 的創(chuàng)建過程中棉饶，Looper 已經(jīng)被創(chuàng)建好了厦章。
我們可以在 ActivityThread 的 main() 方法中看到這樣一句代碼：
Looper.prepareMainLooper();
這個方法內(nèi)部也調(diào)用了 Looper.prepare() 為 UI 線程創(chuàng)建了一個 Looper。
## 4.2）通過 Handler 的 sendMessageAtTime() 方法發(fā)送 Message
為什么是 sendMessageAtTime照藻？不是還有 sendMessage()袜啃，sendEmptyMessage()，sendEmptyMessageDelayed()岩梳，sendEmptyMessageAtTime()囊骤，sendMessageDelayed() 這么多方法嗎？
通過閱讀這些方法的源碼可以發(fā)現(xiàn)冀值，這些方法最終調(diào)用的都是 sendMessageAtTime()也物。
其次還有 post()，postAtTime()列疗，postDelayed() 方法最終調(diào)用的也都是 sendMessageAtTime() 方法滑蚯，只是多了一步調(diào)用 getPostMessage(Runnable r, Object token) 將 Runnable 封裝為一個 Message 對象的 callback 里。
public final boolean post(Runnable r){
return sendMessageDelayed(getPostMessage(r), 0);
}
private static Message getPostMessage(Runnable r) {
Message m = Message.obtain();
m.callback = r;
return m;
}
那么 sendMessageAtTime() 里的具體操作是什么呢？我們?nèi)ピ创a里一探究竟
public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
// 先獲取當(dāng)前 Handler 中的 MessageQueue告材，mQueue 在 Looper 的構(gòu)造方法中進行初始化坤次。
MessageQueue queue = mQueue;
if (queue == null) {
RuntimeException e = new RuntimeException(
this + " sendMessageAtTime() called with no mQueue");
Log.w("Looper", e.getMessage(), e);
return false;
}
// queue 不為空，則執(zhí)行 Handler.java 里的另一個 enqueueMessage() 方法
return enqueueMessage(queue, msg, uptimeMillis);
}
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
// 指定 msg 的 Target 對象為當(dāng)前的 Handler
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
}
在 enqueueMessage() 中斥赋，會最終調(diào)用 MessageQueue.java 中的 enqueueMessage() 方法缰猴。
在 sendMessageAtTime() 方法內(nèi)部 調(diào)用了 enqueueMessage() 方法，將 Message 對象傳遞到 MessageQueue 即消息隊列里中疤剑，在消息隊列里的具體處理邏輯在文章的 MessageQueue 工作原理 部分會具體解釋滑绒。
## 4.3）Looper 處理消息后調(diào)用 Handler 的 dispatchMessage() 方法
在第二步將消息插入消息隊列后，Looper 就開始遍歷消息隊列隘膘，找到新的消息疑故，再通知 Handler 去執(zhí)行這條消息，調(diào)用的就是 Handler 的 dispatchMessage() 方法弯菊。
public void dispatchMessage(Message msg) {
// msg 的 callback 對象就是一個 Runnable
if (msg.callback != null) {
handleCallback(msg);
} else {
// 檢查 mCallback 是否為空纵势，不為空就執(zhí)行它內(nèi)部定義的 handleMessage() 方法
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
// 如果 mCallback 為空，就執(zhí)行在實例化 Handler 過程中我們自己定義的 handleMessage() 方法中的內(nèi)容
handleMessage(msg);
}
}
dispatchMessage() 方法首先會檢查 Message 的 Callback 對象是否為空管钳，callback 就是通過 post() 方法傳遞的 Runnable 對象钦铁，如果 callback 不為空，就去執(zhí)行 handleCallback() 方法蹋嵌。
handleCallback() 方法的實現(xiàn)也很簡單育瓜，它在內(nèi)部執(zhí)行了 Runnable 的 run() 方法
private static void handleCallback(Message message) {
message.callback.run();
}
如果 callback 對象為空，就檢查 mCallback 是否為空栽烂，不為空就執(zhí)行它的定義的 handleMessage() 方法，若沒有 mCallback恋脚，最終將直接執(zhí)行我們在繼承 Handler 時自己定義的 handleMessage() 方法中的代碼腺办。
Callback 是 Handler 中定義的的一個接口，它的代碼如下：
/**
* Callback interface you can use when instantiating a Handler to avoid
* having to implement your own subclass of Handler.
*/
public interface Callback {
/**
* @param msg A {@link android.os.Message Message} object
* @return True if no further handling is desired
*/
public boolean handleMessage(Message msg);
}
如果使用 Callback 接口的話糟描，我們可以直接實例化一個 Handler 而不用去實現(xiàn)一個 Handler 的子類怀喉，
private Handler mHandler = new Handler(new Handler.Callback() {
@Override
public boolean handleMessage(Message msg) {
return false;
}
});
# 5. MessageQueue 工作原理
我們從上一部分的 MessageQueue.java 中的 enqueueMessage() 方法開始入手。
## 5.1）enqueueMessage()
代碼量有點多船响，要耐心看哦躬拢！
boolean enqueueMessage(Message msg, long when) {
// 檢查當(dāng)前 msg 的 target 是否為空
if (msg.target == null) {
throw new IllegalArgumentException("Message must have a target.");
}
// msg 如果正在被執(zhí)行，就拋出異常
if (msg.isInUse()) {
throw new IllegalStateException(msg + " This message is already in use.");
}
synchronized (this) {
// 在 quit() 方法中见间，mQuitting 會被設(shè)置為 true
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;
}
// 標(biāo)記當(dāng)前的 msg 正在執(zhí)行
msg.markInUse();
// 設(shè)置 msg 的 when 為傳進來的 when 參數(shù)聊闯，when 是 Message 想要被執(zhí)行的時間
msg.when = when;
// 得到當(dāng)前消息隊列的頭部消息
Message p = mMessages;
boolean needWake;
// 當(dāng)前消息隊列為空，新消息的觸發(fā)時間為 0米诉，或者新消息的觸發(fā)時間早于消息中第一條消息的觸發(fā)時間
// 則將新消息插入到隊列的頭部菱蔬，作為當(dāng)前消息隊列的第一條消息
if (p == null || when == 0 || when < p.when) {
// New head, wake up the event queue if blocked.
// 將當(dāng)前消息的下一條消息指向頭部消息
msg.next = p;
// 頭部消息修改為當(dāng)前消息
mMessages = msg;
// 當(dāng)阻塞時，需要喚醒
needWake = mBlocked;
} else {
// 將新消息插入到當(dāng)前消息隊列當(dāng)中，（不是頭部）
// 通常我們不必喚醒事件隊列拴泌，
// 除非隊列頭部有消息障礙魏身，并且消息是隊列中最早的異步消息。
needWake = mBlocked && p.target == null && msg.isAsynchronous();
Message prev;
// 開始循環(huán)便利消息隊列蚪腐，比較新消息和隊列中消息的 when（觸發(fā)事件）的值箭昵，將新消息插入到適當(dāng)位置
for (;;) {
// 循環(huán)第一次遍歷時，將當(dāng)前隊列中的頭部消息賦值給 prev
prev = p;
// p 指向隊列中的第二個消息
p = p.next;
// 如果下一個消息為空回季，或者新消息的觸發(fā)時間早于下一個消息宙枷，找到了要插入的位置，退出循環(huán)
if (p == null || when < p.when) {
break;
}
// needWake 為 true茧跋，并且 下一條消息是異步的慰丛，則不需要喚醒。
if (needWake && p.isAsynchronous()) {
needWake = false;
}
}
// 將新消息插入到 p 之前瘾杭，頭消息之后诅病。
msg.next = p; // invariant: p == prev.next
prev.next = msg;
}
// 如果需要喚醒，調(diào)用 nativeWake 方法去喚醒
if (needWake) {
nativeWake(mPtr);
}
}
return true;
}
執(zhí)行完 enqueueMassage 方法粥烁，我們新發(fā)送的 Message 就成功的插入了消息隊列當(dāng)中贤笆。
但是除了插入新消息，我們還需要從消息隊列中讀取消息讨阻，這又要怎么做呢芥永？
## 5.2）next()
Message next() {
// 如果消息循環(huán)已退出，并且被丟棄钝吮，則返回空埋涧。
// 這個將在應(yīng)用重啟一個 looper 時發(fā)生
final long ptr = mPtr;
if (ptr == 0) {
return null;
}
// 記錄空閑時處理的 IdlerHandler 數(shù)量，只在第一次迭代時為 -1
// IdleHandler 只在隊列為空 或者 是頭部消息時執(zhí)行
int pendingIdleHandlerCount = -1;
// native 層使用的變量奇瘦，設(shè)置的阻塞超時時長棘催，0 為不阻塞，-1 為阻塞
int nextPollTimeoutMillis = 0;
for (;;) {
if (nextPollTimeoutMillis != 0) {
Binder.flushPendingCommands();
}
nativePollOnce(ptr, nextPollTimeoutMillis);
// 嘗試檢索下一條消息耳标。 如果找到則返回醇坝。
synchronized (this) {
// 獲取系統(tǒng)從開機到現(xiàn)在到時間
final long now = SystemClock.uptimeMillis();
Message prevMsg = null;
// 將隊列中到頭部消息賦值給 msg
Message msg = mMessages;
if (msg != null && msg.target == null) {
// msg 不為空，但是這個 msg 沒有 handler次坡，則這個 msg 為柵欄
// 開始遍歷呼猪，指到獲取第一個異步消息
do {
prevMsg = msg;
msg = msg.next;
} while (msg != null && !msg.isAsynchronous());
}
if (msg != null) {
// 如果當(dāng)前時間不到 msg 的觸發(fā)時間，則計算時間差砸琅，設(shè)置阻塞超時時長
if (now < msg.when) {
// Next message is not ready. Set a timeout to wake up when it is ready.
nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
} else {
// 當(dāng)前時間到了 msg 的觸發(fā)時間宋距，則獲取消息并返回
mBlocked = false;
// 如果當(dāng)前的 msg 不是頭部消息，則上一條消息的 next 指向 msg 的 next
if (prevMsg != null) {
prevMsg.next = msg.next;
} else {
// 當(dāng)前 msg 為頭部消息明棍，則將下一個 msg 設(shè)置為頭部消息
mMessages = msg.next;
}
// msg 的下一個 Message 對象置空乡革，表示從消息隊列中取出來了這條 msg
msg.next = null;
if (DEBUG) Log.v(TAG, "Returning message: " + msg);
// 標(biāo)記 msg 正在使用
msg.markInUse();
return msg;
}
} else {
// 如果沒有消息，則設(shè)置阻塞時長為 -1，直到被喚醒
nextPollTimeoutMillis = -1;
}
// 所有的消息都被處理后沸版，判斷是否退出嘁傀，并返回 null。
if (mQuitting) {
dispose();
return null;
}
// If first time idle, then get the number of idlers to run.
// Idle handles only run if the queue is empty or if the first message
// in the queue (possibly a barrier) is due to be handled in the future.
// 第一次循環(huán)時视粮，消息隊列為空细办，或 當(dāng)前時間未到消息的觸發(fā)時間，獲取 IdleHandler 的數(shù)量
if (pendingIdleHandlerCount < 0
&& (mMessages == null || now < mMessages.when)) {
pendingIdleHandlerCount = mIdleHandlers.size();
}
// pendingIdleHandlerCount 的數(shù)量為 0 時蕾殴，線程會繼續(xù)堵塞
if (pendingIdleHandlerCount <= 0) {
// No idle handlers to run. Loop and wait some more.
mBlocked = true;
continue;
}
// 判斷當(dāng)前空閑時處理任務(wù)的handler是否是為空笑撞，如果為空，就實例化出新的對象
if (mPendingIdleHandlers == null) {
mPendingIdleHandlers = new IdleHandler[Math.max(pendingIdleHandlerCount, 4)];
}
mPendingIdleHandlers = mIdleHandlers.toArray(mPendingIdleHandlers);
}
// 運行 IdleHandler钓觉，只有第一次循環(huán)時才會運行
for (int i = 0; i < pendingIdleHandlerCount; i++) {
final IdleHandler idler = mPendingIdleHandlers[i];
// 釋放 IdleHandler 的引用
mPendingIdleHandlers[i] = null;
boolean keep = false;
try {
// 執(zhí)行 IdleHandler 的方法
keep = idler.queueIdle();
} catch (Throwable t) {
Log.wtf(TAG, "IdleHandler threw exception", t);
}
if (!keep) {
synchronized (this) {
mIdleHandlers.remove(idler);
}
}
}
// 重置 IdleHandler 的數(shù)量為 0茴肥，確保不會重復(fù)運行它們
pendingIdleHandlerCount = 0;
// 在執(zhí)行 IdleHandler 時，一個新的消息可能插入或消息隊列中的消息到了觸發(fā)時間
// 所以將 nextPollTimeoutMillis 設(shè)為 0荡灾，表示不需要阻塞瓤狐，重新檢查消息隊列。
nextPollTimeoutMillis = 0;
}
}
至此批幌，MessageQueue 的兩個最重要的方法已經(jīng)分析完了础锐，下面來看 Looper 如何循環(huán)地從消息隊列中取出消息。
# 6. Looper 工作原理
在講 Looper 之前荧缘，需要先理解 ThreadLocal 的工作原理
## 6.1）ThreadLocal 的工作原理
ThreadLocal 是一個線程內(nèi)存儲數(shù)據(jù)的類皆警，當(dāng)不同的線程去訪問同一個 ThreadLocal 對象時，獲得的值都是不一樣的截粗，下面用一段代碼來證明
private ThreadLocal<String> mThreadLocal = new ThreadLocal<>();
btn_1 = findViewById(R.id.btn_1);
btn_1.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
new Thread(){
@Override
public void run() {
super.run();
mThreadLocal.set("Thread_A");
Log.d("ThreadLocalValue",mThreadLocal.get());
}
}.start();
new Thread(){
@Override
public void run() {
super.run();
mThreadLocal.set("Thread_B");
Log.d("ThreadLocalValue",mThreadLocal.get());
}
}.start();
}
);
我在兩個線程中分別存入在 mThreadLocal 中存入了不同的值信姓，然后在控制臺輸出它們的內(nèi)容
可見不同線程訪問同一個 ThreadLocal 對象得到的值也是不一樣的。
ThreadLocal 實現(xiàn)這種特性的原因也很簡單桐愉，下面來看它內(nèi)部的 set 方法：
public void set(T value) {
// 獲取當(dāng)前線程 t
Thread t = Thread.currentThread();
// 根據(jù)當(dāng)前線程 t财破，獲取當(dāng)前線程的 ThreadLocalMap 對象
ThreadLocalMap map = getMap(t);
if (map != null)
// map 不為空，調(diào)用 ThreadLocalMap 的 set() 方法从诲。
map.set(this, value);
else
// map 為空，則為當(dāng)前線程創(chuàng)建一個新的 ThreadLocalMap 對象
createMap(t, value);
}
在 set 方法中靡羡，先獲取當(dāng)前線程系洛，然后獲取當(dāng)前線程的 ThreadLocalMap 對象。getMap() 的 和 createMap() 的實現(xiàn)如下：
ThreadLocalMap getMap(Thread t) {
return t.threadLocals;
}
void createMap(Thread t, T firstValue) {
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
那么 ThreadLocalMap 又是什么呢略步，這里是它的一部分源碼：
static class ThreadLocalMap {
static class Entry extends WeakReference<ThreadLocal<?>> {
/** The value associated with this ThreadLocal. */
Object value;
Entry(ThreadLocal<?> k, Object v) {
super(k);
value = v;
}
}
// 初始的 table 容量
private static final int INITIAL_CAPACITY = 16;
// Entry 數(shù)組用于存儲數(shù)據(jù)
private Entry[] table;
// table 的大小
private int size = 0;
// 負(fù)載因子描扯，用于擴容
private int threshold; // Default to 0
// 設(shè)置負(fù)載因子為當(dāng)然容量大小的 2 / 3
private void setThreshold(int len) {
threshold = len * 2 / 3;
}
// 初始化 Entry 數(shù)組
ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
table = new Entry[INITIAL_CAPACITY];
int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
table[i] = new Entry(firstKey, firstValue);
size = 1;
setThreshold(INITIAL_CAPACITY);
}
}
可以將 ThreadLocalMap 當(dāng)作一個哈希表，它的內(nèi)部用 Entry 存儲相應(yīng)的數(shù)據(jù)趟薄。
在 Thread 的屬性中有 ThreadLocal.ThreadLocalMap threadLocals = null;绽诚，所以每一個線程內(nèi)部，都持有一個 ThreadLocalMap 對象，系統(tǒng)才可以通過 getMap() 方法獲取當(dāng)前線程的 ThreadLocalMap 對象恩够。
在 ThreadLocal 中調(diào)用 set 方法卒落，實際上會調(diào)用 ThreadLocalMap 中的 set 方法，源碼如下：
// ThreadLocalMap 的 set 方法
private void set(ThreadLocal<?> key, Object value) {
// We don't use a fast path as with get() because it is at
// least as common to use set() to create new entries as
// it is to replace existing ones, in which case, a fast
// path would fail more often than not.
// 首先獲取當(dāng)前 ThreadLocal 對象的 table 屬性蜂桶，table 一個 Entry 的數(shù)組
// Entry 相當(dāng)于一個 HashMap儡毕，存儲了當(dāng)前 ThreadLocal 對象和 Object 類型的 value 對象
Entry[] tab = table;
int len = tab.length;
// 計算出存儲的位置
int i = key.threadLocalHashCode & (len-1);
// 遍歷 tab
for (Entry e = tab[i];
e != null;
e = tab[i = nextIndex(i, len)]) {
ThreadLocal<?> k = e.get();
// 如果 tab 中已經(jīng)存在了相同的 key 值，就覆蓋它原有的 value
if (k == key) {
e.value = value;
return;
}
// 如果 當(dāng)前 entrt 的 key 為 null扑媚，調(diào)用 replaceStaleEntry 方法清楚所有 key 為 null 的數(shù)據(jù)
if (k == null) {
replaceStaleEntry(key, value, i);
return;
}
}
// 都不滿足腰湾，就新建一個 Entry 對象
tab[i] = new Entry(key, value);
int sz = ++size;
// ThreadLocalMap 的容量到達閥值后擴容
if (!cleanSomeSlots(i, sz) && sz >= threshold)
rehash();
}
ThreadLocal 中的 get() 方法和 set() 方法一樣，都是對 Thread 中對 ThreadLocalMap 進行操作
public T get() {
// 獲取當(dāng)前線程
Thread t = Thread.currentThread();
// 獲取當(dāng)前線程的 ThreadLocalMap 對象
ThreadLocalMap map = getMap(t);
if (map != null) {
// 獲取 ThreadLocalMap 中對應(yīng)當(dāng)前線程的 Entry 對象
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null) {
@SuppressWarnings("unchecked")
// 將 Entry 對象中的 value 取出來
T result = (T)e.value;
return result;
}
}
return setInitialValue();
}
private Entry getEntry(ThreadLocal<?> key) {
int i = key.threadLocalHashCode & (table.length - 1);
Entry e = table[i];
if (e != null && e.get() == key)
return e;
else
return getEntryAfterMiss(key, i, e);
}
## 6.2）Looper 中的 prepare() 方法
那么 ThreadLocal 和 Looper 有什么關(guān)系呢疆股？我們知道每一個線程都有自己的 Looper费坊，Looper 的作用域就是當(dāng)前的線程，Android 系統(tǒng)中便通過 ThreadLocal 對象來存儲不同線程中的 Looper旬痹。
Looper 中 prepare() 方法為當(dāng)前線程創(chuàng)建一個 Looper 對象附井，我們看一下它的實現(xiàn)：
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");
}
// 將 Looper 對象保存到當(dāng)前線程的 ThreadLocalMap 當(dāng)中
sThreadLocal.set(new Looper(quitAllowed));
}
這里再看一下 Looper 的構(gòu)造方法
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
可以看到在一個 Looper 中創(chuàng)建了一個 MessageQueue，這里我們就可以搞清楚 Handler唱凯、Looper 和 MessageQueue 的對應(yīng)關(guān)系了：
每個線程都有一個 Looper 對象羡忘，在 Looper 對象的初始化過程中，會為當(dāng)前線程創(chuàng)建一個 MessageQueue磕昼，而一個線程中可以有多個 Handler卷雕。
## 6.3）Looper 中的 loop() 方法：
prepare() 調(diào)用后，就是調(diào)用 loop() 方法：
/**
* Run the message queue in this thread. Be sure to call
* {@link #quit()} to end the loop.
*/
public static void loop() {
// 通過 Thread Local 獲取當(dāng)前線程的 Looper
final Looper me = myLooper();
if (me == null) {
throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
}
// 獲取當(dāng)前 Looper 對象的 MessageQueue
final MessageQueue queue = me.mQueue;
// 清空遠(yuǎn)程調(diào)用端進程的身份票从，確保此線程的身份是本地進程的身份漫雕，并跟蹤該身份令牌
// 這里主要用于保證消息處理是發(fā)生在當(dāng)前 Looper 所在的線程
Binder.clearCallingIdentity();
final long ident = Binder.clearCallingIdentity();
for (;;) {
// 取出來下一條消息
Message msg = queue.next(); // might block
if (msg == null) {
// No message indicates that the message queue is quitting.
return;
}
// 用 logging 打印日志，默認(rèn)為 null峰鄙，可通過 setMessageLogging() 方法來指定
final Printer logging = me.mLogging;
if (logging != null) {
logging.println(">>>>> Dispatching to " + msg.target + " " +
msg.callback + ": " + msg.what);
}
// 開始跟蹤浸间，并寫入跟蹤消息，用于 debug 功能
final long traceTag = me.mTraceTag;
if (traceTag != 0 && Trace.isTagEnabled(traceTag)) {
Trace.traceBegin(traceTag, msg.target.getTraceName(msg));
}
...
...
try {
// // 通過 Handler 分發(fā)消息
msg.target.dispatchMessage(msg);
dispatchEnd = needEndTime ? SystemClock.uptimeMillis() : 0;
} finally {
if (traceTag != 0) {
// 停止跟蹤
Trace.traceEnd(traceTag);
}
}
if (logSlowDispatch) {
showSlowLog(slowDispatchThresholdMs, dispatchStart, dispatchEnd, "dispatch", msg);
}
if (logging != null) {
logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
}
// 確保在分發(fā)消息的過程中線程的身份沒有改變
final long newIdent = Binder.clearCallingIdentity();
if (ident != newIdent) {
Log.wtf(TAG, "Thread identity changed from 0x"
+ Long.toHexString(ident) + " to 0x"
+ Long.toHexString(newIdent) + " while dispatching to "
+ msg.target.getClass().getName() + " "
+ msg.callback + " what=" + msg.what);
}
// 回收消息吟榴，并把消息放入消息池
msg.recycleUnchecked();
}
}
可以看到 loop() 方法就是不停的遍歷消息隊列中的消息魁蒜，當(dāng)發(fā)現(xiàn)有新的消息時，便調(diào)用 Handler 的 dispatchMessage() 方法吩翻。
## 6.4）getMainLooper()
public static void prepareMainLooper() {
prepare(false);
synchronized (Looper.class) {
if (sMainLooper != null) {
throw new IllegalStateException("The main Looper has already been prepared.");
}
sMainLooper = myLooper();
}
}
/**
* Returns the application's main looper, which lives in the main thread of the application.
*/
public static Looper getMainLooper() {
synchronized (Looper.class) {
return sMainLooper;
}
}
getMainLooper() 方法用于返回當(dāng)前 UI 線程的 Looper兜看，UI 線程的 Looper 在 ActivityThread 的建立時通過調(diào)用
prepareMainLooper() 方法創(chuàng)建。
## 6.5）quit() 和 quitSafely()
在子線程中狭瞎，如果手動為其創(chuàng)建了Looper细移，那么在所有消息處理完成之后應(yīng)該調(diào)用 quit() 方法終止消息循環(huán)，不然 Looper 就會一直處于等待狀態(tài)熊锭。
public void quitSafely() {
mQueue.quit(true);
}
public void quit() {
mQueue.quit(false);
}
可以看到這兩個方法都調(diào)用了 MessageQueue 中都 quit(boolean safe) 方法弧轧，quitSafely 的參數(shù)為 true雪侥，quit 的參數(shù)為 false。
void quit(boolean safe) {
// 主線程不退出消息循環(huán)
if (!mQuitAllowed) {
throw new IllegalStateException("Main thread not allowed to quit.");
}
synchronized (this) {
// 如果已經(jīng)退出了精绎，直接 return
if (mQuitting) {
return;
}
// 標(biāo)記為已經(jīng)退出
mQuitting = true;
// 如果 safe 的值為 true速缨，執(zhí)行完當(dāng)前的消息后退出消息循環(huán)
if (safe) {
removeAllFutureMessagesLocked();
} else {
// 直接退出消息循環(huán)
removeAllMessagesLocked();
}
// We can assume mPtr != 0 because mQuitting was previously false.
nativeWake(mPtr);
}
}
quitSafely() 會等待當(dāng)前消息執(zhí)行完畢后退出消息循環(huán)，而 quit() 方法會直接退出消息循環(huán)捺典。
private void removeAllMessagesLocked() {
// 獲取當(dāng)前 MessageQueue 的頭部消息
Message p = mMessages;
while (p != null) {
// 循環(huán)遍歷所有的 Message
Message n = p.next;
// 回收消息鸟廓，并把消息放入消息池
p.recycleUnchecked();
p = n;
}
// 將頭部消息置為空
mMessages = null;
}
private void removeAllFutureMessagesLocked() {
// 獲取系統(tǒng)從開機到現(xiàn)在到時間
final long now = SystemClock.uptimeMillis();
// 將當(dāng)前的頭部消息賦值給 p
Message p = mMessages;
if (p != null) {
if (p.when > now) {
// 如果當(dāng)前頭部消息將要執(zhí)行的時間大于系統(tǒng)開機到現(xiàn)在的時間，則執(zhí)行 removeAllMessagesLocked() 方法
// 清空 MessageQueue 隊列
removeAllMessagesLocked();
} else {
Message n;
// 遍歷當(dāng)前的 MessageQueue襟己，直到某個消息的執(zhí)行時間小于 now 值（即這個消息正在執(zhí)行）
// 將這個消息的 next 賦值為 null
for (;;) {
n = p.next;
if (n == null) {
return;
}
if (n.when > now) {
break;
}
p = n;
}
p.next = null;
// 回收不會被執(zhí)行的 Message
do {
p = n;
n = p.next;
p.recycleUnchecked();
} while (n != null);
}
}
}
終于講完了引谜，希望大家能通過我的文章，徹底理解 Handler 的機制擎浴，但我的能力有限员咽，如果存在錯誤的地方，還請指出贮预。
零碎的東西很多贝室，為了方便大家記憶，我把上面的內(nèi)容做成了思維導(dǎo)圖仿吞，需要的朋友可以保存下來滑频，偶爾看一下，幫助自己記憶唤冈。
歡迎關(guān)注本文作者：
掃碼關(guān)注并回復(fù)「干貨」峡迷，獲取我整理的千G Android、iOS你虹、JavaWeb绘搞、大數(shù)據(jù)、人工智能等學(xué)習(xí)資源傅物。
