Android 異步消息處理機制 深入理解 Looper、Handler、Message、MessageQueue四者關(guān)系

相信很多人同學面試肯定都被問到過，請問Android中的Looper , Handler , Message，MessageQueue有什么關(guān)系？本文目的首先為大家從源碼角度介紹4者關(guān)系，然后給出一個容易記憶的結(jié)論。

1、 概述

Handler 、 Looper 、Message、MessageQueue 這四者都與Android異步消息處理線程相關(guān)的概念。那么什么叫異步消息處理線程呢？異步消息處理線程啟動后會進入一個無限的循環(huán)體之中，每循環(huán)一次，從其內(nèi)部的消息隊列中取出一個消息，然后回調(diào)相應(yīng)的消息處理函數(shù)，執(zhí)行完成一個消息后則繼續(xù)循環(huán)。若消息隊列為空，線程則會阻塞等待。說了這一堆，那么和Handler 、 Looper 、Message有啥關(guān)系？其實Looper負責的就是創(chuàng)建一個MessageQueue，然后進入一個無限循環(huán)體不斷從該MessageQueue中讀取消息，而消息的創(chuàng)建者就是一個或多個Handler 。

2、 源碼解析

1、Looper

對于Looper主要是prepare()和loop()兩個方法。首先看prepare()方法

public static final void prepare() {  
    //sThreadLocal是一個ThreadLocal對象，可以在一個線程中存儲變量
    //判斷了sThreadLocal是否為null，否則拋出異常。這也就說明了Looper.prepare()方法不能被調(diào)用兩次，同時也保證了一個線程中只有一個Looper實例~相信有些哥們一定遇到這個錯誤
    if (sThreadLocal.get() != null) {  
       throw new RuntimeException("Only one Looper may be created per thread");  
    }
    //將一個Looper的實例放入了ThreadLocal  
    sThreadLocal.set(new Looper(true));  
}

下面看Looper的構(gòu)造方法：

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

在構(gòu)造方法中，創(chuàng)建了一個MessageQueue（消息隊列）。然后我們看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實例中的mQueue（消息隊列） 
    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();  
    //進入了我們所說的無限循環(huán)
        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);  
           }  
           //調(diào)用 msg.target.dispatchMessage(msg);把消息交給msg的target的dispatchMessage方法去處理。Msg的target是什么呢？其實就是handler對象，下面會進行分析
           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);  
           }   
           //釋放消息占據(jù)的資源
           msg.recycle();  
      }  
}

接下來我們看下myLooper() 方法

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

此方法直接返回了sThreadLocal存儲的Looper實例，如果me為null則拋出異常，也就是說looper方法必須在prepare方法之后運行。

Looper主要作用：

  1. 與當前線程綁定，保證一個線程只會有一個Looper實例，同時一個Looper實例也只有一個MessageQueue。
  2. loop()方法，不斷從MessageQueue中去取消息，交給消息的target屬性的dispatchMessage去處理。好了，我們的異步消息處理線程已經(jīng)有了消息隊列（MessageQueue），也有了在無限循環(huán)體中取出消息的哥們，現(xiàn)在缺的就是發(fā)送消息的對象了，于是乎：Handler登場了。

3、Handler

使用Handler之前，我們都是初始化一個實例，比如用于更新UI線程，我們會在聲明的時候直接初始化，或者在onCreate中初始化Handler實例。所以我們首先看Handler的構(gòu)造方法，看其如何與MessageQueue聯(lián)系上的，它在子線程中發(fā)送的消息（一般發(fā)送消息都在非UI線程）怎么發(fā)送到MessageQueue中的

public Handler() {  
    this(null, false);  
}  
public Handler(Callback callback, boolean async) {  
    if (FIND_POTENTIAL_LEAKS) {  
        final Class<? extends Handler> klass = getClass();  
            if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&  (klass.getModifiers() & Modifier.STATIC) == 0) {  
                Log.w(TAG, "The following Handler class should be static or leaksmight occur: " +  klass.getCanonicalName());  
            }  
    }  
    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;  
}

