Handler Looper MessageQueue 深度总结

最新推荐文章于 2021-10-14 16:33:39 发布

原创最新推荐文章于 2021-10-14 16:33:39 发布 · 661 阅读

0 ·

CC 4.0 BY-SA版权

Android Basic Technology 专栏收录该内容

121 篇文章

订阅专栏

本文详细解析了Looper、Handler和MessageQueue的工作原理及它们之间的关系。解释了Looper如何与线程绑定并不断从MessageQueue中读取消息，Handler如何发送消息及消息处理流程。

这三者啥关系：

其实Looper负责的就是创建一个MessageQueue，然后进入一个无限循环体不断从该MessageQueue中读取消息，而消息的创建者就是一个或多个Handler，通过回调的方式让msg的创建者去执行消息的处理方法。

Looper主要作用：
1、与当前线程绑定，保证一个线程只会有一个Looper实例，同时一个Looper实例也只有一个MessageQueue。
2、 loop()方法，不断从MessageQueue中去取消息，交给消息的target属性的dispatchMessage去处理。

一个线程对应一个Looper，一个Looper对应一个MessageQueue。

流程总结：

1、首先Looper.prepare()在本线程中保存一个Looper实例，然后该实例中保存一个MessageQueue对象；因为Looper.prepare()在一个线程中只能调用一次，所以MessageQueue在一个线程中只会存在一个。

2、Looper.loop()会让当前线程进入一个无限循环，不端从MessageQueue的实例中读取消息，然后回调msg.target.dispatchMessage(msg)方法。

3、Handler的构造方法，会首先得到当前线程中保存的Looper实例，进而与Looper实例中的MessageQueue想关联。

4、Handler的sendMessage方法，会给msg的target赋值为handler自身，然后加入MessageQueue中。

5、在构造Handler实例时，我们会重写handleMessage方法，也就是msg.target.dispatchMessage(msg)最终调用的方法。

1、我们来看看Looper的Prepare方法：首先使用ThreadLocal.get检测当前线程是否已经存储Looper变量，如果没有就新建一个Looper实例，如果存在就报错，所以Looper只能Prepare一次哦。跟进去看Looper中只有一个MessageQueue。

[java]view plaincopy 
   
 public static final void prepare() {  
         if (sThreadLocal.get() != null) {  
             throw new RuntimeException("Only one Looper may be created per thread");  
         }  
         sThreadLocal.set(new Looper(true));  
 }  

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

2、Looper.loop()会让当前线程进入一个无限循环，不断从MessageQueue的实例中读取消息，然后回调msg.target.dispatchMessage(msg)方法。而msg.target就是我们可爱而又勤劳的的Handler。请看下面的分析。

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

 

3、Handler的sendMessage方法，会给msg的target赋值为handler自身，然后加入MessageQueue中。辗转反则最后调用了sendMessageAtTime，在此方法内部有直接获取MessageQueue然后调用了enqueueMessage方法。

Handler的sendMessage那一大堆方法都会执行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);
    }

enqueueMessage中首先为meg.target赋值为this

【如果大家还记得Looper的loop方法会取出每个msg然后交给msg,target.dispatchMessage(msg)

去处理消息】，也就是把当前的handler作为msg的target属性。最终会调用queue的enqueueMessage的方法，也就是说handler发出的消息，最终会

保存到消息队列中去。我们再来看看此方法：

[java]view plaincopy 
   
 private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {  
        msg.target = this;  
        if (mAsynchronous) {  
            msg.setAsynchronous(true);  
        }  
        return queue.enqueueMessage(msg, uptimeMillis);  
    }  

 

4、我们来看看最终执行的这个方法dispatchMessage，这个方法提供了2条执行路线！

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

第一条：msg.callback!=null 这个msg.callback就是我们post时扔进去的Runnable,这个可以最优先执行的！

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

其中使用Message.obtain()方法；两者都可以，但是更建议使用obtain方法，因为Message内部维护了一个Message池用于Message的复用，避免使用new 重新分配内存。

第二条：mCallback是啥腻，是我们构造函数时可以选择扔进去的Callback,这个是其次优先执行的。

    public Handler(Looper looper, Callback callback, boolean async) {
        mLooper = looper;
        mQueue = looper.mQueue;
        mCallback = callback;
        mAsynchronous = async;
    }

handleMessage是我们重写Handler时经常实现去处理msg的方法，是最后执行的函数哦，注意观察第二条的return。

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

那么如果有人问你如何让handleMessage失效，你会回答了吧！

好了，总结完成，大家可能还会问，那么在Activity中，我们并没有显示的调用Looper.prepare()和Looper.loop()方法，为啥Handler可以成功创建呢，这是因为在Activity的启动代码中，已经在当前UI线程调用了Looper.prepare()和Looper.loop()方法。

好了，关于Looper , Handler , Message 这三者关系上面已经叙述的非常清楚了。

最后来张图解：

希望图片可以更好的帮助大家的记忆~~

4、后话

其实Handler不仅可以更新UI，你完全可以在一个子线程中去创建一个Handler，然后使用这个handler实例在任何其他线程中发送消息，最终处理消息的代码都会在你创建Handler实例的线程中运行。

[java]view plaincopy 
   
 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();                                                                                   }              