本文主要是對(duì)Handler和消息循環(huán)的實(shí)現(xiàn)原理進(jìn)行源碼分析，如果不熟悉Handler可以參見博文《 Android中Handler的使用》，里面對(duì)Android為何以引入Handler機(jī)制以及如何使用Handler做了講解。

概括來(lái)說(shuō)，Handler是Android中引入的一種讓開發(fā)者參與處理線程中消息循環(huán)的機(jī)制。我們?cè)谑褂肏andler的時(shí)候與Message打交道最多，Message是Hanlder機(jī)制向開發(fā)人員暴露出來(lái)的相關(guān)類，可以通過(guò)Message類完成大部分操作Handler的功能。但作為程序員，我不能只知道怎么用Handler，還要知道其內(nèi)部如何實(shí)現(xiàn)的。Handler的內(nèi)部實(shí)現(xiàn)主要涉及到如下幾個(gè)類: Thread、MessageQueue和Looper。這幾類之間的關(guān)系可以用如下的圖來(lái)簡(jiǎn)單說(shuō)明：

Thread是最基礎(chǔ)的，Looper和MessageQueue都構(gòu)建在Thread之上，Handler又構(gòu)建在Looper和MessageQueue之上，我們通過(guò)Handler間接地與下面這幾個(gè)相對(duì)底層一點(diǎn)的類打交道。

MessageQueue

MessageQueue源碼鏈接

最基礎(chǔ)最底層的是Thread，每個(gè)線程內(nèi)部都維護(hù)了一個(gè)消息隊(duì)列——MessageQueue。消息隊(duì)列MessageQueue，顧名思義，就是存放消息的隊(duì)列（好像是廢話…）。那隊(duì)列中存儲(chǔ)的消息是什么呢？假設(shè)我們?cè)赨I界面上單擊了某個(gè)按鈕，而此時(shí)程序又恰好收到了某個(gè)廣播事件，那我們?nèi)绾翁幚磉@兩件事呢？ 因?yàn)橐粋€(gè)線程在某一時(shí)刻只能處理一件事情，不能同時(shí)處理多件事情，所以我們不能同時(shí)處理按鈕的單擊事件和廣播事件，我們只能挨個(gè)對(duì)其進(jìn)行處理，只要挨個(gè)處理就要有處理的先后順序。 為此Android把UI界面上單擊按鈕的事件封裝成了一個(gè)Message，將其放入到MessageQueue里面去，即將單擊按鈕事件的Message入棧到消息隊(duì)列中，然后再將廣播事件的封裝成以Message，也將其入棧到消息隊(duì)列中。也就是說(shuō)一個(gè)Message對(duì)象表示的是線程需要處理的一件事情，消息隊(duì)列就是一堆需要處理的Message的池。線程Thread會(huì)依次取出消息隊(duì)列中的消息，依次對(duì)其進(jìn)行處理。MessageQueue中有兩個(gè)比較重要的方法，一個(gè)是enqueueMessage方法，一個(gè)是next方法。enqueueMessage方法用于將一個(gè)Message放入到消息隊(duì)列MessageQueue中，next方法是從消息隊(duì)列MessageQueue中阻塞式地取出一個(gè)Message。在Android中，消息隊(duì)列負(fù)責(zé)管理著頂級(jí)程序?qū)ο螅ˋctivity、BroadcastReceiver等）以及由其創(chuàng)建的所有窗口。需要注意的是，消息隊(duì)列不是Android平臺(tái)特有的，其他的平臺(tái)框架也會(huì)用到消息隊(duì)列，比如微軟的MFC框架等。

Looper

Looper源碼鏈接

消息隊(duì)列MessageQueue只是存儲(chǔ)Message的地方，真正讓消息隊(duì)列循環(huán)起來(lái)的是Looper，這就好比消息隊(duì)列MessageQueue是個(gè)水車，那么Looper就是讓水車轉(zhuǎn)動(dòng)起來(lái)的河水，如果沒有河水，那么水車就是個(gè)靜止的擺設(shè)，沒有任何用處，Looper讓MessageQueue動(dòng)了起來(lái)，有了活力。