通過Looper.myLooper()獲取了當前線程保存的Looper實例，然后又獲取了這個Looper實例中保存的MessageQueue（消息隊列），這樣就保證了handler的實例與我們Looper實例中MessageQueue關(guān)聯(lián)上了。

然后看我們最常用的sendMessage方法

public final boolean sendMessage(Message msg)  
{  
     return sendMessageDelayed(msg, 0);  
}  
public final boolean sendEmptyMessageDelayed(int what, long delayMillis) {  
     Message msg = Message.obtain();  
     msg.what = what;  
     return sendMessageDelayed(msg, delayMillis);  
} 
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);  
}

輾轉(zhuǎn)反則最后調(diào)用了sendMessageAtTime，在此方法內(nèi)部有直接獲取MessageQueue然后調(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);  
}

enqueueMessage中首先為meg.target賦值為this，【如果大家還記得Looper的loop方法會取出每個msg然后交給msg,target.dispatchMessage(msg)去處理消息】，也就是把當前的handler作為msg的target屬性。最終會調(diào)用queue的enqueueMessage的方法，也就是說handler發(fā)出的消息，最終會保存到消息隊列中去。

現(xiàn)在已經(jīng)很清楚了Looper會調(diào)用prepare()和loop()方法，在當前執(zhí)行的線程中保存一個Looper實例，這個實例會保存一個MessageQueue對象，然后當前線程進入一個無限循環(huán)中去，不斷從MessageQueue中讀取Handler發(fā)來的消息。然后再回調(diào)創(chuàng)建這個消息的handler中的dispathMessage方法，下面我們趕快去看一看這個方法：

