原始碼分析：Android訊息處理機制

Android訊息處理機制主要指的是Handler的執行機制以及它和Looper、MessageQuene協同工作的過程。本篇文章將由淺入深，從原始碼角度分析整體的執行機制。

簡介

Handler 主要是傳送訊息和處理訊息，sendMessage（）和handleMessage()
Handler是Android訊息機制的上層介面，這使得開發者只需要處理和Handler的互動即可。在子執行緒中進行耗時操作，在主執行緒中重新整理UI,這是我們使用Handler的典型案例。 以下就是我們最常見的使用Handler的一種寫法：

public class Activity extends android.app.Activity {
    private Handler mHandler = new Handler(){
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            //  進行重新整理UI的操作
        }
    };
    @Override
    public void onCreate(Bundle savedInstanceState, PersistableBundle persistentState) {
        super.onCreate(savedInstanceState, persistentState);
        setContentView(R.layout.activity_main);
        new Thread(new Runnable() {
            @Override
            public void run() {
                //  在這裡進行耗時操作
                ....
                ....
                Message message = Message.obtain();
                message.what = 1;
                mHandler.sendMessage(message);
            }
        }).start();
    }
}

Message 需要傳遞的訊息

MessageQueue 訊息佇列 每次我們呼叫mHandler.sendMessage(message)後，message都是存在MessageQueue中。MessageQueue只負責儲存訊息，並不能處理訊息，要藉助Looper來實現。

Looper 訊息輪詢器 它會以無限迴圈的方式去MessageQueue中查詢是否有新的訊息，有的話就進行處理，沒有的話就等待。

執行機制

整個機制大致是這樣的：在子執行緒中Handler呼叫了sendMessage()方法後，實際上是呼叫了MessageQueue的enqueueMessage方法，當Looper.loop()執行完後，無限迴圈當前訊息佇列中是否有新訊息 queue.next(),緊接著呼叫了當前Handler物件的dispatchMessage()方法，之後dispatchMessage()方法裡做的操作是呼叫了當前Handler的handleMessage()方法，實現了訊息的分發。

原始碼分析

Handler

 public final boolean sendMessage(Message msg)
    {
        return sendMessageDelayed(msg, 0);
    }
    
    public final boolean sendMessageDelayed(Message msg, long delayMillis)
    {
        if (delayMillis < 0) {
            delayMillis = 0;
        }
        return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
    }
    
    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);
        }
        //  呼叫MessageQueue的enqueueMessage方法
        return queue.enqueueMessage(msg, uptimeMillis);  
    } 

我們可以看到，當我們程式碼執行了mHandler.sendMessage()語句的時候，實際上是呼叫了Handler的enqueueMessage方法，方法內部最終呼叫了MessageQueue的enqueueMessage方法，我們去MessageQueue的enqueueMessage方法看一下：

MessageQueue

boolean enqueueMessage(Message msg, long when) {
        // 判斷target是不是null
        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;
            // 第一次進來新增到訊息列表中，或者當前時間小於message的時間
            if (p == null || when == 0 || when < p.when) {
                msg.next = p;  
                mMessages = msg;
                needWake = mBlocked;
            } else {
                //將訊息按時間順序插入到MessageQueue
                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的程式碼，我們發現，MessageQueue類並沒有對訊息進行處理，僅僅是做了訊息的儲存工作，這也跟我們上面的簡介中的結論一致。

Looper

當我們把訊息存在MessageQueue中，需要Looper去幫助我們不斷地去獲取訊息,通過呼叫Looper.loop()方法去不斷的獲取訊息，先拿到當前looper的MessageQueue的物件，之後無限迴圈去訊息佇列獲取訊息（ Message msg = queue.next()這行程式碼）

/**
     * Run the message queue in this thread. Be sure to call
     * {@link #quit()} to end the 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.");
        }
        //  拿到當前looper的MessageQueue物件
        final MessageQueue queue = me.mQueue;

        Binder.clearCallingIdentity();
        final long ident = Binder.clearCallingIdentity();
        // 死迴圈
        for (;;) {
            // 關鍵程式碼，不斷的去獲取訊息
            Message msg = queue.next();
            if (msg == null) {
                // No message indicates that the message queue is quitting.
                return;
            }
           .....
           .....
           .....
            try {
            //  target就是繫結的Handler
                msg.target.dispatchMessage(msg);
                end = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis();
            } finally {
                if (traceTag != 0) {
                    Trace.traceEnd(traceTag);
                }
            }
            ......
            ......
            ......
            msg.recycleUnchecked();
        }
    }

看到這裡大致明白了，loop()方法裡不斷的去獲取訊息佇列中的訊息，之後呼叫了Handler的dispatchMessage()方法。 我們看看dispatchMessage()做了哪些操作：

/**
     * Handle system messages here.
     */
    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();
    }

第一個if語句判斷了訊息是否存在回撥方法，存在的話執行handleCallback()方法，接著執行回撥run方法。當Handler的mCallback不為空時，則回撥方法mCallback.handleMessage(msg)； 最後呼叫Handler自身的回撥方法handleMessage()，該方法預設為空，Handler子類通過覆寫該方法來完成具體的邏輯。