Looper是用來(lái)使線程中的消息循環(huán)起來(lái)的。默認(rèn)情況下當(dāng)我們創(chuàng)建一個(gè)新的線程的時(shí)候，這個(gè)線程里面是沒有消息隊(duì)列MessageQueue的。為了能夠讓線程能夠綁定一個(gè)消息隊(duì)列，我們需要借助于Looper：首先我們要調(diào)用Looper的prepare方法，然后調(diào)用Looper的Loop方法。典型的代碼如下所示：

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

需要注意的是Looper.prepare()和Looper.loop()都是在新線程的run方法內(nèi)調(diào)用的，這兩個(gè)方法都是靜態(tài)方法。我們通過(guò)查看Looper的源碼可以發(fā)現(xiàn)，Looper的構(gòu)造函數(shù)是private的，也就是在該類的外部不能用new Looper()的形式得到一個(gè)Looper對(duì)象。根據(jù)我們上面的描述，我們知道線程Thread和Looper是一對(duì)一綁定的，也就是一個(gè)線程中最多只有一個(gè)Looper對(duì)象，這也就能解釋Looper的構(gòu)造函數(shù)為什么是private的了，我們只能通過(guò)工廠方法Looper.myLooper()這個(gè)靜態(tài)方法獲取當(dāng)前線程所綁定的Looper。

Looper通過(guò)如下代碼保存了對(duì)當(dāng)前線程的引用：

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

所以在Looper對(duì)象中通過(guò)sThreadLocal就可以找到其綁定的線程。ThreadLocal中有個(gè)set方法和get方法，可以通過(guò)set方法向ThreadLocal中存入一個(gè)對(duì)象，然后可以通過(guò)get方法取出存入的對(duì)象。ThreadLocal在new的時(shí)候使用了泛型，從上面的代碼中我們可以看到此處的泛型類型是Looper，也就是我們通過(guò)ThreadLocal的set和get方法只能寫入和讀取Looper對(duì)象類型，如果我們調(diào)用其ThreadLocal的set方法傳入一個(gè)Looper，將該Looper綁定給了該線程，相應(yīng)的get就能獲得該線程所綁定的Looper對(duì)象。

我們?cè)賮?lái)看一下Looper.prepare()，該方法是讓Looper做好準(zhǔn)備，只有Looper準(zhǔn)備好了之后才能調(diào)用Looper.loop()方法，Looper.prepare()的代碼如下:

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

上面的代碼首先通過(guò)sThreadLocal.get()拿到線程sThreadLocal所綁定的Looper對(duì)象，由于初始情況下sThreadLocal并沒有綁定Looper，所以第一次調(diào)用prepare方法時(shí)，sThreadLocal.get()返回null，不會(huì)拋出異常。重點(diǎn)是下面的代碼sThreadLocal.set(new Looper(quitAllowed))，首先通過(guò)私有的構(gòu)造函數(shù)創(chuàng)建了一個(gè)Looper對(duì)象的實(shí)例，然后通過(guò)sThreadLocal的set方法將該Looper綁定到sThreadLocal中。
這樣就完成了線程sThreadLocal與Looper的雙向綁定：
a. 在Looper內(nèi)通過(guò)sThreadLocal可以獲取Looper所綁定的線程；
b.線程sThreadLocal通過(guò)sThreadLocal.get()方法可以獲取該線程所綁定的Looper對(duì)象。

上面的代碼執(zhí)行了Looper的構(gòu)造函數(shù)，我們看一下其代碼：

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

我們可以看到在其構(gòu)造函數(shù)中實(shí)例化一個(gè)消息隊(duì)列MessageQueue，并將其賦值給其成員字段mQueue,這樣Looper也就與MessageQueue通過(guò)成員字段mQueue進(jìn)行了關(guān)聯(lián)。

