boolean enqueueMessage(Message msg, long when) {
        // 判斷有沒有 target 
        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;
            // 第一次新增資料到佇列中，或者當前 msg 的時間小於 mMessages 的時間
            if (p == null || when == 0 || when < p.when) {
                // New head, wake up the event queue if blocked.
                // 把當前 msg 新增到連結串列的第一個
                msg.next = p;
                mMessages = msg;
                needWake = mBlocked;
            } else {
                // 不是第一次新增資料，並且 msg 的時間 大於 mMessages(頭指標) 的時間
                // 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 插入到列表中
                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;
    }
 

第一次進來的時候Mseeage  p= null； msg.next = p--->msg.next = null; mMessage = msg; 目前為止沒有看到handler去呼叫handleMessage（）的方法，目前只是看到messequeue吧訊息給了mMessage


總結，handler.sendMeassage其實將message加入到訊息佇列，佇列採用連結串列的方式，按照when進行時間排序

為什麼訊息佇列要採用連結串列的方式儲存來儲存message？

連結串列的要實現手拉手的資料結構，那麼連結串列中的每一個元素肯定知道他的上一個節點元素和下一個節點元素分別是誰，在java中，弱化了指標的概念，因此，每一個節點元素持有上一個節點元素和下一個節點元素的物件的引用。也就是說，每一個節點物件應該有3個屬性：1，value值；  2，上一個節點的引用；  3，下一個節點的引用。這三個屬性是連結串列資料結構的核心，有了這三個屬性，基本雛形就已經完成了。接下來，我們在每次新增或者刪除或者插入一個新的節點的時候，只需要做2件事情：1，將前一個節點的next引用改變；2，將後一個節點的last引用改變。所以同陣列相比，連結串列增刪比較快

Loop訊息迴圈

new Thread(){
    @Override
    public void run() {
        Looper.prepare();
        Handler handler = new Handler();
        Looper.loop();
    }
}.start();

子執行緒中使用handler必須先要呼叫Looper.prepare（）。不然會報錯，我們在主執行緒中並沒有呼叫Loop.prepare（）。為什麼不報錯

因為我們應用啟動的時候，activityThread的入口函式main（）方法中已經幫我們寫了這行程式碼 Looper.prepareMainLooper（）//準備迴圈

public static void main(String[] args) {
    // ... 省略部分程式碼
    
    Looper.prepareMainLooper();

    ActivityThread thread = new ActivityThread();
    thread.attach(false);

    if (sMainThreadHandler == null) {
        sMainThreadHandler = thread.getHandler();
    }

    Looper.loop();

    throw new RuntimeException("Main thread loop unexpectedly exited");
}

public static void prepareMainLooper() { prepare(false); synchronized (Looper.class) { if (sMainLooper != null) { throw new IllegalStateException("The main Looper has already been prepared."); } sMainLooper = myLooper(); } } 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)); } public static @Nullable Looper myLooper() { return sThreadLocal.get(); }
sThreadLocal.set(new Looper(quiteAllowed));

Thread t = Thread.currentThread();
//從執行緒中獲取ThreadLocalMap，一個執行緒一個ThreadLocalMap
ThreadLocalMap map = getMap(t);
if(map != null){
map.set(this,value)
}

 總結其實就是保證Thread執行緒中有且只有一個tlooper物件

這些程式碼相對就比較簡單了，主要還是 ThreadLocal 的 set 方法，用來保證一個執行緒只有一個 Looper 物件，這樣就保證了執行緒的安全。接下來看一下 Looper.loop() 這行：

public static void loop() {
    final Looper me = myLooper();
    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;
        }

        try {
            // 通過 target 去 dispatchMessage 而 target 就是繫結的 Handler
            msg.target.dispatchMessage(msg);
        } finally {
            // 訊息回收迴圈利用
            msg.recycleUnchecked();
        }
    }
}