public void dispatchMessage(Message msg) {  
    if (msg.callback != null) {  
        handleCallback(msg);  
    } else {  
        if (mCallback != null) {  
           if (mCallback.handleMessage(msg)) {  
               return;  
    }   
    handleMessage(msg);  
}

可以看到，上面調(diào)用了handleMessage方法，下面我們?nèi)タ催@個方法：

/** 
  * Subclasses must implement this to receive messages. 
  */  
public void handleMessage(Message msg) {  
}

可以看到這是一個空方法，為什么呢，因為消息的最終回調(diào)是由我們控制的，我們在創(chuàng)建handler的時候都是復(fù)寫handleMessage方法，然后根據(jù)msg.what進行消息處理。
例如：

private Handler mHandler = new Handler()  
{  
   public void handleMessage(android.os.Message msg)  
   {  
       switch (msg.what)  
       {  
           case value:  
           //do something       
           break;  
           default:  
           break;  
       }  
   };  
};

到此，這個流程已經(jīng)解釋完畢，讓我們首先總結(jié)一下

  1. 首先Looper.prepare()在本線程中保存一個Looper實例，然后該實例中保存一個MessageQueue對象；因為Looper.prepare()在一個線程中只能調(diào)用一次，所以MessageQueue在一個線程中只會存在一個。
  2. Looper.loop()會讓當前線程進入一個無限循環(huán)，不端從MessageQueue的實例中讀取消息，然后回調(diào)msg.target.dispatchMessage(msg)方法。
  3. Handler的構(gòu)造方法，會首先得到當前線程中保存的Looper實例，進而與Looper實例中的MessageQueue想關(guān)聯(lián)。
  4. Handler的sendMessage方法，會給msg的target賦值為handler自身，然后加入MessageQueue中。
  5. 在構(gòu)造Handler實例時，我們會重寫handleMessage方法，也就是msg.target.dispatchMessage(msg)最終調(diào)用的方法。
    好了，總結(jié)完成，大家可能還會問，那么在Activity中，我們并沒有顯示的調(diào)用Looper.prepare()和Looper.loop()方法，為啥Handler可以成功創(chuàng)建呢，這是因為在Activity的啟動代碼中，已經(jīng)在當前UI線程調(diào)用了Looper.prepare()和Looper.loop()方法。

4、Handler post

今天有人問我，你說Handler的post方法創(chuàng)建的線程和UI線程有什么關(guān)系？
其實這個問題也是出現(xiàn)這篇博客的原因之一；這里需要說明，有時候為了方便，我們會直接寫如下代碼：

mHandler.post(new Runnable()  
{  
   @Override  
   public void run()  
   {  
       Log.e("TAG", Thread.currentThread().getName());  
       mTxt.setText("yoxi");  
   }  
});

然后run方法中可以寫更新UI的代碼，其實這個Runnable并沒有創(chuàng)建什么線程，而是發(fā)送了一條消息，下面看源碼：

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

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

可以看到，在getPostMessage中，得到了一個Message對象，然后將我們創(chuàng)建的Runable對象作為callback屬性，賦值給了此message.
注：產(chǎn)生一個Message對象，可以new ，也可以使用Message.obtain()方法；兩者都可以，但是更建議使用obtain方法，因為Message內(nèi)部維護了一個Message池用于Message的復(fù)用，避免使用new 重新分配內(nèi)存。

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

最終和handler.sendMessage一樣，調(diào)用了sendMessageAtTime，然后調(diào)用了enqueueMessage方法，給msg.target賦值為handler，最終加入MessagQueue.
可以看到，這里msg的callback和target都有值，那么會執(zhí)行哪個呢？
其實上面已經(jīng)貼過代碼，就是dispatchMessage方法：

public void dispatchMessage(Message msg) {  
     if (msg.callback != null) {  
        handleCallback(msg);  
     } else {  
          if (mCallback != null) {  
               if (mCallback.handleMessage(msg)) {  
                   return;  
               }  
           }  
     handleMessage(msg);  
     }  
}

第2行，如果不為null，則執(zhí)行callback回調(diào)，也就是我們的Runnable對象。
好了，關(guān)于Looper , Handler , Message 這三者關(guān)系上面已經(jīng)敘述的非常清楚了。
最后來張圖解：



希望圖片可以更好的幫助大家的記憶~~

5、后話

其實Handler不僅可以更新UI，你完全可以在一個子線程中去創(chuàng)建一個Handler，然后使用這個handler實例在任何其他線程中發(fā)送消息，最終處理消息的代碼都會在你創(chuàng)建Handler實例的線程中運行。

new Thread()  
{  
      private Handler handler;  
      public void run()  
      {  
          Looper.prepare();   
          handler = new Handler()  
          {  
              public void handleMessage(android.os.Message msg)  
              {  
                  Log.e("TAG",Thread.currentThread().getName());  
              };  
           };
       Looper.loop();                                                                              
}

寫到最后

以前害怕去看android源碼，還有就是覺得看著無趣。那是因為沒找到方法，現(xiàn)在根據(jù)大神們的源碼分析去看，感覺還是蠻有趣的耶。本文就是根據(jù)csdn博客大神張鴻洋的源碼分析寫的。其實也就改了一點點啦。。。
原文地址：
【張鴻洋的博客】
http://blog.csdn.net/lmj623565791/article/details/38377229

最后編輯于 ：
?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請聯(lián)系作者
【社區(qū)內(nèi)容提示】社區(qū)部分內(nèi)容疑似由AI輔助生成，瀏覽時請結(jié)合常識與多方信息審慎甄別。
平臺聲明：文章內(nèi)容（如有圖片或視頻亦包括在內(nèi)）由作者上傳并發(fā)布，文章內(nèi)容僅代表作者本人觀點，簡書系信息發(fā)布平臺，僅提供信息存儲服務(wù)。

相關(guān)閱讀更多精彩內(nèi)容

友情鏈接更多精彩內(nèi)容