在執(zhí)行完了Looper.prepare()之后，我們就可以在外部通過(guò)調(diào)用Looper.myLooper()獲取當(dāng)前線程綁定的Looper對(duì)象。
myLooper的代碼如下所示：

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

需要注意的是，在一個(gè)線程中，只能調(diào)用一次Looper.prepare()，因?yàn)樵诘谝淮握{(diào)用了Looper.prepare()之后，當(dāng)前線程就已經(jīng)綁定了Looper，在該線程內(nèi)第二次調(diào)用Looper.prepare()方法的時(shí)候，sThreadLocal.get()會(huì)返回第一次調(diào)用prepare的時(shí)候綁定的Looper，不是null，這樣就會(huì)走的下面的代碼throw new RuntimeException(“Only one Looper may be created per thread”)，從而拋出異常，告訴開發(fā)者一個(gè)線程只能綁定一個(gè)Looper對(duì)象。

在調(diào)用了Looper.prepare()方法之后，當(dāng)前線程和Looper就進(jìn)行了雙向的綁定，這時(shí)候我們就可以調(diào)用Looper.loop()方法讓消息隊(duì)列循環(huán)起來(lái)了。
需要注意的是Looper.loop()應(yīng)該在該Looper所綁定的線程中執(zhí)行。

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) {
                // No message indicates that the message queue is quitting.
                return;
            }

            // This must be in a local variable, in case a UI event sets the logger
            Printer logging = me.mLogging;
            if (logging != null) {
                logging.println(">>>>> Dispatching to " + msg.target + " " +
                        msg.callback + ": " + msg.what);
            }

            //注意下面這行
            msg.target.dispatchMessage(msg);

            if (logging != null) {
                logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
            }

            // Make sure that during the course of dispatching the
            // identity of the thread wasn't corrupted.
            final long newIdent = Binder.clearCallingIdentity();
            if (ident != newIdent) {
                Log.wtf(TAG, "Thread identity changed from 0x"
                        + Long.toHexString(ident) + " to 0x"
                        + Long.toHexString(newIdent) + " while dispatching to "
                        + msg.target.getClass().getName() + " "
                        + msg.callback + " what=" + msg.what);
            }

            msg.recycleUnchecked();
        }
}

上面有幾行代碼是關(guān)鍵代碼:
1. final MessageQueue queue = me.mQueue;
變量me是通過(guò)靜態(tài)方法myLooper()獲得的當(dāng)前線程所綁定的Looper，me.mQueue是當(dāng)前線程所關(guān)聯(lián)的消息隊(duì)列。
2. for (;;)
我們發(fā)現(xiàn)for循環(huán)沒有設(shè)置循環(huán)終止的條件，所以這個(gè)for循環(huán)是個(gè)死循環(huán)。
3. Message msg = queue.next(); // might block
我們通過(guò)消息隊(duì)列MessageQueue的next方法從消息隊(duì)列中取出一條消息，如果此時(shí)消息隊(duì)列中有Message，那么next方法會(huì)立即返回該Message，如果此時(shí)消息隊(duì)列中沒有Message，那么next方法就會(huì)阻塞式地等待獲取Message。
4. msg.target.dispatchMessage(msg);
msg的target屬性是Handler，該代碼的意思是讓Message所關(guān)聯(lián)的Handler通過(guò)dispatchMessage方法讓Handler處理該Message，關(guān)于Handler的dispatchMessage方法將會(huì)在下面詳細(xì)介紹。

Handler

Handler源碼鏈接

