堅持原創日更，短平快的 Android 進階系列，敬請直接在微信公眾號搜尋：nanchen，直接關注並設為星標，精彩不容錯過。

我 17 年的 面試系列，曾寫過一篇名為：Android 面試（五）：探索 Android 的 Handler 的文章，主要講述的是 Handler 的原理相關面試題，然後簡單地給與了一些結論。沒想到兩年過去，我又開啟了 面試系列 的翻版 每日一問 專題，而這一次的捲土重來，只是為了通過原始碼來探知我們平時可能忽略掉的細節。

我們在日常開發中，總是不可避免的會用到 Handler，雖說 Handler 機制並不等同於 Android 的訊息機制，但 Handler 的訊息機制在 Android 開發中早已諳熟於心，非常重要！

通過本文，你可以非常容易得到一下問題的答案：

1. Handler、Looper、Message 和 MessageQueue 的原理以及它們之間的關係到底是怎樣的？
2. MessageQueue 儲存結構是什麼？
3. 子執行緒為啥一定要呼叫 Looper.prepare() 和 Looper.loop()?

Handler 的簡單使用

相信應該沒有人不會使用 Handler 吧？假設在 Activity 中處理一個耗時任務，需要更新 UI，簡單看看我們平時是怎麼處理的。

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main3)
    // 請求網路
    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 例項，以免記憶體洩漏
    }
}

private class SubThread(val handler: Handler) : Thread() {
    override fun run() {
        super.run()
        // 耗時操作 比如做網路請求

        // 網路請求完畢，咱們就得嘩嘩譁通知 UI 重新整理了，直接直接考慮 Handler 處理，其他方案暫時不做考慮
        // 第一種方法，一般這個 data 是請求結果解析的內容
        handler.obtainMessage(1,data).sendToTarget()
        // 第二種方法
        val message = Message.obtain() // 儘量使用 Message.obtain() 初始化
        message.what = 1
        message.obj = data // 一般這個 data 是請求結果解析的內容
        handler.sendMessage(message)
        // 第三種方法
        handler.post(object : Thread() {
            override fun run() {
                super.run()
                // 處理更新操作
            }
        })
    }
}
 

上述程式碼非常簡單，因為網路請求是一個耗時任務，所以我們新開了一個執行緒，並在網路請求結束解析完畢後通過 Handler 來通知主執行緒去更新 UI，簡單採用了 3 種方式，細心的小夥伴可能會發現，其實第一種和第二種方法是一樣的。就是利用 Handler 來發送了一個攜帶了內容 Message 物件，值得一提的是：我們應該儘可能地使用 Message.obtain() 而不是 new Message() 進行 Message 的初始化，主要是 Message.obtain() 可以減少記憶體的申請。

受到大家在前面文章提出的建議，我們就儘量地少貼一些原始碼了，大家可以直接很容易發現，上述的所有方法最終都會呼叫這個方法：

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);
}

上面的程式碼出現了一個 MessageQueue，並且最終呼叫了 MessageQueue#enqueueMessage 方法進行訊息的入隊，我們不得不簡單說一下 MessageQueue 的基本情況。

MessageQueue

顧名思義，MessageQueue 就是訊息佇列，即存放多條訊息 Message 的容器，它採用的是單向連結串列資料結構，而非佇列。它的 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() 的實現來看，它的主要操作其實就是單鏈表的插入操作，這裡就不做過多的解釋了，我們可能應該更多的關心它的出隊操作方法 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 (;;) 的無限迴圈，迴圈體內部呼叫了一個 nativePollOnce(long, int) 方法。這是一個 Native 方法，實際作用是通過 Native 層的 MessageQueue 阻塞當前呼叫棧執行緒 nextPollTimeoutMillis 毫秒的時間。

下面是 nextPollTimeoutMillis 取值的不同情況的阻塞表現：

1. 小於 0，一直阻塞，直到被喚醒；
2. 等於 0，不會阻塞；
3. 大於 0，最長阻塞 nextPollTimeoutMillis 毫秒，期間如被喚醒會立即返回。

