我們在日常開發(fā)中贡这，總是不可避免的會用到 Handler，雖說 Handler 機制并不等同于 Android 的消息機制银亲，但 Handler 的消息機制在 Android 開發(fā)中早已諳熟于心慢叨，非常重要！
通過本文务蝠，你可以非常容易得到一下問題的答案：
- Handler拍谐、Looper、Message 和 MessageQueue 的原理以及它們之間的關(guān)系到底是怎樣的馏段？
- MessageQueue 存儲結(jié)構(gòu)是什么轩拨？
- 子線程為啥一定要調(diào)用 Looper.prepare() 和 Looper.loop()?
Handler 的簡單使用
相信應(yīng)該沒有人不會使用 Handler 吧？假設(shè)在 Activity 中處理一個耗時任務(wù)院喜，需要更新 UI亡蓉，簡單看看我們平時是怎么處理的。
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main3)
// 請求網(wǎng)絡(luò)
subThread.start()
}
override fun onDestroy() {
subThread.interrupt()
super.onDestroy()
}
private val handler by lazy(LazyThreadSafetyMode.NONE) { MyHandler() }
private val subThread by lazy(LazyThreadSafetyMode.NONE) { SubThread(handler) }
private class MyHandler : Handler() {
override fun handleMessage(msg: Message) {
super.handleMessage(msg)
// 主線程處理邏輯喷舀，一般這里需要使用弱引用持有 Activity 實例砍濒，以免內(nèi)存泄漏
}
}
private class SubThread(val handler: Handler) : Thread() {
override fun run() {
super.run()
// 耗時操作 比如做網(wǎng)絡(luò)請求
// 網(wǎng)絡(luò)請求完畢淋肾，咱們就得嘩嘩嘩通知 UI 刷新了，直接直接考慮 Handler 處理爸邢，其他方案暫時不做考慮
// 第一種方法樊卓，一般這個 data 是請求結(jié)果解析的內(nèi)容
handler.obtainMessage(1,data).sendToTarget()
// 第二種方法
val message = Message.obtain() // 盡量使用 Message.obtain() 初始化
message.what = 1
message.obj = data // 一般這個 data 是請求結(jié)果解析的內(nèi)容
handler.sendMessage(message)
// 第三種方法
handler.post(object : Thread() {
override fun run() {
super.run()
// 處理更新操作
}
})
}
}
上述代碼非常簡單，因為網(wǎng)絡(luò)請求是一個耗時任務(wù)杠河，所以我們新開了一個線程碌尔，并在網(wǎng)絡(luò)請求結(jié)束解析完畢后通過 Handler 來通知主線程去更新 UI，簡單采用了 3 種方式感猛，細心的小伙伴可能會發(fā)現(xiàn)七扰，其實第一種和第二種方法是一樣的。就是利用 Handler 來發(fā)送了一個攜帶了內(nèi)容 Message 對象陪白，值得一提的是：我們應(yīng)該盡可能地使用 Message.obtain() 而不是 new Message() 進行 Message 的初始化颈走，主要是 Message.obtain() 可以減少內(nèi)存的申請。
受到大家在前面文章提出的建議咱士，我們就盡量地少貼一些源碼了立由，大家可以直接很容易發(fā)現(xiàn)，上述的所有方法最終都會調(diào)用這個方法：
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);
}
上面的代碼出現(xiàn)了一個 MessageQueue序厉，并且最終調(diào)用了 MessageQueue#enqueueMessage 方法進行消息的入隊锐膜，我們不得不簡單說一下 MessageQueue 的基本情況。
MessageQueue
顧名思義弛房，MessageQueue 就是消息隊列道盏，即存放多條消息 Message 的容器，它采用的是單向鏈表數(shù)據(jù)結(jié)構(gòu)文捶，而非隊列荷逞。它的 next() 指向鏈表的下一個 Message 元素。
boolean enqueueMessage(Message msg, long when) {
// ... 省略一些檢查代碼
synchronized (this) {
// ... 省略一些檢查代碼
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;
}
從入隊消息 enqueueMessage() 的實現(xiàn)來看粹排，它的主要操作其實就是單鏈表的插入操作种远，這里就不做過多的解釋了，我們可能應(yīng)該更多的關(guān)心它的出隊操作方法 next()：
Message next() {
// ...
int nextPollTimeoutMillis = 0;
for (;;) {
// ...
nativePollOnce(ptr, nextPollTimeoutMillis);
synchronized (this) {
// Try to retrieve the next message. Return if found.
final long now = SystemClock.uptimeMillis();
Message prevMsg = null;
Message msg = mMessages;
if (msg != null && msg.target == null) {
// Stalled by a barrier. Find the next asynchronous message in the queue.
do {
prevMsg = msg;
msg = msg.next;
} while (msg != null && !msg.isAsynchronous());
}
if (msg != null) {
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 {
// Got a message.
mBlocked = false;
if (prevMsg != null) {
prevMsg.next = msg.next;
} else {
mMessages = msg.next;
}
msg.next = null;
if (DEBUG) Log.v(TAG, "Returning message: " + msg);
msg.markInUse();
return msg;
}
} else {
// No more messages.
nextPollTimeoutMillis = -1;
}
//...
}
//...
// While calling an idle handler, a new message could have been delivered
// so go back and look again for a pending message without waiting.
nextPollTimeoutMillis = 0;
}
}
next() 方法其實很長顽耳，不過我們僅僅貼了極少的一部分坠敷，可以看到，里面不過是有一個 for (;;) 的無限循環(huán)射富，循環(huán)體內(nèi)部調(diào)用了一個 nativePollOnce(long, int) 方法膝迎。這是一個 Native 方法，實際作用是通過 Native 層的 MessageQueue 阻塞當前調(diào)用棧線程 nextPollTimeoutMillis 毫秒的時間胰耗。
下面是 nextPollTimeoutMillis 取值的不同情況的阻塞表現(xiàn)：
- 小于 0弄抬，一直阻塞，直到被喚醒宪郊；
- 等于 0掂恕，不會阻塞；
- 大于 0懊亡，最長阻塞 nextPollTimeoutMillis 毫秒依啰，期間如被喚醒會立即返回。
可以看到速警，最開始 nextPollTimeoutMillis 的初始化值是 0，所以不會阻塞，會直接去取 Message 對象帅韧，如果沒有取到 Message 對象數(shù)據(jù)，則直接會把 nextPollTimeoutMillis 置為 -1哑诊，此時滿足小于 0 的條件，會被一直阻塞，直到其他地方調(diào)用另外一個 Native 方法 nativeWake(long) 進行喚醒。如果取到值的話比驻，會直接把得到的 Message 對象進行返回夫椭。
原來陪竿，nativeWake(long) 方法在前面的 MessageQueue#enqueueMessage 方法有個調(diào)用禽翼，調(diào)用時機是在 MessageQueue 入隊消息的過程中。
現(xiàn)在已經(jīng)知道：Handler 發(fā)送了 Message族跛，消息用 MessageQueue 進行存儲闰挡，使用 MessageQueue#enqueueMessage 方法進行入隊，使用 MessageQueue#next 方法進行輪訓(xùn)消息礁哄。這就不免拋出了一個問題长酗，MessageQueue#next 方法是誰調(diào)用的？沒錯桐绒，就是 Looper夺脾。
Looper
Looper 在 Android 的消息機制中扮演著消息循環(huán)的角色，具體來說就是它會不停地從 MessageQueue 通過 next() 查看是否有新消息茉继，如果有新消息就立刻處理咧叭，否則就任由 MessageQueue 阻塞在那里。
我們直接看看 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.");
}
// ...
for (;;) {
Message msg = queue.next(); // might block
if (msg == null) {
// No message indicates that the message queue is quitting.
return;
}
//...
try {
// 分發(fā)消息給 handler 處理
msg.target.dispatchMessage(msg);
dispatchEnd = needEndTime ? SystemClock.uptimeMillis() : 0;
} finally {
// ...
}
// ...
}
}
方法省去了大量的代碼烁竭，只保留了核心邏輯菲茬。可以看到，首先會通過 myLooper() 方法得到 Looper 對象婉弹，如果這個 Looper 返回為空的話睬魂，則直接拋出異常。否則進入到一個 for (;;) 循環(huán)中镀赌，調(diào)用 MessageQueue#next() 方法進行輪訓(xùn)獲取 Message 對象汉买，如果獲取的 Message 對象為空，則直接退出 loop() 方法佩脊。否則直接通過 msg.target 拿到 Handler 對象蛙粘，并調(diào)用 Handler#dispatchMessage() 方法。
我們先來看看Handler#dispatchMessage() 方法實現(xiàn)：
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
private static void handleCallback(Message message) {
message.callback.run();
}
代碼比較簡單威彰，如果 Message 設(shè)置了 callback 則出牧，直接調(diào)用 message.callback.run()，否則判斷是否初始化了 `m
再來看看 myLooper() 方法：
public static @Nullable Looper myLooper() {
return sThreadLocal.get();
}
看看 sThreadLocal 是什么：
static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
這個 ThreadLocal 是什么呢歇盼？
ThreadLocal
關(guān)于 ThreadLocal舔痕，我們直接采取 嚴振杰文章 中的內(nèi)容。
看到 ThreadLocal 的第一感覺就是該類和線程有關(guān)豹缀，確實如此伯复，但是要注意它不是線程，否則它就該叫 LocalThread 了邢笙。
ThreadLocal 是用來存儲指定線程的數(shù)據(jù)的啸如，當某些數(shù)據(jù)的作用域是該指定線程并且該數(shù)據(jù)需要貫穿該線程的所有執(zhí)行過程時就可以使用 ThreadnLocal 存儲數(shù)據(jù)，當某線程使用 ThreadnLocal 存儲數(shù)據(jù)后氮惯，只有該線程可以讀取到存儲的數(shù)據(jù)叮雳，除此線程之外的其他線程是沒辦法讀取到該數(shù)據(jù)的。
一些讀者看完上面這段話應(yīng)該還是不理解 ThreadLocal 的作用妇汗，我們舉個栗子：
ThreadLocal<Boolean> local = new ThreadLocal<>();
// 設(shè)置初始值為true.
local.set(true);
Boolean bool = local.get();
Logger.i("MainThread讀取的值為：" + bool);
new Thread() {
@Override
public void run() {
Boolean bool = local.get();
Logger.i("SubThread讀取的值為：" + bool);
// 設(shè)置值為false.
local.set(false);
}
}.start():
// 主線程睡1秒帘不，確保上方子線程執(zhí)行完畢再執(zhí)行下面的代碼。
Thread.sleep(1000);
Boolean newBool = local.get();
Logger.i("MainThread讀取的新值為：" + newBool);
代碼沒什么好說的吧杨箭，打印出來的日志寞焙，你會看到是這樣的：
MainThread讀取的值為：trueSubThread讀取的值為：nullMainThread讀取的值為：true
第一條 Log 無可置疑，因為設(shè)置了值為 true互婿，因為打印結(jié)果沒什么好說的捣郊。對于第二條 Log，根據(jù)上方介紹擒悬，某線程使用 ThreadLocal 存儲的數(shù)據(jù)模她，只能被該線程讀取稻艰，因此第二條 Log 的結(jié)果是：null懂牧。緊接著在子線程中設(shè)置了 ThreadLocal 的值為 false，然后第三條 Log 將被打印，原理同上僧凤，子線程中設(shè)置了 ThreadLocal 的值并不影響主線程的數(shù)據(jù)畜侦，所以打印是 true。
實驗結(jié)果證實：就算是同一個 ThreadLocal 對象躯保，任一線程對其的 set() 和 get() 方法的操作都是相互獨立互不影響的旋膳。
Looper.myLooper()
我們回到 Looper.myLooper()：
static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
我們看看是在哪兒對 sThreadLocal 操作的。
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));
}
所以知道了吧途事，這就是在子線程中使用 Handler 前验懊，必須要調(diào)用 Looper.prepare() 的原因。
可能你會疑問尸变，我在主線程使用的時候义图，沒有要求 Looper.prepare() 呀。
原來召烂，我們在 ActivityThread 中碱工，有去顯示調(diào)用 Looper.prepareMainLooper()：
public static void main(String[] args) {
// ...
Looper.prepareMainLooper();
// ...
if (sMainThreadHandler == null) {
sMainThreadHandler = thread.getHandler();
}
//...
Looper.loop();
// ...
}
我們看看 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();
}
}
最后
給大家分享一份移動架構(gòu)大綱，包含了移動架構(gòu)師需要掌握的所有的技術(shù)體系奏夫，大家可以對比一下自己不足或者欠缺的地方有方向的去學習提升怕篷；
需要高清架構(gòu)圖以及圖中視頻資料和文章項目源碼的可以加入我的技術(shù)交流群：825106898私聊群主小姐姐免費獲取