Handler是暴露給開發(fā)者最頂層的一個(gè)類，其構(gòu)建在Thread、Looper與MessageQueue之上。
Handler具有多個(gè)構(gòu)造函數(shù)，簽名分別如下所示：
1. publicHandler()
2. publicHandler(Callbackcallback)
3. publicHandler(Looperlooper)
4. publicHandler(Looperlooper, Callbackcallback)
第1個(gè)和第2個(gè)構(gòu)造函數(shù)都沒有傳遞Looper，這兩個(gè)構(gòu)造函數(shù)都將通過(guò)調(diào)用Looper.myLooper()獲取當(dāng)前線程綁定的Looper對(duì)象，然后將該Looper對(duì)象保存到名為mLooper的成員字段中。
第3個(gè)和第4個(gè)構(gòu)造函數(shù)傳遞了Looper對(duì)象，這兩個(gè)構(gòu)造函數(shù)會(huì)將該Looper保存到名為mLooper的成員字段中。
第2個(gè)和第4個(gè)構(gòu)造函數(shù)還傳遞了Callback對(duì)象，Callback是Handler中的內(nèi)部接口，需要實(shí)現(xiàn)其內(nèi)部的handleMessage方法，Callback代碼如下:

public interface Callback {
        public boolean handleMessage(Message msg);
}

Handler.Callback是用來(lái)處理Message的一種手段，如果沒有傳遞該參數(shù)，那么就應(yīng)該重寫Handler的handleMessage方法，也就是說(shuō)為了使得Handler能夠處理Message，我們有兩種辦法：
1. 向Hanlder的構(gòu)造函數(shù)傳入一個(gè)Handler.Callback對(duì)象，并實(shí)現(xiàn)Handler.Callback的handleMessage方法
2. 無(wú)需向Hanlder的構(gòu)造函數(shù)傳入Handler.Callback對(duì)象，但是需要重寫Handler本身的handleMessage方法
也就是說(shuō)無(wú)論哪種方式，我們都得通過(guò)某種方式實(shí)現(xiàn)handleMessage方法，這點(diǎn)與Java中對(duì)Thread的設(shè)計(jì)有異曲同工之處。
在Java中，如果我們想使用多線程，有兩種辦法：
1. 向Thread的構(gòu)造函數(shù)傳入一個(gè)Runnable對(duì)象，并實(shí)現(xiàn)Runnable的run方法
2. 無(wú)需向Thread的構(gòu)造函數(shù)傳入Runnable對(duì)象，但是要重寫Thread本身的run方法
所以只要用過(guò)多線程Thread，應(yīng)該就對(duì)Hanlder這種需要實(shí)現(xiàn)handleMessage的兩種方式了然于心了。

我們知道通過(guò)sendMessageXXX系列方法可以向消息隊(duì)列中添加消息，我們通過(guò)源碼可以看出這些方法的調(diào)用順序，
sendMessage調(diào)用了sendMessageDelayed，sendMessageDelayed又調(diào)用了sendMessageAtTime。
Handler中還有一系列的sendEmptyMessageXXX方法，而這些sendEmptyMessageXXX方法在其內(nèi)部又分別調(diào)用了其對(duì)應(yīng)的sendMessageXXX方法。

通過(guò)以下調(diào)用關(guān)系圖我們可以看的更清楚些:

由此可見所有的sendMessageXXX方法和sendEmptyMessageXXX最終都調(diào)用了sendMessageAtTime方法。

我們?cè)賮?lái)看看postXXX方法，會(huì)發(fā)現(xiàn)postXXX方法在其內(nèi)部又調(diào)用了對(duì)應(yīng)的sendMessageXXX方法，我們可以查看下sendMessage的源碼:

public final boolean post(Runnable r)
{
       return  sendMessageDelayed(getPostMessage(r), 0);
}

可以看到內(nèi)部調(diào)用了getPostMessage方法，該方法傳入一個(gè)Runnable對(duì)象，得到一個(gè)Message對(duì)象，getPostMessage的源碼如下:

private static Message getPostMessage(Runnable r) {
        Message m = Message.obtain();
        m.callback = r;
        return m;
 }