可以看到，最開始 nextPollTimeoutMillis 的初始化值是 0，所以不會阻塞，會直接去取 Message 物件，如果沒有取到 Message 物件資料，則直接會把 nextPollTimeoutMillis 置為 -1，此時滿足小於 0 的條件，會被一直阻塞，直到其他地方呼叫另外一個 Native 方法 nativeWake(long) 進行喚醒。如果取到值的話，會直接把得到的 Message 物件進行返回。

原來，nativeWake(long) 方法在前面的 MessageQueue#enqueueMessage 方法有個呼叫，呼叫時機是在 MessageQueue 入隊訊息的過程中。

現在已經知道：Handler 傳送了 Message，訊息用 MessageQueue 進行儲存，使用 MessageQueue#enqueueMessage 方法進行入隊，使用 MessageQueue#next 方法進行輪訓訊息。這就不免丟擲了一個問題，MessageQueue#next 方法是誰呼叫的？沒錯，就是 Looper。

Looper

Looper 在 Android 的訊息機制中扮演著訊息迴圈的角色，具體來說就是它會不停地從 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 {
            // 分發訊息給 handler 處理
            msg.target.dispatchMessage(msg);
            dispatchEnd = needEndTime ? SystemClock.uptimeMillis() : 0;
        } finally {
            // ...
        }
        // ...
    }
}

方法省去了大量的程式碼，只保留了核心邏輯。可以看到，首先會通過 myLooper() 方法得到 Looper 物件，如果這個 Looper 返回為空的話，則直接丟擲異常。否則進入到一個 for (;;) 迴圈中，呼叫 MessageQueue#next() 方法進行輪訓獲取 Message 物件，如果獲取的 Message 物件為空，則直接退出 loop() 方法。否則直接通過 msg.target 拿到 Handler 物件，並呼叫 Handler#dispatchMessage() 方法。

我們先來看看Handler#dispatchMessage() 方法實現：

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 設定了 callback 則，直接呼叫 message.callback.run()，否則判斷是否初始化了 `m

再來看看 myLooper() 方法：

public static @Nullable Looper myLooper() {
    return sThreadLocal.get();
}

看看 sThreadLocal 是什麼：

static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();

這個 ThreadLocal 是什麼呢？

ThreadLocal

關於 ThreadLocal，我們直接採取 嚴振杰文章 中的內容。
看到 ThreadLocal 的第一感覺就是該類和執行緒有關，確實如此，但是要注意它不是執行緒，否則它就該叫 LocalThread 了。

ThreadLocal 是用來儲存指定執行緒的資料的，當某些資料的作用域是該指定執行緒並且該資料需要貫穿該執行緒的所有執行過程時就可以使用 ThreadnLocal 儲存資料，當某執行緒使用 ThreadnLocal 儲存資料後，只有該執行緒可以讀取到儲存的資料，除此執行緒之外的其他執行緒是沒辦法讀取到該資料的。

一些讀者看完上面這段話應該還是不理解 ThreadLocal 的作用，我們舉個栗子：

ThreadLocal<Boolean> local = new ThreadLocal<>();
// 設定初始值為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);

        // 設定值為false.
        local.set(false);
    }
}.start():

// 主執行緒睡1秒，確保上方子執行緒執行完畢再執行下面的程式碼。
Thread.sleep(1000);

Boolean newBool = local.get();
Logger.i("MainThread讀取的新值為：" + newBool);

程式碼沒什麼好說的吧，打印出來的日誌，你會看到是這樣的：

MainThread讀取的值為：true
SubThread讀取的值為：null
MainThread讀取的值為：true

第一條 Log 無可置疑，因為設定了值為 true，因為列印結果沒什麼好說的。對於第二條 Log，根據上方介紹，某執行緒使用 ThreadLocal 儲存的資料，只能被該執行緒讀取，因此第二條 Log 的結果是：null。緊接著在子執行緒中設定了 ThreadLocal 的值為 false，然後第三條 Log 將被列印，原理同上，子執行緒中設定了 ThreadLocal 的值並不影響主執行緒的資料，所以列印是 true。

實驗結果證實：就算是同一個 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 前，必須要呼叫 Looper.prepare() 的原因。

可能你會疑問，我在主執行緒使用的時候，沒有要求 Looper.prepare() 呀。

原來，我們在 ActivityThread 中，有去顯示呼叫 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();
    }
}

本文參考了：
《Android 開發藝術探索》
Android訊息機制和應