在Android中，當要更新ui的時候，我們必須要在主執行緒中進行更新，原因時當主執行緒被阻塞了5s以上就會出現anr異常，會導致程式崩潰。所以一些耗時的操作必須要放在子執行緒中，但是在子執行緒中又不能做更新ui的操作，所以為了解決這個問題，Android設計了handler機制，handler的出現建立起了主執行緒與子程序之間的通訊橋樑，使得ui更新問題得到改善，下面就來剖析一下handler。ActivityThread啟動了應用程式的主執行緒，在ActivityThread的main方法中：

public static final void main(String[] args) {
        SamplingProfilerIntegration.start();
        Process.setArgV0("<pre-initialized>");
        Looper.prepareMainLooper();
        if (sMainThreadHandler == null) {
            sMainThreadHandler = new Handler();
        }
        ActivityThread thread = new ActivityThread();
        thread.attach(false);
        if (false) {
            Looper.myLooper().setMessageLogging(new
                    LogPrinter(Log.DEBUG, "ActivityThread"));
        }
        Looper.loop();
       ......
}
 

從上述程式碼可以看出，首先要執行Looper.prepareMainLooper();操作，然後進入loop進行迴圈。在prepareMainLooper中，呼叫prepare方法使用sThreadLocal給當前執行緒設定一個Looper，如果當前執行緒中沒有，就初始化一個Looper，在Looper的構造方法中順便建立了一個MessageQueue。細心的讀者可能會注意到prepareMainLooper和prepare方法都是static的，sThreadLocal也是個靜態變數，首先不考慮子執行緒存在的情況，只考慮主執行緒，所以無論我們在應用程式的哪個地方呼叫Looper.prepareMainLooper();通過sThreadLocal.get()得到的都是同一個looper物件，這樣就可以保證一個執行緒中只有一個Looper物件，那麼也就意味著一個執行緒中只有一個MessageQueue。

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

private Looper(boolean quitAllowed) {
        mQueue = new MessageQueue(quitAllowed);
        mThread = Thread.currentThread();
}
 

執行完 Looper.prepareMainLooper()之後，就是開始Looper.loop()進行訊息的迴圈讀取並且進行分發，這個稍後分析完Handler後再分析。

下面我們再分析一下Handler。
在程式碼中我們經常的這樣用：

private Handler handler = new Handler(){
    public void handleMessage(Message msg) {
        // process incoming messages here
    }
}

public Handler(Callback callback, boolean async) {
    ......
    mLooper = Looper.myLooper();
    if (mLooper == null) {
        throw new RuntimeException(
            "Can't create handler inside thread that has not called Looper.prepare()");
    }
    mQueue = mLooper.mQueue;
    mCallback = callback;
    mAsynchronous = async;
}

在Handler的構造方法中，通過Looper.myLooper()獲取本執行緒中唯一的一個Looper物件，並且初始化hanlder中的訊息佇列，這個訊息佇列和Looper中的一開始初始化的訊息佇列是同一個。
當呼叫handler.sendMessage或者sendEmpty方法時，最終要走的方法都是sendMessageAtTime方法：

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

在enqueueMessage方法中，給當前要加入訊息佇列的msg設定一個target為this，這個this也就是當前的handler物件，主要是為了後面的looper迴圈出訊息後，方便知道這個msg向何處分發，該由哪個handler進行處理。接著就呼叫MessageQueue的enqueueMessage方法將msg加入佇列中。

boolean enqueueMessage(Message msg, long when) {
    ......
    synchronized (this) {
        ......
        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 {
            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;
        }
        if (needWake) {
            nativeWake(mPtr);
        }
    }
    return true;
}

當訊息對列中沒有任何msg的時候，當前加入的msg就應該是佇列的隊頭，並且從else語句我們可以看出，整個訊息對列是個迴圈對列。此時訊息對列中已經有了msg，那麼這個msg應該被接受並進行分發處理，在ActivityThread中呼叫了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.");
    }
    final MessageQueue queue = me.mQueue;

    // Make sure the identity of this thread is that of the local process,
    // and keep track of what that identity token actually is.
    Binder.clearCallingIdentity();
    final long ident = Binder.clearCallingIdentity();

    for (;;) {
        Message msg = queue.next(); // might block
        if (msg == null) {
            return;
        }
        Printer logging = me.mLogging;
        .......
        msg.target.dispatchMessage(msg);

        final long newIdent = Binder.clearCallingIdentity();
        if (ident != newIdent) {

        }
        msg.recycle();
    }
}