通過(guò)上面的代碼我們可以看到在getPostMessage方法中，我們創(chuàng)建了一個(gè)Message對(duì)象，并將傳入的Runnable對(duì)象賦值給Message的callback成員字段，然后返回該Message，然后在post方法中該攜帶有Runnable信息的Message傳入到sendMessageDelayed方法中。由此我們可以看到所有的postXXX方法內(nèi)部都需要借助sendMessageXXX方法來(lái)實(shí)現(xiàn)，所以postXXX與sendMessageXXX并不是對(duì)立關(guān)系，而是postXXX依賴sendMessageXXX，所以postXXX方法可以通過(guò)sendMessageXXX方法向消息隊(duì)列中傳入消息，只不過(guò)通過(guò)postXXX方法向消息隊(duì)列中傳入的消息都攜帶有Runnable對(duì)象（Message.callback）。

我們可以通過(guò)如下關(guān)系圖看清楚postXXX系列方法與sendMessageXXX方法之間的調(diào)用關(guān)系：

通過(guò)分別分析sendEmptyMessageXXX、postXXX方法與sendMessageXXX方法之間的關(guān)系，我們可以看到在Handler中所有可以直接或間接向消息隊(duì)列發(fā)送Message的方法最終都調(diào)用了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);
}

該方法內(nèi)部調(diào)用了enqueueMessage方法，該方法的源碼如下：

private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
        //注意下面這行代碼
        msg.target = this;
        if (mAsynchronous) {
            msg.setAsynchronous(true);
        }
        //注意下面這行代碼
        return queue.enqueueMessage(msg, uptimeMillis);
}

在該方法中有兩件事需要注意：
1. msg.target = this
該代碼將Message的target綁定為當(dāng)前的Handler
2. queue.enqueueMessage
變量queue表示的是Handler所綁定的消息隊(duì)列MessageQueue，通過(guò)調(diào)用queue.enqueueMessage(msg, uptimeMillis)我們將Message放入到消息隊(duì)列中。

所以我們通過(guò)下圖可以看到完整的方法調(diào)用順序：

我們?cè)诜治鯨ooper.loop()的源碼時(shí)發(fā)現(xiàn)，Looper一直在不斷的從消息隊(duì)列中通過(guò)MessageQueue的next方法獲取Message，然后通過(guò)代碼msg.target.dispatchMessage(msg)讓該msg所綁定的Handler（Message.target）執(zhí)行dispatchMessage方法以實(shí)現(xiàn)對(duì)Message的處理。
Handler的dispatchMessage的源碼如下：

public void dispatchMessage(Message msg) {
        //注意下面這行代碼
        if (msg.callback != null) {
            handleCallback(msg);
        } else {
             //注意下面這行代碼
            if (mCallback != null) {
                if (mCallback.handleMessage(msg)) {
                    return;
                }
            }
             //注意下面這行代碼
            handleMessage(msg);
        }
}

我們來(lái)分析下這段代碼：

1.首先會(huì)判斷msg.callback存不存在，msg.callback是Runnable類型，如果msg.callback存在，那么說(shuō)明該Message是通過(guò)執(zhí)行Handler的postXXX系列方法將Message放入到消息隊(duì)列中的，這種情況下會(huì)執(zhí)行handleCallback(msg), handleCallback源碼如下：

private static void handleCallback(Message message) {
        message.callback.run();
}

這樣我們我們就清楚地看到我們執(zhí)行了msg.callback的run方法，也就是執(zhí)行了postXXX所傳遞的Runnable對(duì)象的run方法。

2.如果我們不是通過(guò)postXXX系列方法將Message放入到消息隊(duì)列中的，那么msg.callback就是null，代碼繼續(xù)往下執(zhí)行，接著我們會(huì)判斷Handler的成員字段mCallback存不存在。mCallback是Hanlder.Callback類型的，我們?cè)谏厦嫣岬竭^(guò)，在Handler的構(gòu)造函數(shù)中我們可以傳遞Hanlder.Callback類型的對(duì)象，該對(duì)象需要實(shí)現(xiàn)handleMessage方法，如果我們?cè)跇?gòu)造函數(shù)中傳遞了該Callback對(duì)象，那么我們就會(huì)讓Callback的handleMessage方法來(lái)處理Message。