其中的for迴圈為死迴圈，有人可能納悶了，looper.loop()是執行在主執行緒中的，而其中有是個死迴圈，不是說好的主執行緒中不能做超時的操作嗎？呵呵，因為在迴圈中輪詢訊息佇列中的訊息時候，如果沒有訊息，則會被阻塞。所以這裡不用擔心anr的問題。通過queue.next()獲取出msg後，通過msg.target.dispatchMessage(msg)處理這個訊息，這個msg.target就是要處理訊息的handle，這也就是為啥在handler中要重寫dispatchMessage方法的原因。最後呼叫recycle釋放訊息，之所以要recycle一下，是因為Message可以不用new的方式，也可以通過Message.obtain方法從訊息池中獲取一個，因為訊息池中的訊息個數有限，如果用完訊息後，不及時的recycle的 話，就會造成msg物件不能重複利用。

接下來具體的分析下queue.next()這個方法，在註釋中我們看到，這個方法有可能會被阻塞，阻塞的原因是訊息佇列中沒有訊息。

Message next() {
    int pendingIdleHandlerCount = -1; // -1 only during first iteration
    int nextPollTimeoutMillis = 0;
    for (;;) {
        if (nextPollTimeoutMillis != 0) {
            Binder.flushPendingCommands();
        }

        // We can assume mPtr != 0 because the loop is obviously still running.
        // The looper will not call this method after the loop quits.
        nativePollOnce(mPtr, 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 (false) Log.v("MessageQueue", "Returning message: " + msg);
                    msg.markInUse();
                    return msg;
                }
            } else {
                // No more messages.
                nextPollTimeoutMillis = -1;
            }

            // Process the quit message now that all pending messages have been handled.
            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.
            if (pendingIdleHandlerCount < 0
                    && (mMessages == null || now < mMessages.when)) {
                pendingIdleHandlerCount = mIdleHandlers.size();
            }
            if (pendingIdleHandlerCount <= 0) {
                // No idle handlers to run.  Loop and wait some more.
                mBlocked = true;
                continue;
            }

            if (mPendingIdleHandlers == null) {
                mPendingIdleHandlers = new IdleHandler[Math.max(pendingIdleHandlerCount, 4)];
            }
            mPendingIdleHandlers = mIdleHandlers.toArray(mPendingIdleHandlers);
        }

        // Run the idle handlers.
        // We only ever reach this code block during the first iteration.
        for (int i = 0; i < pendingIdleHandlerCount; i++) {
            final IdleHandler idler = mPendingIdleHandlers[i];
            mPendingIdleHandlers[i] = null; // release the reference to the handler
            boolean keep = false;
            try {
                keep = idler.queueIdle();
            } catch (Throwable t) {
                Log.wtf("MessageQueue", "IdleHandler threw exception", t);
            }

            if (!keep) {
                synchronized (this) {
                    mIdleHandlers.remove(idler);
                }
            }
        }

        // Reset the idle handler count to 0 so we do not run them again.
        pendingIdleHandlerCount = 0;

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

nativePollOnce(mPtr, nextPollTimeoutMillis)當輪詢沒有訊息時，會進行阻塞。訊息喚醒和阻塞機制將會在下一篇文章進行介紹，請大家關注。

最後對Handler做一下總結。從訊息的分發一直到訊息的處理，先後接觸到的幾個名詞有Looper、MessageQueue、Thread、Handler、Message。

• Looper：負責初始化訊息佇列，並不斷的從訊息佇列中輪詢訊息。
• MessageQueue ： 是訊息佇列，存放在handler傳送過來的訊息。
• Thread：當前訊息佇列和looper所操作的場所或者說執行的環境。
• Handler：負責訊息的傳送和處理。
• Message：一個更新UI的訊息，由handler發出，由MessageQueue列隊。

訊息處理機制大概的一個處理過程如下：

補充：在子執行緒中要更新ui的時候，可以這樣處理

    class LooperThread extends Thread {
        public Handler mHandler;
       public void run() {
           Looper.prepare();
            mHandler = new Handler() {
                public void handleMessage(Message msg) {
                   // process incoming messages here
                }
            };
            Looper.loop();
        }
    }