3.如果我們?cè)跇?gòu)造函數(shù)中沒有傳入Callback類型的對(duì)象，那么mCallback就為null,那么我們會(huì)調(diào)用Handler自身的hanldeMessage方法，該方法默認(rèn)是個(gè)空方法，我們需要自己是重寫實(shí)現(xiàn)該方法。

綜上，我們可以看到Handler提供了三種途徑處理Message，而且處理有前后優(yōu)先級(jí)之分：首先嘗試讓postXXX中傳遞的Runnable執(zhí)行，其次嘗試讓Handler構(gòu)造函數(shù)中傳入的Callback的handleMessage方法處理，最后才是讓Handler自身的handleMessage方法處理Message。

一圖勝千言

我們?cè)诒疚挠懻摿薚hread、MessageQueue、Looper以及Hanlder的之間的關(guān)系，我們可以通過(guò)如下一張傳送帶的圖來(lái)更形象的理解他們之間的關(guān)系。

在現(xiàn)實(shí)生活的生產(chǎn)生活中，存在著各種各樣的傳送帶，傳送帶上面灑滿了各種貨物，傳送帶在發(fā)動(dòng)機(jī)滾輪的帶動(dòng)下一直在向前滾動(dòng)，不斷有新的貨物放置在傳送帶的一端，貨物在傳送帶的帶動(dòng)下送到另一端進(jìn)行收集處理。

我們可以把傳送帶上的貨物看做是一個(gè)個(gè)的Message，而承載這些貨物的傳送帶就是裝載Message的消息隊(duì)列MessageQueue。傳送帶是靠發(fā)送機(jī)滾輪帶動(dòng)起來(lái)轉(zhuǎn)動(dòng)的，我們可以把發(fā)送機(jī)滾輪看做是Looper，而發(fā)動(dòng)機(jī)的轉(zhuǎn)動(dòng)是需要電源的，我們可以把電源看做是線程Thread，所有的消息循環(huán)的一切操作都是基于某個(gè)線程的。一切準(zhǔn)備就緒，我們只需要按下電源開關(guān)發(fā)動(dòng)機(jī)就會(huì)轉(zhuǎn)動(dòng)起來(lái)，這個(gè)開關(guān)就是Looper的loop方法，當(dāng)我們按下開關(guān)的時(shí)候，我們就相當(dāng)于執(zhí)行了Looper的loop方法，此時(shí)Looper就會(huì)驅(qū)動(dòng)著消息隊(duì)列循環(huán)起來(lái)。

那Hanlder在傳送帶模型中相當(dāng)于什么呢？我們可以將Handler看做是放入貨物以及取走貨物的管道：貨物從一端順著管道劃入傳送帶，貨物又從另一端順著管道劃出傳送帶。我們?cè)趥魉蛶У囊欢朔湃胴浳锏牟僮骶拖喈?dāng)于我們調(diào)用了Handler的sendMessageXXX、sendEmptyMessageXXX或postXXX方法，這就把Message對(duì)象放入到了消息隊(duì)列MessageQueue中了。當(dāng)貨物從傳送帶的另一端順著管道劃出時(shí)，我們就相當(dāng)于調(diào)用了Hanlder的dispatchMessage方法，在該方法中我們完成對(duì)Message的處理。

啰啰嗦嗦說(shuō)了很多，希望本文對(duì)于大家理解Android中的Handler和消息循環(huán)機(jī)制有所幫助。

到此這篇關(guān)于Android Handler,Message,MessageQueue,Loper源碼解析詳解的文章就介紹到這了,更多相關(guān)Android Handler,Message,MessageQueue,Loper內(nèi)容請(qǐng)搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

最新評(píng)論